From 393d3333f6195e7b2bc4e4ca56b2d6e2f82bff82 Mon Sep 17 00:00:00 2001 From: Nico Date: Mon, 9 Dec 2024 20:02:36 +0100 Subject: [PATCH] keine ahnung --- Todo.txt | 1 + .../kotlin/com/example/fforte/MainActivity.kt | 5 + fforte_data/.obsidian/community-plugins.json | 3 + fforte_data/.obsidian/core-plugins.json | 50 +- .../.obsidian/plugins/csv-obsidian/main.js | 109618 +++++++++++++++ .../plugins/csv-obsidian/manifest.json | 10 + .../.obsidian/plugins/csv-obsidian/styles.css | 1999 + .../plugins/obsidian-csv-table/main.js | 3456 + .../plugins/obsidian-csv-table/manifest.json | 10 + .../plugins/obsidian-csv-table/styles.css | 8 + fforte_data/.obsidian/workspace.json | 47 +- fforte_data/Lupus - Tabelle exkursion -.pdf | Bin 0 -> 207307 bytes fforte_data/exkursion_2024_11_15.csv | 55 + fforte_data/exkursion_2024_11_15.csv~ | 55 + lib/screens/Excursion/excursion_main.dart | 20 +- time.txt | 1 + 16 files changed, 115300 insertions(+), 38 deletions(-) create mode 100644 android/app/src/main/kotlin/com/example/fforte/MainActivity.kt create mode 100644 fforte_data/.obsidian/community-plugins.json create mode 100644 fforte_data/.obsidian/plugins/csv-obsidian/main.js create mode 100644 fforte_data/.obsidian/plugins/csv-obsidian/manifest.json create mode 100644 fforte_data/.obsidian/plugins/csv-obsidian/styles.css create mode 100644 fforte_data/.obsidian/plugins/obsidian-csv-table/main.js create mode 100644 fforte_data/.obsidian/plugins/obsidian-csv-table/manifest.json create mode 100644 fforte_data/.obsidian/plugins/obsidian-csv-table/styles.css create mode 100644 fforte_data/Lupus - Tabelle exkursion -.pdf create mode 100644 fforte_data/exkursion_2024_11_15.csv create mode 100644 fforte_data/exkursion_2024_11_15.csv~ diff --git a/Todo.txt b/Todo.txt index 838497e..d0b3062 100644 --- a/Todo.txt +++ b/Todo.txt @@ -1,4 +1,5 @@ todo: +zu nicht nullable Texteditingcontroller ummodeln set theme in settings excursion onstepContinue if isLaststep diff --git a/android/app/src/main/kotlin/com/example/fforte/MainActivity.kt b/android/app/src/main/kotlin/com/example/fforte/MainActivity.kt new file mode 100644 index 0000000..4517d23 --- /dev/null +++ b/android/app/src/main/kotlin/com/example/fforte/MainActivity.kt @@ -0,0 +1,5 @@ +package com.example.fforte + +import io.flutter.embedding.android.FlutterActivity + +class MainActivity: FlutterActivity() diff --git a/fforte_data/.obsidian/community-plugins.json b/fforte_data/.obsidian/community-plugins.json new file mode 100644 index 0000000..6926847 --- /dev/null +++ b/fforte_data/.obsidian/community-plugins.json @@ -0,0 +1,3 @@ +[ + "csv-obsidian" +] \ No newline at end of file diff --git a/fforte_data/.obsidian/core-plugins.json b/fforte_data/.obsidian/core-plugins.json index 9405bfd..436f43c 100644 --- a/fforte_data/.obsidian/core-plugins.json +++ b/fforte_data/.obsidian/core-plugins.json @@ -1,20 +1,30 @@ -[ - "file-explorer", - "global-search", - "switcher", - "graph", - "backlink", - "canvas", - "outgoing-link", - "tag-pane", - "page-preview", - "daily-notes", - "templates", - "note-composer", - "command-palette", - "editor-status", - "bookmarks", - "outline", - "word-count", - "file-recovery" -] \ No newline at end of file +{ + "file-explorer": true, + "global-search": true, + "switcher": true, + "graph": true, + "backlink": true, + "canvas": true, + "outgoing-link": true, + "tag-pane": true, + "properties": false, + "page-preview": true, + "daily-notes": true, + "templates": true, + "note-composer": true, + "command-palette": true, + "slash-command": false, + "editor-status": true, + "bookmarks": true, + "markdown-importer": false, + "zk-prefixer": false, + "random-note": false, + "outline": true, + "word-count": true, + "slides": false, + "audio-recorder": false, + "workspaces": false, + "file-recovery": true, + "publish": false, + "sync": false +} \ No newline at end of file diff --git a/fforte_data/.obsidian/plugins/csv-obsidian/main.js b/fforte_data/.obsidian/plugins/csv-obsidian/main.js new file mode 100644 index 0000000..5087814 --- /dev/null +++ b/fforte_data/.obsidian/plugins/csv-obsidian/main.js @@ -0,0 +1,109618 @@ +'use strict'; + +var obsidian = require('obsidian'); + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +function createCommonjsModule(fn, basedir, module) { + return module = { + path: basedir, + exports: {}, + require: function (path, base) { + return commonjsRequire(path, (base === undefined || base === null) ? module.path : base); + } + }, fn(module, module.exports), module.exports; +} + +function commonjsRequire () { + throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs'); +} + +var papaparse_min = createCommonjsModule(function (module, exports) { +/* @license +Papa Parse +v5.3.0 +https://github.com/mholt/PapaParse +License: MIT +*/ +!function(e,t){module.exports=t();}(commonjsGlobal,function s(){var f="undefined"!=typeof self?self:"undefined"!=typeof window?window:void 0!==f?f:{};var n=!f.document&&!!f.postMessage,o=n&&/blob:/i.test((f.location||{}).protocol),a={},h=0,b={parse:function(e,t){var i=(t=t||{}).dynamicTyping||!1;U(i)&&(t.dynamicTypingFunction=i,i={});if(t.dynamicTyping=i,t.transform=!!U(t.transform)&&t.transform,t.worker&&b.WORKERS_SUPPORTED){var r=function(){if(!b.WORKERS_SUPPORTED)return !1;var e=(i=f.URL||f.webkitURL||null,r=s.toString(),b.BLOB_URL||(b.BLOB_URL=i.createObjectURL(new Blob(["(",r,")();"],{type:"text/javascript"})))),t=new f.Worker(e);var i,r;return t.onmessage=m,t.id=h++,a[t.id]=t}();return r.userStep=t.step,r.userChunk=t.chunk,r.userComplete=t.complete,r.userError=t.error,t.step=U(t.step),t.chunk=U(t.chunk),t.complete=U(t.complete),t.error=U(t.error),delete t.worker,void r.postMessage({input:e,config:t,workerId:r.id})}var n=null;"string"==typeof e?n=t.download?new l(t):new p(t):!0===e.readable&&U(e.read)&&U(e.on)?n=new g(t):(f.File&&e instanceof File||e instanceof Object)&&(n=new c(t));return n.stream(e)},unparse:function(e,t){var n=!1,m=!0,_=",",v="\r\n",s='"',a=s+s,i=!1,r=null,o=!1;!function(){if("object"!=typeof t)return;"string"!=typeof t.delimiter||b.BAD_DELIMITERS.filter(function(e){return -1!==t.delimiter.indexOf(e)}).length||(_=t.delimiter);("boolean"==typeof t.quotes||"function"==typeof t.quotes||Array.isArray(t.quotes))&&(n=t.quotes);"boolean"!=typeof t.skipEmptyLines&&"string"!=typeof t.skipEmptyLines||(i=t.skipEmptyLines);"string"==typeof t.newline&&(v=t.newline);"string"==typeof t.quoteChar&&(s=t.quoteChar);"boolean"==typeof t.header&&(m=t.header);if(Array.isArray(t.columns)){if(0===t.columns.length)throw new Error("Option columns is empty");r=t.columns;}void 0!==t.escapeChar&&(a=t.escapeChar+s);"boolean"==typeof t.escapeFormulae&&(o=t.escapeFormulae);}();var h=new RegExp(q(s),"g");"string"==typeof e&&(e=JSON.parse(e));if(Array.isArray(e)){if(!e.length||Array.isArray(e[0]))return f(null,e,i);if("object"==typeof e[0])return f(r||u(e[0]),e,i)}else if("object"==typeof e)return "string"==typeof e.data&&(e.data=JSON.parse(e.data)),Array.isArray(e.data)&&(e.fields||(e.fields=e.meta&&e.meta.fields),e.fields||(e.fields=Array.isArray(e.data[0])?e.fields:u(e.data[0])),Array.isArray(e.data[0])||"object"==typeof e.data[0]||(e.data=[e.data])),f(e.fields||[],e.data||[],i);throw new Error("Unable to serialize unrecognized input");function u(e){if("object"!=typeof e)return [];var t=[];for(var i in e)t.push(i);return t}function f(e,t,i){var r="";"string"==typeof e&&(e=JSON.parse(e)),"string"==typeof t&&(t=JSON.parse(t));var n=Array.isArray(e)&&0=this._config.preview;if(o)f.postMessage({results:n,workerId:b.WORKER_ID,finished:a});else if(U(this._config.chunk)&&!t){if(this._config.chunk(n,this._handle),this._handle.paused()||this._handle.aborted())return void(this._halted=!0);n=void 0,this._completeResults=void 0;}return this._config.step||this._config.chunk||(this._completeResults.data=this._completeResults.data.concat(n.data),this._completeResults.errors=this._completeResults.errors.concat(n.errors),this._completeResults.meta=n.meta),this._completed||!a||!U(this._config.complete)||n&&n.meta.aborted||(this._config.complete(this._completeResults,this._input),this._completed=!0),a||n&&n.meta.paused||this._nextChunk(),n}this._halted=!0;},this._sendError=function(e){U(this._config.error)?this._config.error(e):o&&this._config.error&&f.postMessage({workerId:b.WORKER_ID,error:e,finished:!1});};}function l(e){var r;(e=e||{}).chunkSize||(e.chunkSize=b.RemoteChunkSize),u.call(this,e),this._nextChunk=n?function(){this._readChunk(),this._chunkLoaded();}:function(){this._readChunk();},this.stream=function(e){this._input=e,this._nextChunk();},this._readChunk=function(){if(this._finished)this._chunkLoaded();else {if(r=new XMLHttpRequest,this._config.withCredentials&&(r.withCredentials=this._config.withCredentials),n||(r.onload=y(this._chunkLoaded,this),r.onerror=y(this._chunkError,this)),r.open(this._config.downloadRequestBody?"POST":"GET",this._input,!n),this._config.downloadRequestHeaders){var e=this._config.downloadRequestHeaders;for(var t in e)r.setRequestHeader(t,e[t]);}if(this._config.chunkSize){var i=this._start+this._config.chunkSize-1;r.setRequestHeader("Range","bytes="+this._start+"-"+i);}try{r.send(this._config.downloadRequestBody);}catch(e){this._chunkError(e.message);}n&&0===r.status&&this._chunkError();}},this._chunkLoaded=function(){4===r.readyState&&(r.status<200||400<=r.status?this._chunkError():(this._start+=this._config.chunkSize?this._config.chunkSize:r.responseText.length,this._finished=!this._config.chunkSize||this._start>=function(e){var t=e.getResponseHeader("Content-Range");if(null===t)return -1;return parseInt(t.substring(t.lastIndexOf("/")+1))}(r),this.parseChunk(r.responseText)));},this._chunkError=function(e){var t=r.statusText||e;this._sendError(new Error(t));};}function c(e){var r,n;(e=e||{}).chunkSize||(e.chunkSize=b.LocalChunkSize),u.call(this,e);var s="undefined"!=typeof FileReader;this.stream=function(e){this._input=e,n=e.slice||e.webkitSlice||e.mozSlice,s?((r=new FileReader).onload=y(this._chunkLoaded,this),r.onerror=y(this._chunkError,this)):r=new FileReaderSync,this._nextChunk();},this._nextChunk=function(){this._finished||this._config.preview&&!(this._rowCount=this._input.size,this.parseChunk(e.target.result);},this._chunkError=function(){this._sendError(r.error);};}function p(e){var i;u.call(this,e=e||{}),this.stream=function(e){return i=e,this._nextChunk()},this._nextChunk=function(){if(!this._finished){var e,t=this._config.chunkSize;return t?(e=i.substring(0,t),i=i.substring(t)):(e=i,i=""),this._finished=!i,this.parseChunk(e)}};}function g(e){u.call(this,e=e||{});var t=[],i=!0,r=!1;this.pause=function(){u.prototype.pause.apply(this,arguments),this._input.pause();},this.resume=function(){u.prototype.resume.apply(this,arguments),this._input.resume();},this.stream=function(e){this._input=e,this._input.on("data",this._streamData),this._input.on("end",this._streamEnd),this._input.on("error",this._streamError);},this._checkIsFinished=function(){r&&1===t.length&&(this._finished=!0);},this._nextChunk=function(){this._checkIsFinished(),t.length?this.parseChunk(t.shift()):i=!0;},this._streamData=y(function(e){try{t.push("string"==typeof e?e:e.toString(this._config.encoding)),i&&(i=!1,this._checkIsFinished(),this.parseChunk(t.shift()));}catch(e){this._streamError(e);}},this),this._streamError=y(function(e){this._streamCleanUp(),this._sendError(e);},this),this._streamEnd=y(function(){this._streamCleanUp(),r=!0,this._streamData("");},this),this._streamCleanUp=y(function(){this._input.removeListener("data",this._streamData),this._input.removeListener("end",this._streamEnd),this._input.removeListener("error",this._streamError);},this);}function i(_){var a,o,h,r=Math.pow(2,53),n=-r,s=/^\s*-?(\d+\.?|\.\d+|\d+\.\d+)(e[-+]?\d+)?\s*$/,u=/(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/,t=this,i=0,f=0,d=!1,e=!1,l=[],c={data:[],errors:[],meta:{}};if(U(_.step)){var p=_.step;_.step=function(e){if(c=e,m())g();else {if(g(),0===c.data.length)return;i+=e.data.length,_.preview&&i>_.preview?o.abort():(c.data=c.data[0],p(c,t));}};}function v(e){return "greedy"===_.skipEmptyLines?""===e.join("").trim():1===e.length&&0===e[0].length}function g(){if(c&&h&&(k("Delimiter","UndetectableDelimiter","Unable to auto-detect delimiting character; defaulted to '"+b.DefaultDelimiter+"'"),h=!1),_.skipEmptyLines)for(var e=0;e=l.length?"__parsed_extra":l[i]),_.transform&&(s=_.transform(s,n)),s=y(n,s),"__parsed_extra"===n?(r[n]=r[n]||[],r[n].push(s)):r[n]=s;}return _.header&&(i>l.length?k("FieldMismatch","TooManyFields","Too many fields: expected "+l.length+" fields but parsed "+i,f+t):i=r.length/2?"\r\n":"\r"}(e,r)),h=!1,_.delimiter)U(_.delimiter)&&(_.delimiter=_.delimiter(e),c.meta.delimiter=_.delimiter);else {var n=function(e,t,i,r,n){var s,a,o,h;n=n||[",","\t","|",";",b.RECORD_SEP,b.UNIT_SEP];for(var u=0;u=L)return R(!0)}else for(_=M,M++;;){if(-1===(_=a.indexOf(O,_+1)))return i||u.push({type:"Quotes",code:"MissingQuotes",message:"Quoted field unterminated",row:h.length,index:M}),E();if(_===r-1)return E(a.substring(M,_).replace(m,O));if(O!==z||a[_+1]!==z){if(O===z||0===_||a[_-1]!==z){-1!==p&&p<_+1&&(p=a.indexOf(D,_+1)),-1!==g&&g<_+1&&(g=a.indexOf(I,_+1));var y=w(-1===g?p:Math.min(p,g));if(a[_+1+y]===D){f.push(a.substring(M,_).replace(m,O)),a[M=_+1+y+e]!==O&&(_=a.indexOf(O,M)),p=a.indexOf(D,M),g=a.indexOf(I,M);break}var k=w(g);if(a.substring(_+1+k,_+1+k+n)===I){if(f.push(a.substring(M,_).replace(m,O)),C(_+1+k+n),p=a.indexOf(D,M),_=a.indexOf(O,M),o&&(S(),j))return R();if(L&&h.length>=L)return R(!0);break}u.push({type:"Quotes",code:"InvalidQuotes",message:"Trailing quote on quoted field is malformed",row:h.length,index:M}),_++;}}else _++;}return E();function b(e){h.push(e),d=M;}function w(e){var t=0;if(-1!==e){var i=a.substring(_+1,e);i&&""===i.trim()&&(t=i.length);}return t}function E(e){return i||(void 0===e&&(e=a.substring(M)),f.push(e),M=r,b(f),o&&S()),R()}function C(e){M=e,b(f),f=[],g=a.indexOf(I,M);}function R(e){return {data:h,errors:u,meta:{delimiter:D,linebreak:I,aborted:j,truncated:!!e,cursor:d+(t||0)}}}function S(){A(R()),h=[],u=[];}function x(e,t,i){var r={nextDelim:void 0,quoteSearch:void 0},n=a.indexOf(O,t+1);if(t 0 ? floor : ceil)(argument); +}; + +var min = Math.min; + +// `ToLength` abstract operation +// https://tc39.es/ecma262/#sec-tolength +var toLength = function (argument) { + return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + +var max = Math.max; +var min$1 = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +var toAbsoluteIndex = function (index, length) { + var integer = toInteger(index); + return integer < 0 ? max(integer + length, 0) : min$1(integer, length); +}; + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = toLength(O.length); + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el != el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value != value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) +}; + +var indexOf = arrayIncludes.indexOf; + + +var objectKeysInternal = function (object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key); + // Don't enum bug & hidden keys + while (names.length > i) if (has(O, key = names[i++])) { + ~indexOf(result, key) || result.push(key); + } + return result; +}; + +// IE8- don't enum bug keys +var enumBugKeys = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + +var hiddenKeys$1 = enumBugKeys.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +var f$3 = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return objectKeysInternal(O, hiddenKeys$1); +}; + +var objectGetOwnPropertyNames = { + f: f$3 +}; + +var f$4 = Object.getOwnPropertySymbols; + +var objectGetOwnPropertySymbols = { + f: f$4 +}; + +// all object keys, includes non-enumerable and symbols +var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = objectGetOwnPropertyNames.f(anObject(it)); + var getOwnPropertySymbols = objectGetOwnPropertySymbols.f; + return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; +}; + +var copyConstructorProperties = function (target, source) { + var keys = ownKeys(source); + var defineProperty = objectDefineProperty.f; + var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } +}; + +var replacement = /#|\.prototype\./; + +var isForced = function (feature, detection) { + var value = data[normalize(feature)]; + return value == POLYFILL ? true + : value == NATIVE ? false + : typeof detection == 'function' ? fails(detection) + : !!detection; +}; + +var normalize = isForced.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced.data = {}; +var NATIVE = isForced.NATIVE = 'N'; +var POLYFILL = isForced.POLYFILL = 'P'; + +var isForced_1 = isForced; + +var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; + + + + + + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.noTargetGet - prevent calling a getter on target +*/ +var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global_1; + } else if (STATIC) { + target = global_1[TARGET] || setGlobal(TARGET, {}); + } else { + target = (global_1[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.noTargetGet) { + descriptor = getOwnPropertyDescriptor$1(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced_1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty === typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty(sourceProperty, 'sham', true); + } + // extend global + redefine(target, key, sourceProperty, options); + } +}; + +var nativeGetOwnPropertyNames = objectGetOwnPropertyNames.f; + +var toString$1 = {}.toString; + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return nativeGetOwnPropertyNames(it); + } catch (error) { + return windowNames.slice(); + } +}; + +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +var f$5 = function getOwnPropertyNames(it) { + return windowNames && toString$1.call(it) == '[object Window]' + ? getWindowNames(it) + : nativeGetOwnPropertyNames(toIndexedObject(it)); +}; + +var objectGetOwnPropertyNamesExternal = { + f: f$5 +}; + +var nativeGetOwnPropertyNames$1 = objectGetOwnPropertyNamesExternal.f; + +var FAILS_ON_PRIMITIVES = fails(function () { return !Object.getOwnPropertyNames(1); }); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + getOwnPropertyNames: nativeGetOwnPropertyNames$1 +}); + +// `IsArray` abstract operation +// https://tc39.es/ecma262/#sec-isarray +var isArray = Array.isArray || function isArray(arg) { + return classofRaw(arg) == 'Array'; +}; + +// `ToObject` abstract operation +// https://tc39.es/ecma262/#sec-toobject +var toObject = function (argument) { + return Object(requireObjectCoercible(argument)); +}; + +var createProperty = function (object, key, value) { + var propertyKey = toPrimitive(key); + if (propertyKey in object) objectDefineProperty.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; +}; + +var nativeSymbol = !!Object.getOwnPropertySymbols && !fails(function () { + // Chrome 38 Symbol has incorrect toString conversion + /* global Symbol -- required for testing */ + return !String(Symbol()); +}); + +var useSymbolAsUid = nativeSymbol + /* global Symbol -- safe */ + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + +var WellKnownSymbolsStore = shared('wks'); +var Symbol$1 = global_1.Symbol; +var createWellKnownSymbol = useSymbolAsUid ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid; + +var wellKnownSymbol = function (name) { + if (!has(WellKnownSymbolsStore, name)) { + if (nativeSymbol && has(Symbol$1, name)) WellKnownSymbolsStore[name] = Symbol$1[name]; + else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; +}; + +var SPECIES = wellKnownSymbol('species'); + +// `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +var arraySpeciesCreate = function (originalArray, length) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; + else if (isObject(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); +}; + +var engineUserAgent = getBuiltIn('navigator', 'userAgent') || ''; + +var process = global_1.process; +var versions = process && process.versions; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + version = match[0] + match[1]; +} else if (engineUserAgent) { + match = engineUserAgent.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = engineUserAgent.match(/Chrome\/(\d+)/); + if (match) version = match[1]; + } +} + +var engineV8Version = version && +version; + +var SPECIES$1 = wellKnownSymbol('species'); + +var arrayMethodHasSpeciesSupport = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return engineV8Version >= 51 || !fails(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES$1] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; + +var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable'); +var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; +var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded'; + +// We can't use this feature detection in V8 since it causes +// deoptimization and serious performance degradation +// https://github.com/zloirock/core-js/issues/679 +var IS_CONCAT_SPREADABLE_SUPPORT = engineV8Version >= 51 || !fails(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; +}); + +var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat'); + +var isConcatSpreadable = function (O) { + if (!isObject(O)) return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); +}; + +var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT; + +// `Array.prototype.concat` method +// https://tc39.es/ecma262/#sec-array.prototype.concat +// with adding support of @@isConcatSpreadable and @@species +_export({ target: 'Array', proto: true, forced: FORCED }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + concat: function concat(arg) { + var O = toObject(this); + var A = arraySpeciesCreate(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = toLength(E.length); + if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); + for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]); + } else { + if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED); + createProperty(A, n++, E); + } + } + A.length = n; + return A; + } +}); + +var aFunction$1 = function (it) { + if (typeof it != 'function') { + throw TypeError(String(it) + ' is not a function'); + } return it; +}; + +// optional / simple context binding +var functionBindContext = function (fn, that, length) { + aFunction$1(fn); + if (that === undefined) return fn; + switch (length) { + case 0: return function () { + return fn.call(that); + }; + 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); + }; +}; + +var push = [].push; + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterOut }` methods implementation +var createMethod$1 = function (TYPE) { + var IS_MAP = TYPE == 1; + var IS_FILTER = TYPE == 2; + var IS_SOME = TYPE == 3; + var IS_EVERY = TYPE == 4; + var IS_FIND_INDEX = TYPE == 6; + var IS_FILTER_OUT = TYPE == 7; + var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject($this); + var self = indexedObject(O); + var boundFunction = functionBindContext(callbackfn, that, 3); + var length = toLength(self.length); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_OUT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push.call(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push.call(target, value); // filterOut + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +var arrayIteration = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod$1(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod$1(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod$1(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod$1(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod$1(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod$1(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod$1(6), + // `Array.prototype.filterOut` method + // https://github.com/tc39/proposal-array-filtering + filterOut: createMethod$1(7) +}; + +var arrayMethodIsStrict = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails(function () { + // eslint-disable-next-line no-useless-call,no-throw-literal -- required for testing + method.call(null, argument || function () { throw 1; }, 1); + }); +}; + +var $forEach = arrayIteration.forEach; + + +var STRICT_METHOD = arrayMethodIsStrict('forEach'); + +// `Array.prototype.forEach` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.foreach +var arrayForEach = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); +} : [].forEach; + +// `Array.prototype.forEach` method +// https://tc39.es/ecma262/#sec-array.prototype.foreach +_export({ target: 'Array', proto: true, forced: [].forEach != arrayForEach }, { + forEach: arrayForEach +}); + +var iteratorClose = function (iterator) { + var returnMethod = iterator['return']; + if (returnMethod !== undefined) { + return anObject(returnMethod.call(iterator)).value; + } +}; + +// call something on iterator step with safe closing on error +var callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); + // 7.4.6 IteratorClose(iterator, completion) + } catch (error) { + iteratorClose(iterator); + throw error; + } +}; + +var iterators = {}; + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayPrototype = Array.prototype; + +// check on default Array iterator +var isArrayIteratorMethod = function (it) { + return it !== undefined && (iterators.Array === it || ArrayPrototype[ITERATOR] === it); +}; + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var test = {}; + +test[TO_STRING_TAG] = 'z'; + +var toStringTagSupport = String(test) === '[object z]'; + +var TO_STRING_TAG$1 = wellKnownSymbol('toStringTag'); +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +var classof = toStringTagSupport ? classofRaw : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw(O) + // ES3 arguments fallback + : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result; +}; + +var ITERATOR$1 = wellKnownSymbol('iterator'); + +var getIteratorMethod = function (it) { + if (it != undefined) return it[ITERATOR$1] + || it['@@iterator'] + || iterators[classof(it)]; +}; + +// `Array.from` method implementation +// https://tc39.es/ecma262/#sec-array.from +var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var O = toObject(arrayLike); + var C = typeof this == 'function' ? this : Array; + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + var iteratorMethod = getIteratorMethod(O); + var index = 0; + var length, result, step, iterator, next, value; + if (mapping) mapfn = functionBindContext(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2); + // if the target is not iterable or it's an array with the default iterator - use a simple case + if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) { + iterator = iteratorMethod.call(O); + next = iterator.next; + result = new C(); + for (;!(step = next.call(iterator)).done; index++) { + value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value; + createProperty(result, index, value); + } + } else { + length = toLength(O.length); + result = new C(length); + for (;length > index; index++) { + value = mapping ? mapfn(O[index], index) : O[index]; + createProperty(result, index, value); + } + } + result.length = index; + return result; +}; + +var ITERATOR$2 = wellKnownSymbol('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$2] = function () { + return this; + }; + // eslint-disable-next-line no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +var checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$2] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + +var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + Array.from(iterable); +}); + +// `Array.from` method +// https://tc39.es/ecma262/#sec-array.from +_export({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: arrayFrom +}); + +var $indexOf = arrayIncludes.indexOf; + + +var nativeIndexOf = [].indexOf; + +var NEGATIVE_ZERO = !!nativeIndexOf && 1 / [1].indexOf(1, -0) < 0; +var STRICT_METHOD$1 = arrayMethodIsStrict('indexOf'); + +// `Array.prototype.indexOf` method +// https://tc39.es/ecma262/#sec-array.prototype.indexof +_export({ target: 'Array', proto: true, forced: NEGATIVE_ZERO || !STRICT_METHOD$1 }, { + indexOf: function indexOf(searchElement /* , fromIndex = 0 */) { + return NEGATIVE_ZERO + // convert -0 to +0 + ? nativeIndexOf.apply(this, arguments) || 0 + : $indexOf(this, searchElement, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +var nativeReverse = [].reverse; +var test$1 = [1, 2]; + +// `Array.prototype.reverse` method +// https://tc39.es/ecma262/#sec-array.prototype.reverse +// fix for Safari 12.0 bug +// https://bugs.webkit.org/show_bug.cgi?id=188794 +_export({ target: 'Array', proto: true, forced: String(test$1) === String(test$1.reverse()) }, { + reverse: function reverse() { + // eslint-disable-next-line no-self-assign -- dirty hack + if (isArray(this)) this.length = this.length; + return nativeReverse.call(this); + } +}); + +var test$2 = []; +var nativeSort = test$2.sort; + +// IE8- +var FAILS_ON_UNDEFINED = fails(function () { + test$2.sort(undefined); +}); +// V8 bug +var FAILS_ON_NULL = fails(function () { + test$2.sort(null); +}); +// Old WebKit +var STRICT_METHOD$2 = arrayMethodIsStrict('sort'); + +var FORCED$1 = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD$2; + +// `Array.prototype.sort` method +// https://tc39.es/ecma262/#sec-array.prototype.sort +_export({ target: 'Array', proto: true, forced: FORCED$1 }, { + sort: function sort(comparefn) { + return comparefn === undefined + ? nativeSort.call(toObject(this)) + : nativeSort.call(toObject(this), aFunction$1(comparefn)); + } +}); + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('splice'); + +var max$1 = Math.max; +var min$2 = Math.min; +var MAX_SAFE_INTEGER$1 = 0x1FFFFFFFFFFFFF; +var MAXIMUM_ALLOWED_LENGTH_EXCEEDED = 'Maximum allowed length exceeded'; + +// `Array.prototype.splice` method +// https://tc39.es/ecma262/#sec-array.prototype.splice +// with adding support of @@species +_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + splice: function splice(start, deleteCount /* , ...items */) { + var O = toObject(this); + var len = toLength(O.length); + var actualStart = toAbsoluteIndex(start, len); + var argumentsLength = arguments.length; + var insertCount, actualDeleteCount, A, k, from, to; + if (argumentsLength === 0) { + insertCount = actualDeleteCount = 0; + } else if (argumentsLength === 1) { + insertCount = 0; + actualDeleteCount = len - actualStart; + } else { + insertCount = argumentsLength - 2; + actualDeleteCount = min$2(max$1(toInteger(deleteCount), 0), len - actualStart); + } + if (len + insertCount - actualDeleteCount > MAX_SAFE_INTEGER$1) { + throw TypeError(MAXIMUM_ALLOWED_LENGTH_EXCEEDED); + } + A = arraySpeciesCreate(O, actualDeleteCount); + for (k = 0; k < actualDeleteCount; k++) { + from = actualStart + k; + if (from in O) createProperty(A, k, O[from]); + } + A.length = actualDeleteCount; + if (insertCount < actualDeleteCount) { + for (k = actualStart; k < len - actualDeleteCount; k++) { + from = k + actualDeleteCount; + to = k + insertCount; + if (from in O) O[to] = O[from]; + else delete O[to]; + } + for (k = len; k > len - actualDeleteCount + insertCount; k--) delete O[k - 1]; + } else if (insertCount > actualDeleteCount) { + for (k = len - actualDeleteCount; k > actualStart; k--) { + from = k + actualDeleteCount - 1; + to = k + insertCount - 1; + if (from in O) O[to] = O[from]; + else delete O[to]; + } + } + for (k = 0; k < insertCount; k++) { + O[k + actualStart] = arguments[k + 2]; + } + O.length = len - actualDeleteCount + insertCount; + return A; + } +}); + +var aPossiblePrototype = function (it) { + if (!isObject(it) && it !== null) { + throw TypeError("Can't set " + String(it) + ' as a prototype'); + } return it; +}; + +/* eslint-disable no-proto -- safe */ + + + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set; + setter.call(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter.call(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + +// makes subclassing work correct for wrapped built-ins +var inheritIfRequired = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + objectSetPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + typeof (NewTarget = dummy.constructor) == 'function' && + NewTarget !== Wrapper && + isObject(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) objectSetPrototypeOf($this, NewTargetPrototype); + return $this; +}; + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +var objectKeys = Object.keys || function keys(O) { + return objectKeysInternal(O, enumBugKeys); +}; + +// `Object.defineProperties` method +// https://tc39.es/ecma262/#sec-object.defineproperties +var objectDefineProperties = descriptors ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) objectDefineProperty.f(O, key = keys[index++], Properties[key]); + return O; +}; + +var html = getBuiltIn('document', 'documentElement'); + +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO = sharedKey('IE_PROTO'); + +var EmptyConstructor = function () { /* empty */ }; + +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; + +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; +}; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + /* global ActiveXObject -- old IE */ + activeXDocument = document.domain && new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame(); + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys[IE_PROTO] = true; + +// `Object.create` method +// https://tc39.es/ecma262/#sec-object.create +var objectCreate = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : objectDefineProperties(result, Properties); +}; + +// a string of all valid unicode whitespaces +var whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + +var whitespace = '[' + whitespaces + ']'; +var ltrim = RegExp('^' + whitespace + whitespace + '*'); +var rtrim = RegExp(whitespace + whitespace + '*$'); + +// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation +var createMethod$2 = function (TYPE) { + return function ($this) { + var string = String(requireObjectCoercible($this)); + if (TYPE & 1) string = string.replace(ltrim, ''); + if (TYPE & 2) string = string.replace(rtrim, ''); + return string; + }; +}; + +var stringTrim = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimstart + start: createMethod$2(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimend + end: createMethod$2(2), + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + trim: createMethod$2(3) +}; + +var getOwnPropertyNames = objectGetOwnPropertyNames.f; +var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f; +var defineProperty = objectDefineProperty.f; +var trim = stringTrim.trim; + +var NUMBER = 'Number'; +var NativeNumber = global_1[NUMBER]; +var NumberPrototype = NativeNumber.prototype; + +// Opera ~12 has broken Object#toString +var BROKEN_CLASSOF = classofRaw(objectCreate(NumberPrototype)) == NUMBER; + +// `ToNumber` abstract operation +// https://tc39.es/ecma262/#sec-tonumber +var toNumber = function (argument) { + var it = toPrimitive(argument, false); + var first, third, radix, maxCode, digits, length, index, code; + if (typeof it == 'string' && it.length > 2) { + it = trim(it); + first = it.charCodeAt(0); + if (first === 43 || first === 45) { + third = it.charCodeAt(2); + if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix + } else if (first === 48) { + switch (it.charCodeAt(1)) { + case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i + case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i + default: return +it; + } + digits = it.slice(2); + length = digits.length; + for (index = 0; index < length; index++) { + code = digits.charCodeAt(index); + // parseInt parses a string to a first unavailable symbol + // but ToNumber should return NaN if a string contains unavailable symbols + if (code < 48 || code > maxCode) return NaN; + } return parseInt(digits, radix); + } + } return +it; +}; + +// `Number` constructor +// https://tc39.es/ecma262/#sec-number-constructor +if (isForced_1(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) { + var NumberWrapper = function Number(value) { + var it = arguments.length < 1 ? 0 : value; + var dummy = this; + return dummy instanceof NumberWrapper + // check on 1..constructor(foo) case + && (BROKEN_CLASSOF ? fails(function () { NumberPrototype.valueOf.call(dummy); }) : classofRaw(dummy) != NUMBER) + ? inheritIfRequired(new NativeNumber(toNumber(it)), dummy, NumberWrapper) : toNumber(it); + }; + for (var keys$1 = descriptors ? getOwnPropertyNames(NativeNumber) : ( + // ES3: + 'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' + + // ES2015 (in case, if modules with ES2015 Number statics required before): + 'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' + + 'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger,' + + // ESNext + 'fromString,range' + ).split(','), j = 0, key; keys$1.length > j; j++) { + if (has(NativeNumber, key = keys$1[j]) && !has(NumberWrapper, key)) { + defineProperty(NumberWrapper, key, getOwnPropertyDescriptor$2(NativeNumber, key)); + } + } + NumberWrapper.prototype = NumberPrototype; + NumberPrototype.constructor = NumberWrapper; + redefine(global_1, NUMBER, NumberWrapper); +} + +var floor$1 = Math.floor; + +// `Number.isInteger` method implementation +// https://tc39.es/ecma262/#sec-number.isinteger +var isInteger = function isInteger(it) { + return !isObject(it) && isFinite(it) && floor$1(it) === it; +}; + +// `Number.isInteger` method +// https://tc39.es/ecma262/#sec-number.isinteger +_export({ target: 'Number', stat: true }, { + isInteger: isInteger +}); + +// `RegExp.prototype.flags` getter implementation +// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags +var regexpFlags = function () { + var that = anObject(this); + var result = ''; + if (that.global) result += 'g'; + if (that.ignoreCase) result += 'i'; + if (that.multiline) result += 'm'; + if (that.dotAll) result += 's'; + if (that.unicode) result += 'u'; + if (that.sticky) result += 'y'; + return result; +}; + +// babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError, +// so we use an intermediate function. +function RE(s, f) { + return RegExp(s, f); +} + +var UNSUPPORTED_Y = fails(function () { + // babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError + var re = RE('a', 'y'); + re.lastIndex = 2; + return re.exec('abcd') != null; +}); + +var BROKEN_CARET = fails(function () { + // https://bugzilla.mozilla.org/show_bug.cgi?id=773687 + var re = RE('^r', 'gy'); + re.lastIndex = 2; + return re.exec('str') != null; +}); + +var regexpStickyHelpers = { + UNSUPPORTED_Y: UNSUPPORTED_Y, + BROKEN_CARET: BROKEN_CARET +}; + +var nativeExec = RegExp.prototype.exec; +// This always refers to the native implementation, because the +// String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js, +// which loads this file before patching the method. +var nativeReplace = String.prototype.replace; + +var patchedExec = nativeExec; + +var UPDATES_LAST_INDEX_WRONG = (function () { + var re1 = /a/; + var re2 = /b*/g; + nativeExec.call(re1, 'a'); + nativeExec.call(re2, 'a'); + return re1.lastIndex !== 0 || re2.lastIndex !== 0; +})(); + +var UNSUPPORTED_Y$1 = regexpStickyHelpers.UNSUPPORTED_Y || regexpStickyHelpers.BROKEN_CARET; + +// nonparticipating capturing group, copied from es5-shim's String#split patch. +// eslint-disable-next-line regexp/no-assertion-capturing-group, regexp/no-empty-group -- required for testing +var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; + +var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y$1; + +if (PATCH) { + patchedExec = function exec(str) { + var re = this; + var lastIndex, reCopy, match, i; + var sticky = UNSUPPORTED_Y$1 && re.sticky; + var flags = regexpFlags.call(re); + var source = re.source; + var charsAdded = 0; + var strCopy = str; + + if (sticky) { + flags = flags.replace('y', ''); + if (flags.indexOf('g') === -1) { + flags += 'g'; + } + + strCopy = String(str).slice(re.lastIndex); + // Support anchored sticky behavior. + if (re.lastIndex > 0 && (!re.multiline || re.multiline && str[re.lastIndex - 1] !== '\n')) { + source = '(?: ' + source + ')'; + strCopy = ' ' + strCopy; + charsAdded++; + } + // ^(? + rx + ) is needed, in combination with some str slicing, to + // simulate the 'y' flag. + reCopy = new RegExp('^(?:' + source + ')', flags); + } + + if (NPCG_INCLUDED) { + reCopy = new RegExp('^' + source + '$(?!\\s)', flags); + } + if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; + + match = nativeExec.call(sticky ? reCopy : re, strCopy); + + if (sticky) { + if (match) { + match.input = match.input.slice(charsAdded); + match[0] = match[0].slice(charsAdded); + match.index = re.lastIndex; + re.lastIndex += match[0].length; + } else re.lastIndex = 0; + } else if (UPDATES_LAST_INDEX_WRONG && match) { + re.lastIndex = re.global ? match.index + match[0].length : lastIndex; + } + if (NPCG_INCLUDED && match && match.length > 1) { + // Fix browsers whose `exec` methods don't consistently return `undefined` + // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/ + nativeReplace.call(match[0], reCopy, function () { + for (i = 1; i < arguments.length - 2; i++) { + if (arguments[i] === undefined) match[i] = undefined; + } + }); + } + + return match; + }; +} + +var regexpExec = patchedExec; + +// `RegExp.prototype.exec` method +// https://tc39.es/ecma262/#sec-regexp.prototype.exec +_export({ target: 'RegExp', proto: true, forced: /./.exec !== regexpExec }, { + exec: regexpExec +}); + +// `String.prototype.{ codePointAt, at }` methods implementation +var createMethod$3 = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = String(requireObjectCoercible($this)); + var position = toInteger(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = S.charCodeAt(position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING ? S.charAt(position) : first + : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; + +var stringMultibyte = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod$3(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod$3(true) +}; + +var correctPrototypeGetter = !fails(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + +var IE_PROTO$1 = sharedKey('IE_PROTO'); +var ObjectPrototype = Object.prototype; + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +var objectGetPrototypeOf = correctPrototypeGetter ? Object.getPrototypeOf : function (O) { + O = toObject(O); + if (has(O, IE_PROTO$1)) return O[IE_PROTO$1]; + if (typeof O.constructor == 'function' && O instanceof O.constructor) { + return O.constructor.prototype; + } return O instanceof Object ? ObjectPrototype : null; +}; + +var ITERATOR$3 = wellKnownSymbol('iterator'); +var BUGGY_SAFARI_ITERATORS = false; + +var returnThis = function () { return this; }; + +// `%IteratorPrototype%` object +// https://tc39.es/ecma262/#sec-%iteratorprototype%-object +var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator; + +if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true; + else { + PrototypeOfArrayIteratorPrototype = objectGetPrototypeOf(objectGetPrototypeOf(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype; + } +} + +var NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype[ITERATOR$3].call(test) !== test; +}); + +if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {}; + +// 25.1.2.1.1 %IteratorPrototype%[@@iterator]() +if (!has(IteratorPrototype, ITERATOR$3)) { + createNonEnumerableProperty(IteratorPrototype, ITERATOR$3, returnThis); +} + +var iteratorsCore = { + IteratorPrototype: IteratorPrototype, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS +}; + +var defineProperty$1 = objectDefineProperty.f; + + + +var TO_STRING_TAG$2 = wellKnownSymbol('toStringTag'); + +var setToStringTag = function (it, TAG, STATIC) { + if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG$2)) { + defineProperty$1(it, TO_STRING_TAG$2, { configurable: true, value: TAG }); + } +}; + +var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; + + + + + +var returnThis$1 = function () { return this; }; + +var createIteratorConstructor = function (IteratorConstructor, NAME, next) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = objectCreate(IteratorPrototype$1, { next: createPropertyDescriptor(1, next) }); + setToStringTag(IteratorConstructor, TO_STRING_TAG, false); + iterators[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; +}; + +var IteratorPrototype$2 = iteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS$1 = iteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR$4 = wellKnownSymbol('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; + +var returnThis$2 = function () { return this; }; + +var defineIterator = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS$1 && KIND in IterablePrototype) return IterablePrototype[KIND]; + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$4] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS$1 && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = objectGetPrototypeOf(anyNativeIterator.call(new Iterable())); + if (IteratorPrototype$2 !== Object.prototype && CurrentIteratorPrototype.next) { + if (objectGetPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype$2) { + if (objectSetPrototypeOf) { + objectSetPrototypeOf(CurrentIteratorPrototype, IteratorPrototype$2); + } else if (typeof CurrentIteratorPrototype[ITERATOR$4] != 'function') { + createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR$4, returnThis$2); + } + } + // Set @@toStringTag to native iterators + setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array#{values, @@iterator}.name in V8 / FF + if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return nativeIterator.call(this); }; + } + + // define iterator + if (IterablePrototype[ITERATOR$4] !== defaultIterator) { + createNonEnumerableProperty(IterablePrototype, ITERATOR$4, defaultIterator); + } + iterators[NAME] = defaultIterator; + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + redefine(IterablePrototype, KEY, methods[KEY]); + } + } else _export({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS$1 || INCORRECT_VALUES_NAME }, methods); + } + + return methods; +}; + +var charAt = stringMultibyte.charAt; + + + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState = internalState.set; +var getInternalState = internalState.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-string.prototype-@@iterator +defineIterator(String, 'String', function (iterated) { + setInternalState(this, { + type: STRING_ITERATOR, + string: String(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return { value: undefined, done: true }; + point = charAt(string, index); + state.index += point.length; + return { value: point, done: false }; +}); + +// TODO: Remove from `core-js@4` since it's moved to entry points + + + + + + + +var SPECIES$2 = wellKnownSymbol('species'); + +var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { + // #replace needs built-in support for named groups. + // #match works fine because it just return the exec results, even if it has + // a "grops" property. + var re = /./; + re.exec = function () { + var result = []; + result.groups = { a: '7' }; + return result; + }; + return ''.replace(re, '$') !== '7'; +}); + +// IE <= 11 replaces $0 with the whole match, as if it was $& +// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0 +var REPLACE_KEEPS_$0 = (function () { + return 'a'.replace(/./, '$0') === '$0'; +})(); + +var REPLACE = wellKnownSymbol('replace'); +// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string +var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () { + if (/./[REPLACE]) { + return /./[REPLACE]('a', '$0') === ''; + } + return false; +})(); + +// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec +// Weex JS has frozen built-in prototypes, so use try / catch wrapper +var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () { + // eslint-disable-next-line regexp/no-empty-group -- required for testing + var re = /(?:)/; + var originalExec = re.exec; + re.exec = function () { return originalExec.apply(this, arguments); }; + var result = 'ab'.split(re); + return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b'; +}); + +var fixRegexpWellKnownSymbolLogic = function (KEY, length, exec, sham) { + var SYMBOL = wellKnownSymbol(KEY); + + var DELEGATES_TO_SYMBOL = !fails(function () { + // String methods call symbol-named RegEp methods + var O = {}; + O[SYMBOL] = function () { return 7; }; + return ''[KEY](O) != 7; + }); + + var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () { + // Symbol-named RegExp methods call .exec + var execCalled = false; + var re = /a/; + + if (KEY === 'split') { + // We can't use real regex here since it causes deoptimization + // and serious performance degradation in V8 + // https://github.com/zloirock/core-js/issues/306 + re = {}; + // RegExp[@@split] doesn't call the regex's exec method, but first creates + // a new one. We need to return the patched regex when creating the new one. + re.constructor = {}; + re.constructor[SPECIES$2] = function () { return re; }; + re.flags = ''; + re[SYMBOL] = /./[SYMBOL]; + } + + re.exec = function () { execCalled = true; return null; }; + + re[SYMBOL](''); + return !execCalled; + }); + + if ( + !DELEGATES_TO_SYMBOL || + !DELEGATES_TO_EXEC || + (KEY === 'replace' && !( + REPLACE_SUPPORTS_NAMED_GROUPS && + REPLACE_KEEPS_$0 && + !REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE + )) || + (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC) + ) { + var nativeRegExpMethod = /./[SYMBOL]; + var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { + if (regexp.exec === regexpExec) { + if (DELEGATES_TO_SYMBOL && !forceStringMethod) { + // The native String method already delegates to @@method (this + // polyfilled function), leasing to infinite recursion. + // We avoid it by directly calling the native @@method method. + return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) }; + } + return { done: true, value: nativeMethod.call(str, regexp, arg2) }; + } + return { done: false }; + }, { + REPLACE_KEEPS_$0: REPLACE_KEEPS_$0, + REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE: REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE + }); + var stringMethod = methods[0]; + var regexMethod = methods[1]; + + redefine(String.prototype, KEY, stringMethod); + redefine(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 regexMethod.call(string, this, arg); } + // 21.2.5.6 RegExp.prototype[@@match](string) + // 21.2.5.9 RegExp.prototype[@@search](string) + : function (string) { return regexMethod.call(string, this); } + ); + } + + if (sham) createNonEnumerableProperty(RegExp.prototype[SYMBOL], 'sham', true); +}; + +var charAt$1 = stringMultibyte.charAt; + +// `AdvanceStringIndex` abstract operation +// https://tc39.es/ecma262/#sec-advancestringindex +var advanceStringIndex = function (S, index, unicode) { + return index + (unicode ? charAt$1(S, index).length : 1); +}; + +var floor$2 = Math.floor; +var replace = ''.replace; +var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d\d?|<[^>]*>)/g; +var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d\d?)/g; + +// https://tc39.es/ecma262/#sec-getsubstitution +var getSubstitution = function (matched, str, position, captures, namedCaptures, replacement) { + var tailPos = position + matched.length; + var m = captures.length; + var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; + if (namedCaptures !== undefined) { + namedCaptures = toObject(namedCaptures); + symbols = SUBSTITUTION_SYMBOLS; + } + return replace.call(replacement, symbols, function (match, ch) { + var capture; + switch (ch.charAt(0)) { + case '$': return '$'; + case '&': return matched; + case '`': return str.slice(0, position); + case "'": return str.slice(tailPos); + case '<': + capture = namedCaptures[ch.slice(1, -1)]; + break; + default: // \d\d? + var n = +ch; + if (n === 0) return match; + if (n > m) { + var f = floor$2(n / 10); + if (f === 0) return match; + if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1); + return match; + } + capture = captures[n - 1]; + } + return capture === undefined ? '' : capture; + }); +}; + +// `RegExpExec` abstract operation +// https://tc39.es/ecma262/#sec-regexpexec +var regexpExecAbstract = function (R, S) { + var exec = R.exec; + if (typeof exec === 'function') { + var result = exec.call(R, S); + if (typeof result !== 'object') { + throw TypeError('RegExp exec method returned something other than an Object or null'); + } + return result; + } + + if (classofRaw(R) !== 'RegExp') { + throw TypeError('RegExp#exec called on incompatible receiver'); + } + + return regexpExec.call(R, S); +}; + +var max$2 = Math.max; +var min$3 = Math.min; + +var maybeToString = function (it) { + return it === undefined ? it : String(it); +}; + +// @@replace logic +fixRegexpWellKnownSymbolLogic('replace', 2, function (REPLACE, nativeReplace, maybeCallNative, reason) { + var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = reason.REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE; + var REPLACE_KEEPS_$0 = reason.REPLACE_KEEPS_$0; + var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0'; + + return [ + // `String.prototype.replace` method + // https://tc39.es/ecma262/#sec-string.prototype.replace + function replace(searchValue, replaceValue) { + var O = requireObjectCoercible(this); + var replacer = searchValue == undefined ? undefined : searchValue[REPLACE]; + return replacer !== undefined + ? replacer.call(searchValue, O, replaceValue) + : nativeReplace.call(String(O), searchValue, replaceValue); + }, + // `RegExp.prototype[@@replace]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace + function (regexp, replaceValue) { + if ( + (!REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE && REPLACE_KEEPS_$0) || + (typeof replaceValue === 'string' && replaceValue.indexOf(UNSAFE_SUBSTITUTE) === -1) + ) { + var res = maybeCallNative(nativeReplace, regexp, this, replaceValue); + if (res.done) return res.value; + } + + var rx = anObject(regexp); + var S = String(this); + + var functionalReplace = typeof replaceValue === 'function'; + if (!functionalReplace) replaceValue = String(replaceValue); + + var global = rx.global; + if (global) { + var fullUnicode = rx.unicode; + rx.lastIndex = 0; + } + var results = []; + while (true) { + var result = regexpExecAbstract(rx, S); + if (result === null) break; + + results.push(result); + if (!global) break; + + var matchStr = String(result[0]); + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + } + + var accumulatedResult = ''; + var nextSourcePosition = 0; + for (var i = 0; i < results.length; i++) { + result = results[i]; + + var matched = String(result[0]); + var position = max$2(min$3(toInteger(result.index), S.length), 0); + var captures = []; + // NOTE: This is equivalent to + // captures = result.slice(1).map(maybeToString) + // but for some reason `nativeSlice.call(result, 1, result.length)` (called in + // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and + // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. + for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j])); + var namedCaptures = result.groups; + if (functionalReplace) { + var replacerArgs = [matched].concat(captures, position, S); + if (namedCaptures !== undefined) replacerArgs.push(namedCaptures); + var replacement = String(replaceValue.apply(undefined, replacerArgs)); + } else { + replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); + } + if (position >= nextSourcePosition) { + accumulatedResult += S.slice(nextSourcePosition, position) + replacement; + nextSourcePosition = position + matched.length; + } + } + return accumulatedResult + S.slice(nextSourcePosition); + } + ]; +}); + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + +for (var COLLECTION_NAME in domIterables) { + var Collection = global_1[COLLECTION_NAME]; + var CollectionPrototype = Collection && Collection.prototype; + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== arrayForEach) try { + createNonEnumerableProperty(CollectionPrototype, 'forEach', arrayForEach); + } catch (error) { + CollectionPrototype.forEach = arrayForEach; + } +} + +var engineIsIos = /(iphone|ipod|ipad).*applewebkit/i.test(engineUserAgent); + +var engineIsNode = classofRaw(global_1.process) == 'process'; + +var location$1 = global_1.location; +var set$1 = global_1.setImmediate; +var clear = global_1.clearImmediate; +var process$1 = global_1.process; +var MessageChannel = global_1.MessageChannel; +var Dispatch = global_1.Dispatch; +var counter = 0; +var queue = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var defer, channel, port; + +var run = function (id) { + // eslint-disable-next-line no-prototype-builtins -- safe + if (queue.hasOwnProperty(id)) { + var fn = queue[id]; + delete queue[id]; + fn(); + } +}; + +var runner = function (id) { + return function () { + run(id); + }; +}; + +var listener = function (event) { + run(event.data); +}; + +var post = function (id) { + // old engines have not location.origin + global_1.postMessage(id + '', location$1.protocol + '//' + location$1.host); +}; + +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!set$1 || !clear) { + set$1 = function setImmediate(fn) { + var args = []; + var i = 1; + while (arguments.length > i) args.push(arguments[i++]); + queue[++counter] = function () { + // eslint-disable-next-line no-new-func -- spec requirement + (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue[id]; + }; + // Node.js 0.8- + if (engineIsNode) { + defer = function (id) { + process$1.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !engineIsIos) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = listener; + defer = functionBindContext(port.postMessage, port, 1); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global_1.addEventListener && + typeof postMessage == 'function' && + !global_1.importScripts && + location$1 && location$1.protocol !== 'file:' && + !fails(post) + ) { + defer = post; + global_1.addEventListener('message', listener, false); + // IE8- + } else if (ONREADYSTATECHANGE in documentCreateElement('script')) { + defer = function (id) { + html.appendChild(documentCreateElement('script'))[ONREADYSTATECHANGE] = function () { + html.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} + +var task = { + set: set$1, + clear: clear +}; + +var FORCED$2 = !global_1.setImmediate || !global_1.clearImmediate; + +// http://w3c.github.io/setImmediate/ +_export({ global: true, bind: true, enumerable: true, forced: FORCED$2 }, { + // `setImmediate` method + // http://w3c.github.io/setImmediate/#si-setImmediate + setImmediate: task.set, + // `clearImmediate` method + // http://w3c.github.io/setImmediate/#si-clearImmediate + clearImmediate: task.clear +}); + +var slice = [].slice; +var MSIE = /MSIE .\./.test(engineUserAgent); // <- dirty ie9- check + +var wrap = function (scheduler) { + return function (handler, timeout /* , ...arguments */) { + var boundArgs = arguments.length > 2; + var args = boundArgs ? slice.call(arguments, 2) : undefined; + return scheduler(boundArgs ? function () { + // eslint-disable-next-line no-new-func -- spec requirement + (typeof handler == 'function' ? handler : Function(handler)).apply(this, args); + } : handler, timeout); + }; +}; + +// ie9- setTimeout & setInterval additional parameters fix +// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers +_export({ global: true, bind: true, forced: MSIE }, { + // `setTimeout` method + // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout + setTimeout: wrap(global_1.setTimeout), + // `setInterval` method + // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval + setInterval: wrap(global_1.setInterval) +}); + +var $filter = arrayIteration.filter; + + +var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport('filter'); + +// `Array.prototype.filter` method +// https://tc39.es/ecma262/#sec-array.prototype.filter +// with adding support of @@species +_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$1 }, { + filter: function filter(callbackfn /* , thisArg */) { + return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +var UNSCOPABLES = wellKnownSymbol('unscopables'); +var ArrayPrototype$1 = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype$1[UNSCOPABLES] == undefined) { + objectDefineProperty.f(ArrayPrototype$1, UNSCOPABLES, { + configurable: true, + value: objectCreate(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +var addToUnscopables = function (key) { + ArrayPrototype$1[UNSCOPABLES][key] = true; +}; + +var $includes = arrayIncludes.includes; + + +// `Array.prototype.includes` method +// https://tc39.es/ecma262/#sec-array.prototype.includes +_export({ target: 'Array', proto: true }, { + includes: function includes(el /* , fromIndex = 0 */) { + return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('includes'); + +var nativeJoin = [].join; + +var ES3_STRINGS = indexedObject != Object; +var STRICT_METHOD$3 = arrayMethodIsStrict('join', ','); + +// `Array.prototype.join` method +// https://tc39.es/ecma262/#sec-array.prototype.join +_export({ target: 'Array', proto: true, forced: ES3_STRINGS || !STRICT_METHOD$3 }, { + join: function join(separator) { + return nativeJoin.call(toIndexedObject(this), separator === undefined ? ',' : separator); + } +}); + +var HAS_SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport('slice'); + +var SPECIES$3 = wellKnownSymbol('species'); +var nativeSlice = [].slice; +var max$3 = Math.max; + +// `Array.prototype.slice` method +// https://tc39.es/ecma262/#sec-array.prototype.slice +// fallback for not array-like ES3 strings and DOM objects +_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$2 }, { + slice: function slice(start, end) { + var O = toIndexedObject(this); + var length = toLength(O.length); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible + var Constructor, result, n; + if (isArray(O)) { + Constructor = O.constructor; + // cross-realm fallback + if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) { + Constructor = undefined; + } else if (isObject(Constructor)) { + Constructor = Constructor[SPECIES$3]; + if (Constructor === null) Constructor = undefined; + } + if (Constructor === Array || Constructor === undefined) { + return nativeSlice.call(O, k, fin); + } + } + result = new (Constructor === undefined ? Array : Constructor)(max$3(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]); + result.length = n; + return result; + } +}); + +var FAILS_ON_PRIMITIVES$1 = fails(function () { objectGetPrototypeOf(1); }); + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$1, sham: !correctPrototypeGetter }, { + getPrototypeOf: function getPrototypeOf(it) { + return objectGetPrototypeOf(toObject(it)); + } +}); + +// `Object.prototype.toString` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.tostring +var objectToString = toStringTagSupport ? {}.toString : function toString() { + return '[object ' + classof(this) + ']'; +}; + +// `Object.prototype.toString` method +// https://tc39.es/ecma262/#sec-object.prototype.tostring +if (!toStringTagSupport) { + redefine(Object.prototype, 'toString', objectToString, { unsafe: true }); +} + +var MATCH = wellKnownSymbol('match'); + +// `IsRegExp` abstract operation +// https://tc39.es/ecma262/#sec-isregexp +var isRegexp = function (it) { + var isRegExp; + return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classofRaw(it) == 'RegExp'); +}; + +var SPECIES$4 = wellKnownSymbol('species'); + +var setSpecies = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn(CONSTRUCTOR_NAME); + var defineProperty = objectDefineProperty.f; + + if (descriptors && Constructor && !Constructor[SPECIES$4]) { + defineProperty(Constructor, SPECIES$4, { + configurable: true, + get: function () { return this; } + }); + } +}; + +var defineProperty$2 = objectDefineProperty.f; +var getOwnPropertyNames$1 = objectGetOwnPropertyNames.f; + + + + + +var setInternalState$1 = internalState.set; + + + +var MATCH$1 = wellKnownSymbol('match'); +var NativeRegExp = global_1.RegExp; +var RegExpPrototype = NativeRegExp.prototype; +var re1 = /a/g; +var re2 = /a/g; + +// "new" should create a new object, old webkit bug +var CORRECT_NEW = new NativeRegExp(re1) !== re1; + +var UNSUPPORTED_Y$2 = regexpStickyHelpers.UNSUPPORTED_Y; + +var FORCED$3 = descriptors && isForced_1('RegExp', (!CORRECT_NEW || UNSUPPORTED_Y$2 || fails(function () { + re2[MATCH$1] = false; + // RegExp constructor can alter flags and IsRegExp works correct with @@match + return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i'; +}))); + +// `RegExp` constructor +// https://tc39.es/ecma262/#sec-regexp-constructor +if (FORCED$3) { + var RegExpWrapper = function RegExp(pattern, flags) { + var thisIsRegExp = this instanceof RegExpWrapper; + var patternIsRegExp = isRegexp(pattern); + var flagsAreUndefined = flags === undefined; + var sticky; + + if (!thisIsRegExp && patternIsRegExp && pattern.constructor === RegExpWrapper && flagsAreUndefined) { + return pattern; + } + + if (CORRECT_NEW) { + if (patternIsRegExp && !flagsAreUndefined) pattern = pattern.source; + } else if (pattern instanceof RegExpWrapper) { + if (flagsAreUndefined) flags = regexpFlags.call(pattern); + pattern = pattern.source; + } + + if (UNSUPPORTED_Y$2) { + sticky = !!flags && flags.indexOf('y') > -1; + if (sticky) flags = flags.replace(/y/g, ''); + } + + var result = inheritIfRequired( + CORRECT_NEW ? new NativeRegExp(pattern, flags) : NativeRegExp(pattern, flags), + thisIsRegExp ? this : RegExpPrototype, + RegExpWrapper + ); + + if (UNSUPPORTED_Y$2 && sticky) setInternalState$1(result, { sticky: sticky }); + + return result; + }; + var proxy = function (key) { + key in RegExpWrapper || defineProperty$2(RegExpWrapper, key, { + configurable: true, + get: function () { return NativeRegExp[key]; }, + set: function (it) { NativeRegExp[key] = it; } + }); + }; + var keys$2 = getOwnPropertyNames$1(NativeRegExp); + var index = 0; + while (keys$2.length > index) proxy(keys$2[index++]); + RegExpPrototype.constructor = RegExpWrapper; + RegExpWrapper.prototype = RegExpPrototype; + redefine(global_1, 'RegExp', RegExpWrapper); +} + +// https://tc39.es/ecma262/#sec-get-regexp-@@species +setSpecies('RegExp'); + +var TO_STRING = 'toString'; +var RegExpPrototype$1 = RegExp.prototype; +var nativeToString = RegExpPrototype$1[TO_STRING]; + +var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; }); +// FF44- RegExp#toString has a wrong name +var INCORRECT_NAME = nativeToString.name != TO_STRING; + +// `RegExp.prototype.toString` method +// https://tc39.es/ecma262/#sec-regexp.prototype.tostring +if (NOT_GENERIC || INCORRECT_NAME) { + redefine(RegExp.prototype, TO_STRING, function toString() { + var R = anObject(this); + var p = String(R.source); + var rf = R.flags; + var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype$1) ? regexpFlags.call(R) : rf); + return '/' + p + '/' + f; + }, { unsafe: true }); +} + +var notARegexp = function (it) { + if (isRegexp(it)) { + throw TypeError("The method doesn't accept regular expressions"); + } return it; +}; + +var MATCH$2 = wellKnownSymbol('match'); + +var correctIsRegexpLogic = function (METHOD_NAME) { + var regexp = /./; + try { + '/./'[METHOD_NAME](regexp); + } catch (error1) { + try { + regexp[MATCH$2] = false; + return '/./'[METHOD_NAME](regexp); + } catch (error2) { /* empty */ } + } return false; +}; + +// `String.prototype.includes` method +// https://tc39.es/ecma262/#sec-string.prototype.includes +_export({ target: 'String', proto: true, forced: !correctIsRegexpLogic('includes') }, { + includes: function includes(searchString /* , position = 0 */) { + return !!~String(requireObjectCoercible(this)) + .indexOf(notARegexp(searchString), arguments.length > 1 ? arguments[1] : undefined); + } +}); + +var SPECIES$5 = wellKnownSymbol('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.es/ecma262/#sec-speciesconstructor +var speciesConstructor = function (O, defaultConstructor) { + var C = anObject(O).constructor; + var S; + return C === undefined || (S = anObject(C)[SPECIES$5]) == undefined ? defaultConstructor : aFunction$1(S); +}; + +var arrayPush = [].push; +var min$4 = Math.min; +var MAX_UINT32 = 0xFFFFFFFF; + +// babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError +var SUPPORTS_Y = !fails(function () { return !RegExp(MAX_UINT32, 'y'); }); + +// @@split logic +fixRegexpWellKnownSymbolLogic('split', 2, function (SPLIT, nativeSplit, maybeCallNative) { + var internalSplit; + if ( + 'abbc'.split(/(b)*/)[1] == 'c' || + // eslint-disable-next-line regexp/no-empty-group -- required for testing + 'test'.split(/(?:)/, -1).length != 4 || + 'ab'.split(/(?:ab)*/).length != 2 || + '.'.split(/(.?)(.?)/).length != 4 || + // eslint-disable-next-line regexp/no-assertion-capturing-group, regexp/no-empty-group -- required for testing + '.'.split(/()()/).length > 1 || + ''.split(/.?/).length + ) { + // based on es5-shim implementation, need to rework it + internalSplit = function (separator, limit) { + var string = String(requireObjectCoercible(this)); + var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; + if (lim === 0) return []; + if (separator === undefined) return [string]; + // If `separator` is not a regex, use native split + if (!isRegexp(separator)) { + return nativeSplit.call(string, separator, lim); + } + var output = []; + var flags = (separator.ignoreCase ? 'i' : '') + + (separator.multiline ? 'm' : '') + + (separator.unicode ? 'u' : '') + + (separator.sticky ? 'y' : ''); + var lastLastIndex = 0; + // Make `global` and avoid `lastIndex` issues by working with a copy + var separatorCopy = new RegExp(separator.source, flags + 'g'); + var match, lastIndex, lastLength; + while (match = regexpExec.call(separatorCopy, string)) { + lastIndex = separatorCopy.lastIndex; + if (lastIndex > lastLastIndex) { + output.push(string.slice(lastLastIndex, match.index)); + if (match.length > 1 && match.index < string.length) arrayPush.apply(output, match.slice(1)); + lastLength = match[0].length; + lastLastIndex = lastIndex; + if (output.length >= lim) break; + } + if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop + } + if (lastLastIndex === string.length) { + if (lastLength || !separatorCopy.test('')) output.push(''); + } else output.push(string.slice(lastLastIndex)); + return output.length > lim ? output.slice(0, lim) : output; + }; + // Chakra, V8 + } else if ('0'.split(undefined, 0).length) { + internalSplit = function (separator, limit) { + return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit); + }; + } else internalSplit = nativeSplit; + + return [ + // `String.prototype.split` method + // https://tc39.es/ecma262/#sec-string.prototype.split + function split(separator, limit) { + var O = requireObjectCoercible(this); + var splitter = separator == undefined ? undefined : separator[SPLIT]; + return splitter !== undefined + ? splitter.call(separator, O, limit) + : internalSplit.call(String(O), separator, limit); + }, + // `RegExp.prototype[@@split]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@split + // + // NOTE: This cannot be properly polyfilled in engines that don't support + // the 'y' flag. + function (regexp, limit) { + var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== nativeSplit); + if (res.done) return res.value; + + var rx = anObject(regexp); + var S = String(this); + var C = speciesConstructor(rx, RegExp); + + var unicodeMatching = rx.unicode; + var flags = (rx.ignoreCase ? 'i' : '') + + (rx.multiline ? 'm' : '') + + (rx.unicode ? 'u' : '') + + (SUPPORTS_Y ? 'y' : 'g'); + + // ^(? + rx + ) is needed, in combination with some S slicing, to + // simulate the 'y' flag. + var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags); + var lim = limit === undefined ? MAX_UINT32 : limit >>> 0; + if (lim === 0) return []; + if (S.length === 0) return regexpExecAbstract(splitter, S) === null ? [S] : []; + var p = 0; + var q = 0; + var A = []; + while (q < S.length) { + splitter.lastIndex = SUPPORTS_Y ? q : 0; + var z = regexpExecAbstract(splitter, SUPPORTS_Y ? S : S.slice(q)); + var e; + if ( + z === null || + (e = min$4(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p + ) { + q = advanceStringIndex(S, q, unicodeMatching); + } else { + A.push(S.slice(p, q)); + if (A.length === lim) return A; + for (var i = 1; i <= z.length - 1; i++) { + A.push(z[i]); + if (A.length === lim) return A; + } + q = p = e; + } + } + A.push(S.slice(p)); + return A; + } + ]; +}, !SUPPORTS_Y); + +var non = '\u200B\u0085\u180E'; + +// check that a method works with the correct list +// of whitespaces and has a correct name +var stringTrimForced = function (METHOD_NAME) { + return fails(function () { + return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME; + }); +}; + +var $trim = stringTrim.trim; + + +// `String.prototype.trim` method +// https://tc39.es/ecma262/#sec-string.prototype.trim +_export({ target: 'String', proto: true, forced: stringTrimForced('trim') }, { + trim: function trim() { + return $trim(this); + } +}); + +var f$6 = wellKnownSymbol; + +var wellKnownSymbolWrapped = { + f: f$6 +}; + +var defineProperty$3 = objectDefineProperty.f; + +var defineWellKnownSymbol = function (NAME) { + var Symbol = path.Symbol || (path.Symbol = {}); + if (!has(Symbol, NAME)) defineProperty$3(Symbol, NAME, { + value: wellKnownSymbolWrapped.f(NAME) + }); +}; + +var $forEach$1 = arrayIteration.forEach; + +var HIDDEN = sharedKey('hidden'); +var SYMBOL = 'Symbol'; +var PROTOTYPE$1 = 'prototype'; +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); +var setInternalState$2 = internalState.set; +var getInternalState$1 = internalState.getterFor(SYMBOL); +var ObjectPrototype$1 = Object[PROTOTYPE$1]; +var $Symbol = global_1.Symbol; +var $stringify = getBuiltIn('JSON', 'stringify'); +var nativeGetOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; +var nativeDefineProperty$1 = objectDefineProperty.f; +var nativeGetOwnPropertyNames$2 = objectGetOwnPropertyNamesExternal.f; +var nativePropertyIsEnumerable$1 = objectPropertyIsEnumerable.f; +var AllSymbols = shared('symbols'); +var ObjectPrototypeSymbols = shared('op-symbols'); +var StringToSymbolRegistry = shared('string-to-symbol-registry'); +var SymbolToStringRegistry = shared('symbol-to-string-registry'); +var WellKnownSymbolsStore$1 = shared('wks'); +var QObject = global_1.QObject; +// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 +var USE_SETTER = !QObject || !QObject[PROTOTYPE$1] || !QObject[PROTOTYPE$1].findChild; + +// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 +var setSymbolDescriptor = descriptors && fails(function () { + return objectCreate(nativeDefineProperty$1({}, 'a', { + get: function () { return nativeDefineProperty$1(this, 'a', { value: 7 }).a; } + })).a != 7; +}) ? function (O, P, Attributes) { + var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor$1(ObjectPrototype$1, P); + if (ObjectPrototypeDescriptor) delete ObjectPrototype$1[P]; + nativeDefineProperty$1(O, P, Attributes); + if (ObjectPrototypeDescriptor && O !== ObjectPrototype$1) { + nativeDefineProperty$1(ObjectPrototype$1, P, ObjectPrototypeDescriptor); + } +} : nativeDefineProperty$1; + +var wrap$1 = function (tag, description) { + var symbol = AllSymbols[tag] = objectCreate($Symbol[PROTOTYPE$1]); + setInternalState$2(symbol, { + type: SYMBOL, + tag: tag, + description: description + }); + if (!descriptors) symbol.description = description; + return symbol; +}; + +var isSymbol = useSymbolAsUid ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + return Object(it) instanceof $Symbol; +}; + +var $defineProperty = function defineProperty(O, P, Attributes) { + if (O === ObjectPrototype$1) $defineProperty(ObjectPrototypeSymbols, P, Attributes); + anObject(O); + var key = toPrimitive(P, true); + anObject(Attributes); + if (has(AllSymbols, key)) { + if (!Attributes.enumerable) { + if (!has(O, HIDDEN)) nativeDefineProperty$1(O, HIDDEN, createPropertyDescriptor(1, {})); + O[HIDDEN][key] = true; + } else { + if (has(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false; + Attributes = objectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) }); + } return setSymbolDescriptor(O, key, Attributes); + } return nativeDefineProperty$1(O, key, Attributes); +}; + +var $defineProperties = function defineProperties(O, Properties) { + anObject(O); + var properties = toIndexedObject(Properties); + var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties)); + $forEach$1(keys, function (key) { + if (!descriptors || $propertyIsEnumerable.call(properties, key)) $defineProperty(O, key, properties[key]); + }); + return O; +}; + +var $create = function create(O, Properties) { + return Properties === undefined ? objectCreate(O) : $defineProperties(objectCreate(O), Properties); +}; + +var $propertyIsEnumerable = function propertyIsEnumerable(V) { + var P = toPrimitive(V, true); + var enumerable = nativePropertyIsEnumerable$1.call(this, P); + if (this === ObjectPrototype$1 && has(AllSymbols, P) && !has(ObjectPrototypeSymbols, P)) return false; + return enumerable || !has(this, P) || !has(AllSymbols, P) || has(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true; +}; + +var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) { + var it = toIndexedObject(O); + var key = toPrimitive(P, true); + if (it === ObjectPrototype$1 && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key)) return; + var descriptor = nativeGetOwnPropertyDescriptor$1(it, key); + if (descriptor && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) { + descriptor.enumerable = true; + } + return descriptor; +}; + +var $getOwnPropertyNames = function getOwnPropertyNames(O) { + var names = nativeGetOwnPropertyNames$2(toIndexedObject(O)); + var result = []; + $forEach$1(names, function (key) { + if (!has(AllSymbols, key) && !has(hiddenKeys, key)) result.push(key); + }); + return result; +}; + +var $getOwnPropertySymbols = function getOwnPropertySymbols(O) { + var IS_OBJECT_PROTOTYPE = O === ObjectPrototype$1; + var names = nativeGetOwnPropertyNames$2(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O)); + var result = []; + $forEach$1(names, function (key) { + if (has(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || has(ObjectPrototype$1, key))) { + result.push(AllSymbols[key]); + } + }); + return result; +}; + +// `Symbol` constructor +// https://tc39.es/ecma262/#sec-symbol-constructor +if (!nativeSymbol) { + $Symbol = function Symbol() { + if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor'); + var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]); + var tag = uid(description); + var setter = function (value) { + if (this === ObjectPrototype$1) setter.call(ObjectPrototypeSymbols, value); + if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false; + setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value)); + }; + if (descriptors && USE_SETTER) setSymbolDescriptor(ObjectPrototype$1, tag, { configurable: true, set: setter }); + return wrap$1(tag, description); + }; + + redefine($Symbol[PROTOTYPE$1], 'toString', function toString() { + return getInternalState$1(this).tag; + }); + + redefine($Symbol, 'withoutSetter', function (description) { + return wrap$1(uid(description), description); + }); + + objectPropertyIsEnumerable.f = $propertyIsEnumerable; + objectDefineProperty.f = $defineProperty; + objectGetOwnPropertyDescriptor.f = $getOwnPropertyDescriptor; + objectGetOwnPropertyNames.f = objectGetOwnPropertyNamesExternal.f = $getOwnPropertyNames; + objectGetOwnPropertySymbols.f = $getOwnPropertySymbols; + + wellKnownSymbolWrapped.f = function (name) { + return wrap$1(wellKnownSymbol(name), name); + }; + + if (descriptors) { + // https://github.com/tc39/proposal-Symbol-description + nativeDefineProperty$1($Symbol[PROTOTYPE$1], 'description', { + configurable: true, + get: function description() { + return getInternalState$1(this).description; + } + }); + { + redefine(ObjectPrototype$1, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true }); + } + } +} + +_export({ global: true, wrap: true, forced: !nativeSymbol, sham: !nativeSymbol }, { + Symbol: $Symbol +}); + +$forEach$1(objectKeys(WellKnownSymbolsStore$1), function (name) { + defineWellKnownSymbol(name); +}); + +_export({ target: SYMBOL, stat: true, forced: !nativeSymbol }, { + // `Symbol.for` method + // https://tc39.es/ecma262/#sec-symbol.for + 'for': function (key) { + var string = String(key); + if (has(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string]; + var symbol = $Symbol(string); + StringToSymbolRegistry[string] = symbol; + SymbolToStringRegistry[symbol] = string; + return symbol; + }, + // `Symbol.keyFor` method + // https://tc39.es/ecma262/#sec-symbol.keyfor + keyFor: function keyFor(sym) { + if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol'); + if (has(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym]; + }, + useSetter: function () { USE_SETTER = true; }, + useSimple: function () { USE_SETTER = false; } +}); + +_export({ target: 'Object', stat: true, forced: !nativeSymbol, sham: !descriptors }, { + // `Object.create` method + // https://tc39.es/ecma262/#sec-object.create + create: $create, + // `Object.defineProperty` method + // https://tc39.es/ecma262/#sec-object.defineproperty + defineProperty: $defineProperty, + // `Object.defineProperties` method + // https://tc39.es/ecma262/#sec-object.defineproperties + defineProperties: $defineProperties, + // `Object.getOwnPropertyDescriptor` method + // https://tc39.es/ecma262/#sec-object.getownpropertydescriptors + getOwnPropertyDescriptor: $getOwnPropertyDescriptor +}); + +_export({ target: 'Object', stat: true, forced: !nativeSymbol }, { + // `Object.getOwnPropertyNames` method + // https://tc39.es/ecma262/#sec-object.getownpropertynames + getOwnPropertyNames: $getOwnPropertyNames, + // `Object.getOwnPropertySymbols` method + // https://tc39.es/ecma262/#sec-object.getownpropertysymbols + getOwnPropertySymbols: $getOwnPropertySymbols +}); + +// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives +// https://bugs.chromium.org/p/v8/issues/detail?id=3443 +_export({ target: 'Object', stat: true, forced: fails(function () { objectGetOwnPropertySymbols.f(1); }) }, { + getOwnPropertySymbols: function getOwnPropertySymbols(it) { + return objectGetOwnPropertySymbols.f(toObject(it)); + } +}); + +// `JSON.stringify` method behavior with symbols +// https://tc39.es/ecma262/#sec-json.stringify +if ($stringify) { + var FORCED_JSON_STRINGIFY = !nativeSymbol || fails(function () { + var symbol = $Symbol(); + // MS Edge converts symbol values to JSON as {} + return $stringify([symbol]) != '[null]' + // WebKit converts symbol values to JSON as null + || $stringify({ a: symbol }) != '{}' + // V8 throws on boxed symbols + || $stringify(Object(symbol)) != '{}'; + }); + + _export({ target: 'JSON', stat: true, forced: FORCED_JSON_STRINGIFY }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + stringify: function stringify(it, replacer, space) { + var args = [it]; + var index = 1; + var $replacer; + while (arguments.length > index) args.push(arguments[index++]); + $replacer = replacer; + if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined + if (!isArray(replacer)) replacer = function (key, value) { + if (typeof $replacer == 'function') value = $replacer.call(this, key, value); + if (!isSymbol(value)) return value; + }; + args[1] = replacer; + return $stringify.apply(null, args); + } + }); +} + +// `Symbol.prototype[@@toPrimitive]` method +// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive +if (!$Symbol[PROTOTYPE$1][TO_PRIMITIVE]) { + createNonEnumerableProperty($Symbol[PROTOTYPE$1], TO_PRIMITIVE, $Symbol[PROTOTYPE$1].valueOf); +} +// `Symbol.prototype[@@toStringTag]` property +// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag +setToStringTag($Symbol, SYMBOL); + +hiddenKeys[HIDDEN] = true; + +var defineProperty$4 = objectDefineProperty.f; + + +var NativeSymbol = global_1.Symbol; + +if (descriptors && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) || + // Safari 12 bug + NativeSymbol().description !== undefined +)) { + var EmptyStringDescriptionStore = {}; + // wrap Symbol constructor for correct work with undefined description + var SymbolWrapper = function Symbol() { + var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]); + var result = this instanceof SymbolWrapper + ? new NativeSymbol(description) + // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)' + : description === undefined ? NativeSymbol() : NativeSymbol(description); + if (description === '') EmptyStringDescriptionStore[result] = true; + return result; + }; + copyConstructorProperties(SymbolWrapper, NativeSymbol); + var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype; + symbolPrototype.constructor = SymbolWrapper; + + var symbolToString = symbolPrototype.toString; + var native = String(NativeSymbol('test')) == 'Symbol(test)'; + var regexp = /^Symbol\((.*)\)[^)]+$/; + defineProperty$4(symbolPrototype, 'description', { + configurable: true, + get: function description() { + var symbol = isObject(this) ? this.valueOf() : this; + var string = symbolToString.call(symbol); + if (has(EmptyStringDescriptionStore, symbol)) return ''; + var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1'); + return desc === '' ? undefined : desc; + } + }); + + _export({ global: true, forced: true }, { + Symbol: SymbolWrapper + }); +} + +// `Symbol.iterator` well-known symbol +// https://tc39.es/ecma262/#sec-symbol.iterator +defineWellKnownSymbol('iterator'); + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState$3 = internalState.set; +var getInternalState$2 = internalState.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.es/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.es/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.es/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.es/ecma262/#sec-createarrayiterator +var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) { + setInternalState$3(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState$2(this); + var target = state.target; + var kind = state.kind; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return { value: undefined, done: true }; + } + if (kind == 'keys') return { value: index, done: false }; + if (kind == 'values') return { value: target[index], done: false }; + return { value: [index, target[index]], done: false }; +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.es/ecma262/#sec-createunmappedargumentsobject +// https://tc39.es/ecma262/#sec-createmappedargumentsobject +iterators.Arguments = iterators.Array; + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + +var ITERATOR$5 = wellKnownSymbol('iterator'); +var TO_STRING_TAG$3 = wellKnownSymbol('toStringTag'); +var ArrayValues = es_array_iterator.values; + +for (var COLLECTION_NAME$1 in domIterables) { + var Collection$1 = global_1[COLLECTION_NAME$1]; + var CollectionPrototype$1 = Collection$1 && Collection$1.prototype; + if (CollectionPrototype$1) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype$1[ITERATOR$5] !== ArrayValues) try { + createNonEnumerableProperty(CollectionPrototype$1, ITERATOR$5, ArrayValues); + } catch (error) { + CollectionPrototype$1[ITERATOR$5] = ArrayValues; + } + if (!CollectionPrototype$1[TO_STRING_TAG$3]) { + createNonEnumerableProperty(CollectionPrototype$1, TO_STRING_TAG$3, COLLECTION_NAME$1); + } + if (domIterables[COLLECTION_NAME$1]) for (var METHOD_NAME in es_array_iterator) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype$1[METHOD_NAME] !== es_array_iterator[METHOD_NAME]) try { + createNonEnumerableProperty(CollectionPrototype$1, METHOD_NAME, es_array_iterator[METHOD_NAME]); + } catch (error) { + CollectionPrototype$1[METHOD_NAME] = es_array_iterator[METHOD_NAME]; + } + } + } +} + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +// https://gist.github.com/paulirish/1579671 + +/* eslint-disable no-restricted-globals */ +var lastTime = 0; +var vendors = ['ms', 'moz', 'webkit', 'o']; +var _requestAnimationFrame = window.requestAnimationFrame; +var _cancelAnimationFrame = window.cancelAnimationFrame; + +for (var x = 0; x < vendors.length && !_requestAnimationFrame; ++x) { + _requestAnimationFrame = window["".concat(vendors[x], "RequestAnimationFrame")]; + _cancelAnimationFrame = window["".concat(vendors[x], "CancelAnimationFrame")] || window["".concat(vendors[x], "CancelRequestAnimationFrame")]; +} + +if (!_requestAnimationFrame) { + _requestAnimationFrame = function _requestAnimationFrame(callback) { + var currTime = new Date().getTime(); + var timeToCall = Math.max(0, 16 - (currTime - lastTime)); + var id = window.setTimeout(function () { + callback(currTime + timeToCall); + }, timeToCall); + lastTime = currTime + timeToCall; + return id; + }; +} + +if (!_cancelAnimationFrame) { + _cancelAnimationFrame = function _cancelAnimationFrame(id) { + clearTimeout(id); + }; +} +/** + * Polyfill for requestAnimationFrame. + * + * @param {Function} callback The function to call when it's time. + * @returns {number} + */ + + +function requestAnimationFrame(callback) { + return _requestAnimationFrame.call(window, callback); +} +/** + * @returns {boolean} + */ + +function isClassListSupported() { + return !!document.documentElement.classList; +} +/** + * @returns {boolean} + */ + +function isTextContentSupported() { + return !!document.createTextNode('test').textContent; +} +/** + * @returns {boolean} + */ + +function isGetComputedStyleSupported() { + return !!window.getComputedStyle; +} +/** + * Polyfill for cancelAnimationFrame. + * + * @param {number} id The request Id, generated by `requestAnimationFrame`. + */ + +function cancelAnimationFrame(id) { + _cancelAnimationFrame.call(window, id); +} +/** + * @returns {boolean} + */ + +function isTouchSupported() { + return 'ontouchstart' in window; +} + +var _hasCaptionProblem; +/** + * + */ + + +function detectCaptionProblem() { + var TABLE = document.createElement('TABLE'); + TABLE.style.borderSpacing = '0'; + TABLE.style.borderWidth = '0'; + TABLE.style.padding = '0'; + var TBODY = document.createElement('TBODY'); + TABLE.appendChild(TBODY); + TBODY.appendChild(document.createElement('TR')); + TBODY.firstChild.appendChild(document.createElement('TD')); + TBODY.firstChild.firstChild.innerHTML = 't
t'; + var CAPTION = document.createElement('CAPTION'); + CAPTION.innerHTML = 'c
c
c
c'; + CAPTION.style.padding = '0'; + CAPTION.style.margin = '0'; + TABLE.insertBefore(CAPTION, TBODY); + document.body.appendChild(TABLE); + _hasCaptionProblem = TABLE.offsetHeight < 2 * TABLE.lastChild.offsetHeight; // boolean + + document.body.removeChild(TABLE); +} +/** + * @returns {boolean} + */ + + +function hasCaptionProblem() { + if (_hasCaptionProblem === void 0) { + detectCaptionProblem(); + } + + return _hasCaptionProblem; +} +var comparisonFunction; +/** + * Get string comparison function for sorting purposes. It supports multilingual string comparison base on Internationalization API. + * + * @param {string} [language] The language code used for phrases sorting. + * @param {object} [options] Additional options for sort comparator. + * @returns {*} + */ + +function getComparisonFunction(language) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (comparisonFunction) { + return comparisonFunction; + } + + if ((typeof Intl === "undefined" ? "undefined" : _typeof(Intl)) === 'object') { + comparisonFunction = new Intl.Collator(language, options).compare; + } else if (typeof String.prototype.localeCompare === 'function') { + comparisonFunction = function comparisonFunction(a, b) { + return "".concat(a).localeCompare(b); + }; + } else { + comparisonFunction = function comparisonFunction(a, b) { + if (a === b) { + return 0; + } + + return a > b ? -1 : 1; + }; + } + + return comparisonFunction; +} +var passiveSupported; +/** + * Checks if browser supports passive events. + * + * @returns {boolean} + */ + +function isPassiveEventSupported() { + if (passiveSupported !== void 0) { + return passiveSupported; + } + + try { + var options = { + get passive() { + passiveSupported = true; + } + + }; // eslint-disable-next-line no-restricted-globals + + window.addEventListener('test', options, options); // eslint-disable-next-line no-restricted-globals + + window.removeEventListener('test', options, options); + } catch (err) { + passiveSupported = false; + } + + return passiveSupported; +} + +var featureHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + requestAnimationFrame: requestAnimationFrame, + isClassListSupported: isClassListSupported, + isTextContentSupported: isTextContentSupported, + isGetComputedStyleSupported: isGetComputedStyleSupported, + cancelAnimationFrame: cancelAnimationFrame, + isTouchSupported: isTouchSupported, + hasCaptionProblem: hasCaptionProblem, + getComparisonFunction: getComparisonFunction, + isPassiveEventSupported: isPassiveEventSupported +}); + +var freezing = !fails(function () { + return Object.isExtensible(Object.preventExtensions({})); +}); + +var internalMetadata = createCommonjsModule(function (module) { +var defineProperty = objectDefineProperty.f; + + + +var METADATA = uid('meta'); +var id = 0; + +var isExtensible = Object.isExtensible || function () { + return true; +}; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + ++id, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!has(it, METADATA)) { + // 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 + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData = function (it, create) { + if (!has(it, METADATA)) { + // 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 + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (freezing && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it); + return it; +}; + +var meta = module.exports = { + REQUIRED: false, + fastKey: fastKey, + getWeakData: getWeakData, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; +}); + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var iterate = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = functionBindContext(unboundFunction, that, 1 + AS_ENTRIES + INTERRUPTED); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose(iterator); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (typeof iterFn != 'function') throw TypeError('Target is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = toLength(iterable.length); length > index; index++) { + result = callFn(iterable[index]); + if (result && result instanceof Result) return result; + } return new Result(false); + } + iterator = iterFn.call(iterable); + } + + next = iterator.next; + while (!(step = next.call(iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose(iterator); + throw error; + } + if (typeof result == 'object' && result && result instanceof Result) return result; + } return new Result(false); +}; + +var anInstance = function (it, Constructor, name) { + if (!(it instanceof Constructor)) { + throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation'); + } return it; +}; + +var collection = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global_1[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var nativeMethod = NativePrototype[KEY]; + redefine(NativePrototype, KEY, + KEY == 'add' ? function add(value) { + nativeMethod.call(this, value === 0 ? 0 : value); + return this; + } : KEY == 'delete' ? function (key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == 'get' ? function get(key) { + return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key); + } : KEY == 'has' ? function has(key) { + return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key); + } : function set(key, value) { + nativeMethod.call(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced_1( + CONSTRUCTOR_NAME, + typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + internalMetadata.REQUIRED = true; + } else if (isForced_1(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance(dummy, Constructor, CONSTRUCTOR_NAME); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + 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 && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + _export({ global: true, forced: Constructor != NativeConstructor }, exported); + + setToStringTag(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + +var redefineAll = function (target, src, options) { + for (var key in src) redefine(target, key, src[key], options); + return target; +}; + +var defineProperty$5 = objectDefineProperty.f; + + + + + + + + +var fastKey = internalMetadata.fastKey; + + +var setInternalState$4 = internalState.set; +var internalStateGetterFor = internalState.getterFor; + +var collectionStrong = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, CONSTRUCTOR_NAME); + setInternalState$4(that, { + type: CONSTRUCTOR_NAME, + index: objectCreate(null), + first: undefined, + last: undefined, + size: 0 + }); + if (!descriptors) that.size = 0; + if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + // change existing entry + if (entry) { + entry.value = value; + // create new entry + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: undefined, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (descriptors) state.size++; + else that.size++; + // add to index + if (index !== 'F') state.index[index] = entry; + } return that; + }; + + var getEntry = function (that, key) { + var state = getInternalState(that); + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return state.index[index]; + // frozen object case + for (entry = state.first; entry; entry = entry.next) { + if (entry.key == key) return entry; + } + }; + + redefineAll(C.prototype, { + // 23.1.3.1 Map.prototype.clear() + // 23.2.3.2 Set.prototype.clear() + clear: function clear() { + var that = this; + var state = getInternalState(that); + var data = state.index; + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = undefined; + delete data[entry.index]; + entry = entry.next; + } + state.first = state.last = undefined; + if (descriptors) state.size = 0; + else 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; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first == entry) state.first = next; + if (state.last == entry) state.last = prev; + if (descriptors) state.size--; + else 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 */) { + var state = getInternalState(this); + var boundFunction = functionBindContext(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + } + }, + // 23.1.3.7 Map.prototype.has(key) + // 23.2.3.7 Set.prototype.has(value) + has: function has(key) { + return !!getEntry(this, key); + } + }); + + redefineAll(C.prototype, IS_MAP ? { + // 23.1.3.6 Map.prototype.get(key) + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // 23.1.3.9 Map.prototype.set(key, value) + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // 23.2.3.1 Set.prototype.add(value) + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (descriptors) defineProperty$5(C.prototype, 'size', { + get: function () { + return getInternalState(this).size; + } + }); + return C; + }, + setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + // 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 + defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState$4(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: undefined + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + // get next entry + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + // or finish the iteration + state.target = undefined; + return { value: undefined, done: true }; + } + // return step by kind + if (kind == 'keys') return { value: entry.key, done: false }; + if (kind == 'values') return { value: entry.value, done: false }; + return { value: [entry.key, entry.value], done: false }; + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // add [@@species], 23.1.2.2, 23.2.2.2 + setSpecies(CONSTRUCTOR_NAME); + } +}; + +// `Set` constructor +// https://tc39.es/ecma262/#sec-set-objects +collection('Set', function (init) { + return function Set() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionStrong); + +/** + * @param {Array} arr An array to process. + */ +function to2dArray(arr) { + var ilen = arr.length; + var i = 0; + + while (i < ilen) { + arr[i] = [arr[i]]; + i += 1; + } +} +/** + * @param {Array} arr An array to extend. + * @param {Array} extension The data to extend from. + */ + +function extendArray(arr, extension) { + var ilen = extension.length; + var i = 0; + + while (i < ilen) { + arr.push(extension[i]); + i += 1; + } +} +/** + * @param {Array} arr An array to pivot. + * @returns {Array} + */ + +function pivot(arr) { + var pivotedArr = []; + + if (!arr || arr.length === 0 || !arr[0] || arr[0].length === 0) { + return pivotedArr; + } + + var rowCount = arr.length; + var colCount = arr[0].length; + + for (var i = 0; i < rowCount; i++) { + for (var j = 0; j < colCount; j++) { + if (!pivotedArr[j]) { + pivotedArr[j] = []; + } + + pivotedArr[j][i] = arr[i][j]; + } + } + + return pivotedArr; +} +/** + * A specialized version of `.reduce` for arrays without support for callback + * shorthands and `this` binding. + * + * {@link https://github.com/lodash/lodash/blob/master/lodash.js}. + * + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {*} [accumulator] The initial value. + * @param {boolean} [initFromArray] Specify using the first element of `array` as the initial value. + * @returns {*} Returns the accumulated value. + */ + +function arrayReduce(array, iteratee, accumulator, initFromArray) { + var index = -1; + var iterable = array; + var result = accumulator; + + if (!Array.isArray(array)) { + iterable = Array.from(array); + } + + var length = iterable.length; + + if (initFromArray && length) { + index += 1; + result = iterable[index]; + } + + index += 1; + + while (index < length) { + result = iteratee(result, iterable[index], index, iterable); + index += 1; + } + + return result; +} +/** + * A specialized version of `.filter` for arrays without support for callback + * shorthands and `this` binding. + * + * {@link https://github.com/lodash/lodash/blob/master/lodash.js}. + * + * @param {Array} array The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ + +function arrayFilter(array, predicate) { + var index = 0; + var iterable = array; + + if (!Array.isArray(array)) { + iterable = Array.from(array); + } + + var length = iterable.length; + var result = []; + var resIndex = -1; + + while (index < length) { + var value = iterable[index]; + + if (predicate(value, index, iterable)) { + resIndex += 1; + result[resIndex] = value; + } + + index += 1; + } + + return result; +} +/** + * A specialized version of `.map` for arrays without support for callback + * shorthands and `this` binding. + * + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ + +function arrayMap(array, iteratee) { + var index = 0; + var iterable = array; + + if (!Array.isArray(array)) { + iterable = Array.from(array); + } + + var length = iterable.length; + var result = []; + var resIndex = -1; + + while (index < length) { + var value = iterable[index]; + resIndex += 1; + result[resIndex] = iteratee(value, index, iterable); + index += 1; + } + + return result; +} +/** + * A specialized version of `.forEach` for arrays without support for callback + * shorthands and `this` binding. + * + * {@link https://github.com/lodash/lodash/blob/master/lodash.js}. + * + * @param {Array|*} array The array to iterate over or an any element with implemented iterator protocol. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + +function arrayEach(array, iteratee) { + var index = 0; + var iterable = array; + + if (!Array.isArray(array)) { + iterable = Array.from(array); + } + + var length = iterable.length; + + while (index < length) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + + index += 1; + } + + return array; +} +/** + * Calculate sum value for each item of the array. + * + * @param {Array} array The array to process. + * @returns {number} Returns calculated sum value. + */ + +function arraySum(array) { + return arrayReduce(array, function (a, b) { + return a + b; + }, 0); +} +/** + * Returns the highest value from an array. Can be array of numbers or array of strings. + * NOTICE: Mixed values is not supported. + * + * @param {Array} array The array to process. + * @returns {number} Returns the highest value from an array. + */ + +function arrayMax(array) { + return arrayReduce(array, function (a, b) { + return a > b ? a : b; + }, Array.isArray(array) ? array[0] : void 0); +} +/** + * Returns the lowest value from an array. Can be array of numbers or array of strings. + * NOTICE: Mixed values is not supported. + * + * @param {Array} array The array to process. + * @returns {number} Returns the lowest value from an array. + */ + +function arrayMin(array) { + return arrayReduce(array, function (a, b) { + return a < b ? a : b; + }, Array.isArray(array) ? array[0] : void 0); +} +/** + * Calculate average value for each item of the array. + * + * @param {Array} array The array to process. + * @returns {number} Returns calculated average value. + */ + +function arrayAvg(array) { + if (!array.length) { + return 0; + } + + return arraySum(array) / array.length; +} +/** + * Flatten multidimensional array. + * + * @param {Array} array Array of Arrays. + * @returns {Array} + */ + +function arrayFlatten(array) { + return arrayReduce(array, function (initial, value) { + return initial.concat(Array.isArray(value) ? arrayFlatten(value) : value); + }, []); +} +/** + * Unique values in the array. + * + * @param {Array} array The array to process. + * @returns {Array} + */ + +function arrayUnique(array) { + var unique = []; + arrayEach(array, function (value) { + if (unique.indexOf(value) === -1) { + unique.push(value); + } + }); + return unique; +} +/** + * Differences from two or more arrays. + * + * @param {...Array} arrays Array of strings or array of numbers. + * @returns {Array} Returns the difference between arrays. + */ + +function getDifferenceOfArrays() { + for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) { + arrays[_key] = arguments[_key]; + } + + var _ref = [].concat(arrays), + first = _ref[0], + rest = _ref.slice(1); + + var filteredFirstArray = first; + arrayEach(rest, function (array) { + filteredFirstArray = filteredFirstArray.filter(function (value) { + return !array.includes(value); + }); + }); + return filteredFirstArray; +} +/** + * Intersection of two or more arrays. + * + * @param {...Array} arrays Array of strings or array of numbers. + * @returns {Array} Returns elements that exists in every array. + */ + +function getIntersectionOfArrays() { + for (var _len2 = arguments.length, arrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + arrays[_key2] = arguments[_key2]; + } + + var _ref2 = [].concat(arrays), + first = _ref2[0], + rest = _ref2.slice(1); + + var filteredFirstArray = first; + arrayEach(rest, function (array) { + filteredFirstArray = filteredFirstArray.filter(function (value) { + return array.includes(value); + }); + }); + return filteredFirstArray; +} +/** + * Union of two or more arrays. + * + * @param {...Array} arrays Array of strings or array of numbers. + * @returns {Array} Returns the elements that exist in any of the arrays, without duplicates. + */ + +function getUnionOfArrays() { + for (var _len3 = arguments.length, arrays = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + arrays[_key3] = arguments[_key3]; + } + + var _ref3 = [].concat(arrays), + first = _ref3[0], + rest = _ref3.slice(1); + + var set = new Set(first); + arrayEach(rest, function (array) { + arrayEach(array, function (value) { + if (!set.has(value)) { + set.add(value); + } + }); + }); + return Array.from(set); +} +/** + * Convert a separated strings to an array of strings. + * + * @param {string} value A string of class name(s). + * @param {string|RegExp} delimiter The pattern describing where each split should occur. + * @returns {string[]} Returns array of string or empty array. + */ + +function stringToArray(value) { + var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ' '; + return value.split(delimiter); +} + +var arrayHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + to2dArray: to2dArray, + extendArray: extendArray, + pivot: pivot, + arrayReduce: arrayReduce, + arrayFilter: arrayFilter, + arrayMap: arrayMap, + arrayEach: arrayEach, + arraySum: arraySum, + arrayMax: arrayMax, + arrayMin: arrayMin, + arrayAvg: arrayAvg, + arrayFlatten: arrayFlatten, + arrayUnique: arrayUnique, + getDifferenceOfArrays: getDifferenceOfArrays, + getIntersectionOfArrays: getIntersectionOfArrays, + getUnionOfArrays: getUnionOfArrays, + stringToArray: stringToArray +}); + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _typeof$1(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1 = function _typeof(obj) { return typeof obj; }; } else { _typeof$1 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1(obj); } +/** + * Generate schema for passed object. + * + * @param {Array|object} object An object to analyze. + * @returns {Array|object} + */ + +function duckSchema(object) { + var schema; + + if (Array.isArray(object)) { + schema = []; + } else { + schema = {}; + objectEach(object, function (value, key) { + if (key === '__children') { + return; + } + + if (value && _typeof$1(value) === 'object' && !Array.isArray(value)) { + schema[key] = duckSchema(value); + } else if (Array.isArray(value)) { + if (value.length && _typeof$1(value[0]) === 'object' && !Array.isArray(value[0])) { + schema[key] = [duckSchema(value[0])]; + } else { + schema[key] = []; + } + } else { + schema[key] = null; + } + }); + } + + return schema; +} +/** + * Inherit without without calling parent constructor, and setting `Child.prototype.constructor` to `Child` instead of `Parent`. + * Creates temporary dummy function to call it as constructor. + * Described in ticket: https://github.com/handsontable/handsontable/pull/516. + * + * @param {object} Child The child class. + * @param {object} Parent The parent class. + * @returns {object} + */ + +function inherit(Child, Parent) { + Parent.prototype.constructor = Parent; + Child.prototype = new Parent(); + Child.prototype.constructor = Child; + return Child; +} +/** + * Perform shallow extend of a target object with extension's own properties. + * + * @param {object} target An object that will receive the new properties. + * @param {object} extension An object containing additional properties to merge into the target. + * @param {string[]} [writableKeys] An array of keys that are writable to target object. + * @returns {object} + */ + +function extend(target, extension, writableKeys) { + var hasWritableKeys = Array.isArray(writableKeys); + objectEach(extension, function (value, key) { + if (hasWritableKeys === false || writableKeys.includes(key)) { + target[key] = value; + } + }); + return target; +} +/** + * Perform deep extend of a target object with extension's own properties. + * + * @param {object} target An object that will receive the new properties. + * @param {object} extension An object containing additional properties to merge into the target. + */ + +function deepExtend(target, extension) { + objectEach(extension, function (value, key) { + if (extension[key] && _typeof$1(extension[key]) === 'object') { + if (!target[key]) { + if (Array.isArray(extension[key])) { + target[key] = []; + } else if (Object.prototype.toString.call(extension[key]) === '[object Date]') { + target[key] = extension[key]; + } else { + target[key] = {}; + } + } + + deepExtend(target[key], extension[key]); + } else { + target[key] = extension[key]; + } + }); +} +/** + * Perform deep clone of an object. + * WARNING! Only clones JSON properties. Will cause error when `obj` contains a function, Date, etc. + * + * @param {object} obj An object that will be cloned. + * @returns {object} + */ + +function deepClone(obj) { + if (_typeof$1(obj) === 'object') { + return JSON.parse(JSON.stringify(obj)); + } + + return obj; +} +/** + * Shallow clone object. + * + * @param {object} object An object to clone. + * @returns {object} + */ + +function clone(object) { + var result = {}; + objectEach(object, function (value, key) { + result[key] = value; + }); + return result; +} +/** + * Extend the Base object (usually prototype) of the functionality the `mixins` objects. + * + * @param {object} Base Base object which will be extended. + * @param {object} mixins The object of the functionality will be "copied". + * @returns {object} + */ + +function mixin(Base) { + if (!Base.MIXINS) { + Base.MIXINS = []; + } + + for (var _len = arguments.length, mixins = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + mixins[_key - 1] = arguments[_key]; + } + + arrayEach(mixins, function (mixinItem) { + Base.MIXINS.push(mixinItem.MIXIN_NAME); + objectEach(mixinItem, function (value, key) { + if (Base.prototype[key] !== void 0) { + throw new Error("Mixin conflict. Property '".concat(key, "' already exist and cannot be overwritten.")); + } + + if (typeof value === 'function') { + Base.prototype[key] = value; + } else { + var getter = function _getter(property, initialValue) { + var propertyName = "_".concat(property); + + var initValue = function initValue(newValue) { + var result = newValue; + + if (Array.isArray(result) || isObject$1(result)) { + result = deepClone(result); + } + + return result; + }; + + return function () { + if (this[propertyName] === void 0) { + this[propertyName] = initValue(initialValue); + } + + return this[propertyName]; + }; + }; + + var setter = function _setter(property) { + var propertyName = "_".concat(property); + return function (newValue) { + this[propertyName] = newValue; + }; + }; + + Object.defineProperty(Base.prototype, key, { + get: getter(key, value), + set: setter(key), + configurable: true + }); + } + }); + }); + return Base; +} +/** + * Checks if two objects or arrays are (deep) equal. + * + * @param {object|Array} object1 The first object to compare. + * @param {object|Array} object2 The second object to compare. + * @returns {boolean} + */ + +function isObjectEqual(object1, object2) { + return JSON.stringify(object1) === JSON.stringify(object2); +} +/** + * Determines whether given object is a plain Object. + * Note: String and Array are not plain Objects. + * + * @param {*} object An object to check. + * @returns {boolean} + */ + +function isObject$1(object) { + return Object.prototype.toString.call(object) === '[object Object]'; +} +/** + * @param {object} object The object on which to define the property. + * @param {string} property The name of the property to be defined or modified. + * @param {*} value The value associated with the property. + * @param {object} options The descriptor for the property being defined or modified. + */ + +function defineGetter(object, property, value, options) { + options.value = value; + options.writable = options.writable !== false; + options.enumerable = options.enumerable !== false; + options.configurable = options.configurable !== false; + Object.defineProperty(object, property, options); +} +/** + * A specialized version of `.forEach` for objects. + * + * @param {object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {object} Returns `object`. + */ + +function objectEach(object, iteratee) { + // eslint-disable-next-line no-restricted-syntax + for (var key in object) { + if (!object.hasOwnProperty || object.hasOwnProperty && Object.prototype.hasOwnProperty.call(object, key)) { + if (iteratee(object[key], key, object) === false) { + break; + } + } + } + + return object; +} +/** + * Get object property by its name. Access to sub properties can be achieved by dot notation (e.q. `'foo.bar.baz'`). + * + * @param {object} object Object which value will be exported. + * @param {string} name Object property name. + * @returns {*} + */ + +function getProperty(object, name) { + var names = name.split('.'); + var result = object; + objectEach(names, function (nameItem) { + result = result[nameItem]; + + if (result === void 0) { + result = void 0; + return false; + } + }); + return result; +} +/** + * Set a property value on the provided object. Works on nested object prop names as well (e.g. `first.name`). + * + * @param {object} object Object to work on. + * @param {string} name Prop name. + * @param {*} value Value to be assigned at the provided property. + */ + +function setProperty(object, name, value) { + var names = name.split('.'); + var workingObject = object; + names.forEach(function (propName, index) { + if (index !== names.length - 1) { + if (!hasOwnProperty$1(workingObject, propName)) { + workingObject[propName] = {}; + } + + workingObject = workingObject[propName]; + } else { + workingObject[propName] = value; + } + }); +} +/** + * Return object length (recursively). + * + * @param {*} object Object for which we want get length. + * @returns {number} + */ + +function deepObjectSize(object) { + if (!isObject$1(object)) { + return 0; + } + + var recursObjLen = function recursObjLen(obj) { + var result = 0; + + if (isObject$1(obj)) { + objectEach(obj, function (value, key) { + if (key === '__children') { + return; + } + + result += recursObjLen(value); + }); + } else { + result += 1; + } + + return result; + }; + + return recursObjLen(object); +} +/** + * Create object with property where its value change will be observed. + * + * @param {*} [defaultValue=undefined] Default value. + * @param {string} [propertyToListen='value'] Property to listen. + * @returns {object} + */ + +function createObjectPropListener(defaultValue) { + var _holder; + + var propertyToListen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'value'; + var privateProperty = "_".concat(propertyToListen); + var holder = (_holder = { + _touched: false + }, _defineProperty(_holder, privateProperty, defaultValue), _defineProperty(_holder, "isTouched", function isTouched() { + return this._touched; + }), _holder); + Object.defineProperty(holder, propertyToListen, { + get: function get() { + return this[privateProperty]; + }, + set: function set(value) { + this._touched = true; + this[privateProperty] = value; + }, + enumerable: true, + configurable: true + }); + return holder; +} +/** + * Check if at specified `key` there is any value for `object`. + * + * @param {object} object Object to search value at specyfic key. + * @param {string} key String key to check. + * @returns {boolean} + */ + +function hasOwnProperty$1(object, key) { + return Object.prototype.hasOwnProperty.call(object, key); +} + +var objectHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + duckSchema: duckSchema, + inherit: inherit, + extend: extend, + deepExtend: deepExtend, + deepClone: deepClone, + clone: clone, + mixin: mixin, + isObjectEqual: isObjectEqual, + isObject: isObject$1, + defineGetter: defineGetter, + objectEach: objectEach, + getProperty: getProperty, + setProperty: setProperty, + deepObjectSize: deepObjectSize, + createObjectPropListener: createObjectPropListener, + hasOwnProperty: hasOwnProperty$1 +}); + +var tester = function tester(testerFunc) { + var result = { + value: false + }; + + result.test = function (ua, vendor) { + result.value = testerFunc(ua, vendor); + }; + + return result; +}; + +var browsers = { + chrome: tester(function (ua, vendor) { + return /Chrome/.test(ua) && /Google/.test(vendor); + }), + edge: tester(function (ua) { + return /Edge/.test(ua); + }), + firefox: tester(function (ua) { + return /Firefox/.test(ua); + }), + ie: tester(function (ua) { + return /Trident/.test(ua); + }), + // eslint-disable-next-line no-restricted-globals + ie9: tester(function () { + return !!document.documentMode; + }), + mobile: tester(function (ua) { + return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(ua); + }), + safari: tester(function (ua, vendor) { + return /Safari/.test(ua) && /Apple Computer/.test(vendor); + }) +}; +var platforms = { + mac: tester(function (platform) { + return /^Mac/.test(platform); + }), + win: tester(function (platform) { + return /^Win/.test(platform); + }), + linux: tester(function (platform) { + return /^Linux/.test(platform); + }) +}; +/** + * @param {object} [metaObject] The browser identity collection. + * @param {object} [metaObject.userAgent] The user agent reported by browser. + * @param {object} [metaObject.vendor] The vendor name reported by browser. + */ + +function setBrowserMeta() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + _ref$userAgent = _ref.userAgent, + userAgent = _ref$userAgent === void 0 ? navigator.userAgent : _ref$userAgent, + _ref$vendor = _ref.vendor, + vendor = _ref$vendor === void 0 ? navigator.vendor : _ref$vendor; + + objectEach(browsers, function (_ref2) { + var test = _ref2.test; + return void test(userAgent, vendor); + }); +} +/** + * @param {object} [metaObject] The platform identity collection. + * @param {object} [metaObject.platform] The platform ID. + */ + +function setPlatformMeta() { + var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + _ref3$platform = _ref3.platform, + platform = _ref3$platform === void 0 ? navigator.platform : _ref3$platform; + + objectEach(platforms, function (_ref4) { + var test = _ref4.test; + return void test(platform); + }); +} +setBrowserMeta(); +setPlatformMeta(); +/** + * @returns {boolean} + */ + +function isChrome() { + return browsers.chrome.value; +} +/** + * @returns {boolean} + */ + +function isEdge() { + return browsers.edge.value; +} +/** + * @returns {boolean} + */ + +function isIE() { + return browsers.ie.value; +} +/** + * @returns {boolean} + */ + +function isIE9() { + return browsers.ie9.value; +} +/** + * @returns {boolean} + */ + +function isMSBrowser() { + return browsers.ie.value || browsers.edge.value; +} +/** + * @returns {boolean} + */ + +function isMobileBrowser() { + return browsers.mobile.value; +} +/** + * @returns {boolean} + */ + +function isSafari() { + return browsers.safari.value; +} +/** + * @returns {boolean} + */ + +function isFirefox() { + return browsers.firefox.value; +} +/** + * @returns {boolean} + */ + +function isWindowsOS() { + return platforms.win.value; +} +/** + * @returns {boolean} + */ + +function isMacOS() { + return platforms.mac.value; +} +/** + * @returns {boolean} + */ + +function isLinuxOS() { + return platforms.linux.value; +} + +var browserHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + setBrowserMeta: setBrowserMeta, + setPlatformMeta: setPlatformMeta, + isChrome: isChrome, + isEdge: isEdge, + isIE: isIE, + isIE9: isIE9, + isMSBrowser: isMSBrowser, + isMobileBrowser: isMobileBrowser, + isSafari: isSafari, + isFirefox: isFirefox, + isWindowsOS: isWindowsOS, + isMacOS: isMacOS, + isLinuxOS: isLinuxOS +}); + +/*! @license DOMPurify | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.2.2/LICENSE */ + +function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + +var hasOwnProperty$2 = Object.hasOwnProperty, + setPrototypeOf = Object.setPrototypeOf, + isFrozen = Object.isFrozen, + getPrototypeOf = Object.getPrototypeOf, + getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor; +var freeze = Object.freeze, + seal = Object.seal, + create = Object.create; // eslint-disable-line import/no-mutable-exports + +var _ref = typeof Reflect !== 'undefined' && Reflect, + apply = _ref.apply, + construct = _ref.construct; + +if (!apply) { + apply = function apply(fun, thisValue, args) { + return fun.apply(thisValue, args); + }; +} + +if (!freeze) { + freeze = function freeze(x) { + return x; + }; +} + +if (!seal) { + seal = function seal(x) { + return x; + }; +} + +if (!construct) { + construct = function construct(Func, args) { + return new (Function.prototype.bind.apply(Func, [null].concat(_toConsumableArray(args))))(); + }; +} + +var arrayForEach$1 = unapply(Array.prototype.forEach); +var arrayPop = unapply(Array.prototype.pop); +var arrayPush$1 = unapply(Array.prototype.push); + +var stringToLowerCase = unapply(String.prototype.toLowerCase); +var stringMatch = unapply(String.prototype.match); +var stringReplace = unapply(String.prototype.replace); +var stringIndexOf = unapply(String.prototype.indexOf); +var stringTrim$1 = unapply(String.prototype.trim); + +var regExpTest = unapply(RegExp.prototype.test); + +var typeErrorCreate = unconstruct(TypeError); + +function unapply(func) { + return function (thisArg) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return apply(func, thisArg, args); + }; +} + +function unconstruct(func) { + return function () { + for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + return construct(func, args); + }; +} + +/* Add properties to a lookup table */ +function addToSet(set, array) { + if (setPrototypeOf) { + // Make 'in' and truthy checks like Boolean(set.constructor) + // independent of any properties defined on Object.prototype. + // Prevent prototype setters from intercepting set as a this value. + setPrototypeOf(set, null); + } + + var l = array.length; + while (l--) { + var element = array[l]; + if (typeof element === 'string') { + var lcElement = stringToLowerCase(element); + if (lcElement !== element) { + // Config presets (e.g. tags.js, attrs.js) are immutable. + if (!isFrozen(array)) { + array[l] = lcElement; + } + + element = lcElement; + } + } + + set[element] = true; + } + + return set; +} + +/* Shallow clone an object */ +function clone$1(object) { + var newObject = create(null); + + var property = void 0; + for (property in object) { + if (apply(hasOwnProperty$2, object, [property])) { + newObject[property] = object[property]; + } + } + + return newObject; +} + +/* IE10 doesn't support __lookupGetter__ so lets' + * simulate it. It also automatically checks + * if the prop is function or getter and behaves + * accordingly. */ +function lookupGetter(object, prop) { + while (object !== null) { + var desc = getOwnPropertyDescriptor$3(object, prop); + if (desc) { + if (desc.get) { + return unapply(desc.get); + } + + if (typeof desc.value === 'function') { + return unapply(desc.value); + } + } + + object = getPrototypeOf(object); + } + + return null; +} + +var html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']); + +// SVG +var svg = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']); + +var svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']); + +// List of SVG elements that are disallowed by default. +// We still need to know them so that we can do namespace +// checks properly in case one wants to add them to +// allow-list. +var svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'fedropshadow', 'feimage', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']); + +var mathMl = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover']); + +// Similarly to SVG, we want to know all MathML elements, +// even those that we disallow by default. +var mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']); + +var text = freeze(['#text']); + +var html$1$1 = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'xmlns']); + +var svg$1 = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'targetx', 'targety', 'transform', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']); + +var mathMl$1 = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']); + +var xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']); + +// eslint-disable-next-line unicorn/better-regex +var MUSTACHE_EXPR = seal(/\{\{[\s\S]*|[\s\S]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode +var ERB_EXPR = seal(/<%[\s\S]*|[\s\S]*%>/gm); +var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/); // eslint-disable-line no-useless-escape +var ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape +var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape +); +var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i); +var ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g // eslint-disable-line no-control-regex +); + +var _typeof$2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +function _toConsumableArray$1(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + +var getGlobal = function getGlobal() { + return typeof window === 'undefined' ? null : window; +}; + +/** + * Creates a no-op policy for internal use only. + * Don't export this function outside this module! + * @param {?TrustedTypePolicyFactory} trustedTypes The policy factory. + * @param {Document} document The document object (to determine policy name suffix) + * @return {?TrustedTypePolicy} The policy created (or null, if Trusted Types + * are not supported). + */ +var _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, document) { + if ((typeof trustedTypes === 'undefined' ? 'undefined' : _typeof$2(trustedTypes)) !== 'object' || typeof trustedTypes.createPolicy !== 'function') { + return null; + } + + // Allow the callers to control the unique policy name + // by adding a data-tt-policy-suffix to the script element with the DOMPurify. + // Policy creation with duplicate names throws in Trusted Types. + var suffix = null; + var ATTR_NAME = 'data-tt-policy-suffix'; + if (document.currentScript && document.currentScript.hasAttribute(ATTR_NAME)) { + suffix = document.currentScript.getAttribute(ATTR_NAME); + } + + var policyName = 'dompurify' + (suffix ? '#' + suffix : ''); + + try { + return trustedTypes.createPolicy(policyName, { + createHTML: function createHTML(html$$1) { + return html$$1; + } + }); + } catch (_) { + // Policy creation failed (most likely another DOMPurify script has + // already run). Skip creating the policy, as this will only cause errors + // if TT are enforced. + console.warn('TrustedTypes policy ' + policyName + ' could not be created.'); + return null; + } +}; + +function createDOMPurify() { + var window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal(); + + var DOMPurify = function DOMPurify(root) { + return createDOMPurify(root); + }; + + /** + * Version label, exposed for easier checks + * if DOMPurify is up to date or not + */ + DOMPurify.version = '2.2.6'; + + /** + * Array of elements that DOMPurify removed during sanitation. + * Empty if nothing was removed. + */ + DOMPurify.removed = []; + + if (!window || !window.document || window.document.nodeType !== 9) { + // Not running in a browser, provide a factory function + // so that you can pass your own Window + DOMPurify.isSupported = false; + + return DOMPurify; + } + + var originalDocument = window.document; + + var document = window.document; + var DocumentFragment = window.DocumentFragment, + HTMLTemplateElement = window.HTMLTemplateElement, + Node = window.Node, + Element = window.Element, + NodeFilter = window.NodeFilter, + _window$NamedNodeMap = window.NamedNodeMap, + NamedNodeMap = _window$NamedNodeMap === undefined ? window.NamedNodeMap || window.MozNamedAttrMap : _window$NamedNodeMap, + Text = window.Text, + Comment = window.Comment, + DOMParser = window.DOMParser, + trustedTypes = window.trustedTypes; + + + var ElementPrototype = Element.prototype; + + var cloneNode = lookupGetter(ElementPrototype, 'cloneNode'); + var getNextSibling = lookupGetter(ElementPrototype, 'nextSibling'); + var getChildNodes = lookupGetter(ElementPrototype, 'childNodes'); + var getParentNode = lookupGetter(ElementPrototype, 'parentNode'); + + // As per issue #47, the web-components registry is inherited by a + // new document created via createHTMLDocument. As per the spec + // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries) + // a new empty registry is used when creating a template contents owner + // document, so we use that as our parent document to ensure nothing + // is inherited. + if (typeof HTMLTemplateElement === 'function') { + var template = document.createElement('template'); + if (template.content && template.content.ownerDocument) { + document = template.content.ownerDocument; + } + } + + var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument); + var emptyHTML = trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML('') : ''; + + var _document = document, + implementation = _document.implementation, + createNodeIterator = _document.createNodeIterator, + getElementsByTagName = _document.getElementsByTagName, + createDocumentFragment = _document.createDocumentFragment; + var importNode = originalDocument.importNode; + + + var documentMode = {}; + try { + documentMode = clone$1(document).documentMode ? document.documentMode : {}; + } catch (_) {} + + var hooks = {}; + + /** + * Expose whether this browser supports running the full DOMPurify. + */ + DOMPurify.isSupported = implementation && typeof implementation.createHTMLDocument !== 'undefined' && documentMode !== 9; + + var MUSTACHE_EXPR$$1 = MUSTACHE_EXPR, + ERB_EXPR$$1 = ERB_EXPR, + DATA_ATTR$$1 = DATA_ATTR, + ARIA_ATTR$$1 = ARIA_ATTR, + IS_SCRIPT_OR_DATA$$1 = IS_SCRIPT_OR_DATA, + ATTR_WHITESPACE$$1 = ATTR_WHITESPACE; + var IS_ALLOWED_URI$$1 = IS_ALLOWED_URI; + + /** + * We consider the elements and attributes below to be safe. Ideally + * don't add any new ones but feel free to remove unwanted ones. + */ + + /* allowed element names */ + + var ALLOWED_TAGS = null; + var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(html$1), _toConsumableArray$1(svg), _toConsumableArray$1(svgFilters), _toConsumableArray$1(mathMl), _toConsumableArray$1(text))); + + /* Allowed attribute names */ + var ALLOWED_ATTR = null; + var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray$1(html$1$1), _toConsumableArray$1(svg$1), _toConsumableArray$1(mathMl$1), _toConsumableArray$1(xml))); + + /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */ + var FORBID_TAGS = null; + + /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */ + var FORBID_ATTR = null; + + /* Decide if ARIA attributes are okay */ + var ALLOW_ARIA_ATTR = true; + + /* Decide if custom data attributes are okay */ + var ALLOW_DATA_ATTR = true; + + /* Decide if unknown protocols are okay */ + var ALLOW_UNKNOWN_PROTOCOLS = false; + + /* Output should be safe for common template engines. + * This means, DOMPurify removes data attributes, mustaches and ERB + */ + var SAFE_FOR_TEMPLATES = false; + + /* Decide if document with ... should be returned */ + var WHOLE_DOCUMENT = false; + + /* Track whether config is already set on this instance of DOMPurify. */ + var SET_CONFIG = false; + + /* Decide if all elements (e.g. style, script) must be children of + * document.body. By default, browsers might move them to document.head */ + var FORCE_BODY = false; + + /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html + * string (or a TrustedHTML object if Trusted Types are supported). + * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead + */ + var RETURN_DOM = false; + + /* Decide if a DOM `DocumentFragment` should be returned, instead of a html + * string (or a TrustedHTML object if Trusted Types are supported) */ + var RETURN_DOM_FRAGMENT = false; + + /* If `RETURN_DOM` or `RETURN_DOM_FRAGMENT` is enabled, decide if the returned DOM + * `Node` is imported into the current `Document`. If this flag is not enabled the + * `Node` will belong (its ownerDocument) to a fresh `HTMLDocument`, created by + * DOMPurify. + * + * This defaults to `true` starting DOMPurify 2.2.0. Note that setting it to `false` + * might cause XSS from attacks hidden in closed shadowroots in case the browser + * supports Declarative Shadow: DOM https://web.dev/declarative-shadow-dom/ + */ + var RETURN_DOM_IMPORT = true; + + /* Try to return a Trusted Type object instead of a string, return a string in + * case Trusted Types are not supported */ + var RETURN_TRUSTED_TYPE = false; + + /* Output should be free from DOM clobbering attacks? */ + var SANITIZE_DOM = true; + + /* Keep element content when removing element? */ + var KEEP_CONTENT = true; + + /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead + * of importing it into a new Document and returning a sanitized copy */ + var IN_PLACE = false; + + /* Allow usage of profiles like html, svg and mathMl */ + var USE_PROFILES = {}; + + /* Tags to ignore content of when KEEP_CONTENT is true */ + var FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']); + + /* Tags that are safe for data: URIs */ + var DATA_URI_TAGS = null; + var DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']); + + /* Attributes safe for values like "javascript:" */ + var URI_SAFE_ATTRIBUTES = null; + var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'summary', 'title', 'value', 'style', 'xmlns']); + + /* Keep a reference to config to pass to hooks */ + var CONFIG = null; + + /* Ideally, do not touch anything below this line */ + /* ______________________________________________ */ + + var formElement = document.createElement('form'); + + /** + * _parseConfig + * + * @param {Object} cfg optional config literal + */ + // eslint-disable-next-line complexity + var _parseConfig = function _parseConfig(cfg) { + if (CONFIG && CONFIG === cfg) { + return; + } + + /* Shield configuration object from tampering */ + if (!cfg || (typeof cfg === 'undefined' ? 'undefined' : _typeof$2(cfg)) !== 'object') { + cfg = {}; + } + + /* Shield configuration object from prototype pollution */ + cfg = clone$1(cfg); + + /* Set configuration parameters */ + ALLOWED_TAGS = 'ALLOWED_TAGS' in cfg ? addToSet({}, cfg.ALLOWED_TAGS) : DEFAULT_ALLOWED_TAGS; + ALLOWED_ATTR = 'ALLOWED_ATTR' in cfg ? addToSet({}, cfg.ALLOWED_ATTR) : DEFAULT_ALLOWED_ATTR; + URI_SAFE_ATTRIBUTES = 'ADD_URI_SAFE_ATTR' in cfg ? addToSet(clone$1(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR) : DEFAULT_URI_SAFE_ATTRIBUTES; + DATA_URI_TAGS = 'ADD_DATA_URI_TAGS' in cfg ? addToSet(clone$1(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS) : DEFAULT_DATA_URI_TAGS; + FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS) : {}; + FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR) : {}; + USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false; + ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true + ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true + ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false + SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false + WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false + RETURN_DOM = cfg.RETURN_DOM || false; // Default false + RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false + RETURN_DOM_IMPORT = cfg.RETURN_DOM_IMPORT !== false; // Default true + RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false + FORCE_BODY = cfg.FORCE_BODY || false; // Default false + SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true + KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true + IN_PLACE = cfg.IN_PLACE || false; // Default false + IS_ALLOWED_URI$$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$$1; + if (SAFE_FOR_TEMPLATES) { + ALLOW_DATA_ATTR = false; + } + + if (RETURN_DOM_FRAGMENT) { + RETURN_DOM = true; + } + + /* Parse profile info */ + if (USE_PROFILES) { + ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(text))); + ALLOWED_ATTR = []; + if (USE_PROFILES.html === true) { + addToSet(ALLOWED_TAGS, html$1); + addToSet(ALLOWED_ATTR, html$1$1); + } + + if (USE_PROFILES.svg === true) { + addToSet(ALLOWED_TAGS, svg); + addToSet(ALLOWED_ATTR, svg$1); + addToSet(ALLOWED_ATTR, xml); + } + + if (USE_PROFILES.svgFilters === true) { + addToSet(ALLOWED_TAGS, svgFilters); + addToSet(ALLOWED_ATTR, svg$1); + addToSet(ALLOWED_ATTR, xml); + } + + if (USE_PROFILES.mathMl === true) { + addToSet(ALLOWED_TAGS, mathMl); + addToSet(ALLOWED_ATTR, mathMl$1); + addToSet(ALLOWED_ATTR, xml); + } + } + + /* Merge configuration parameters */ + if (cfg.ADD_TAGS) { + if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) { + ALLOWED_TAGS = clone$1(ALLOWED_TAGS); + } + + addToSet(ALLOWED_TAGS, cfg.ADD_TAGS); + } + + if (cfg.ADD_ATTR) { + if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) { + ALLOWED_ATTR = clone$1(ALLOWED_ATTR); + } + + addToSet(ALLOWED_ATTR, cfg.ADD_ATTR); + } + + if (cfg.ADD_URI_SAFE_ATTR) { + addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR); + } + + /* Add #text in case KEEP_CONTENT is set to true */ + if (KEEP_CONTENT) { + ALLOWED_TAGS['#text'] = true; + } + + /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */ + if (WHOLE_DOCUMENT) { + addToSet(ALLOWED_TAGS, ['html', 'head', 'body']); + } + + /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */ + if (ALLOWED_TAGS.table) { + addToSet(ALLOWED_TAGS, ['tbody']); + delete FORBID_TAGS.tbody; + } + + // Prevent further manipulation of configuration. + // Not available in IE8, Safari 5, etc. + if (freeze) { + freeze(cfg); + } + + CONFIG = cfg; + }; + + var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']); + + var HTML_INTEGRATION_POINTS = addToSet({}, ['foreignobject', 'desc', 'title', 'annotation-xml']); + + /* Keep track of all possible SVG and MathML tags + * so that we can perform the namespace checks + * correctly. */ + var ALL_SVG_TAGS = addToSet({}, svg); + addToSet(ALL_SVG_TAGS, svgFilters); + addToSet(ALL_SVG_TAGS, svgDisallowed); + + var ALL_MATHML_TAGS = addToSet({}, mathMl); + addToSet(ALL_MATHML_TAGS, mathMlDisallowed); + + var MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML'; + var SVG_NAMESPACE = 'http://www.w3.org/2000/svg'; + var HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml'; + + /** + * + * + * @param {Element} element a DOM element whose namespace is being checked + * @returns {boolean} Return false if the element has a + * namespace that a spec-compliant parser would never + * return. Return true otherwise. + */ + var _checkValidNamespace = function _checkValidNamespace(element) { + var parent = getParentNode(element); + + // In JSDOM, if we're inside shadow DOM, then parentNode + // can be null. We just simulate parent in this case. + if (!parent || !parent.tagName) { + parent = { + namespaceURI: HTML_NAMESPACE, + tagName: 'template' + }; + } + + var tagName = stringToLowerCase(element.tagName); + var parentTagName = stringToLowerCase(parent.tagName); + + if (element.namespaceURI === SVG_NAMESPACE) { + // The only way to switch from HTML namespace to SVG + // is via . If it happens via any other tag, then + // it should be killed. + if (parent.namespaceURI === HTML_NAMESPACE) { + return tagName === 'svg'; + } + + // The only way to switch from MathML to SVG is via + // svg if parent is either or MathML + // text integration points. + if (parent.namespaceURI === MATHML_NAMESPACE) { + return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]); + } + + // We only allow elements that are defined in SVG + // spec. All others are disallowed in SVG namespace. + return Boolean(ALL_SVG_TAGS[tagName]); + } + + if (element.namespaceURI === MATHML_NAMESPACE) { + // The only way to switch from HTML namespace to MathML + // is via . If it happens via any other tag, then + // it should be killed. + if (parent.namespaceURI === HTML_NAMESPACE) { + return tagName === 'math'; + } + + // The only way to switch from SVG to MathML is via + // and HTML integration points + if (parent.namespaceURI === SVG_NAMESPACE) { + return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName]; + } + + // We only allow elements that are defined in MathML + // spec. All others are disallowed in MathML namespace. + return Boolean(ALL_MATHML_TAGS[tagName]); + } + + if (element.namespaceURI === HTML_NAMESPACE) { + // The only way to switch from SVG to HTML is via + // HTML integration points, and from MathML to HTML + // is via MathML text integration points + if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) { + return false; + } + + if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) { + return false; + } + + // Certain elements are allowed in both SVG and HTML + // namespace. We need to specify them explicitly + // so that they don't get erronously deleted from + // HTML namespace. + var commonSvgAndHTMLElements = addToSet({}, ['title', 'style', 'font', 'a', 'script']); + + // We disallow tags that are specific for MathML + // or SVG and should never appear in HTML namespace + return !ALL_MATHML_TAGS[tagName] && (commonSvgAndHTMLElements[tagName] || !ALL_SVG_TAGS[tagName]); + } + + // The code should never reach this place (this means + // that the element somehow got namespace that is not + // HTML, SVG or MathML). Return false just in case. + return false; + }; + + /** + * _forceRemove + * + * @param {Node} node a DOM node + */ + var _forceRemove = function _forceRemove(node) { + arrayPush$1(DOMPurify.removed, { element: node }); + try { + node.parentNode.removeChild(node); + } catch (_) { + try { + node.outerHTML = emptyHTML; + } catch (_) { + node.remove(); + } + } + }; + + /** + * _removeAttribute + * + * @param {String} name an Attribute name + * @param {Node} node a DOM node + */ + var _removeAttribute = function _removeAttribute(name, node) { + try { + arrayPush$1(DOMPurify.removed, { + attribute: node.getAttributeNode(name), + from: node + }); + } catch (_) { + arrayPush$1(DOMPurify.removed, { + attribute: null, + from: node + }); + } + + node.removeAttribute(name); + }; + + /** + * _initDocument + * + * @param {String} dirty a string of dirty markup + * @return {Document} a DOM, filled with the dirty markup + */ + var _initDocument = function _initDocument(dirty) { + /* Create a HTML document */ + var doc = void 0; + var leadingWhitespace = void 0; + + if (FORCE_BODY) { + dirty = '' + dirty; + } else { + /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */ + var matches = stringMatch(dirty, /^[\r\n\t ]+/); + leadingWhitespace = matches && matches[0]; + } + + var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty; + /* Use the DOMParser API by default, fallback later if needs be */ + try { + doc = new DOMParser().parseFromString(dirtyPayload, 'text/html'); + } catch (_) {} + + /* Use createHTMLDocument in case DOMParser is not available */ + if (!doc || !doc.documentElement) { + doc = implementation.createHTMLDocument(''); + var _doc = doc, + body = _doc.body; + + body.parentNode.removeChild(body.parentNode.firstElementChild); + body.outerHTML = dirtyPayload; + } + + if (dirty && leadingWhitespace) { + doc.body.insertBefore(document.createTextNode(leadingWhitespace), doc.body.childNodes[0] || null); + } + + /* Work on whole document or just its body */ + return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0]; + }; + + /** + * _createIterator + * + * @param {Document} root document/fragment to create iterator for + * @return {Iterator} iterator instance + */ + var _createIterator = function _createIterator(root) { + return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, function () { + return NodeFilter.FILTER_ACCEPT; + }, false); + }; + + /** + * _isClobbered + * + * @param {Node} elm element to check for clobbering attacks + * @return {Boolean} true if clobbered, false if safe + */ + var _isClobbered = function _isClobbered(elm) { + if (elm instanceof Text || elm instanceof Comment) { + return false; + } + + if (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function') { + return true; + } + + return false; + }; + + /** + * _isNode + * + * @param {Node} obj object to check whether it's a DOM node + * @return {Boolean} true is object is a DOM node + */ + var _isNode = function _isNode(object) { + return (typeof Node === 'undefined' ? 'undefined' : _typeof$2(Node)) === 'object' ? object instanceof Node : object && (typeof object === 'undefined' ? 'undefined' : _typeof$2(object)) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'; + }; + + /** + * _executeHook + * Execute user configurable hooks + * + * @param {String} entryPoint Name of the hook's entry point + * @param {Node} currentNode node to work on with the hook + * @param {Object} data additional hook parameters + */ + var _executeHook = function _executeHook(entryPoint, currentNode, data) { + if (!hooks[entryPoint]) { + return; + } + + arrayForEach$1(hooks[entryPoint], function (hook) { + hook.call(DOMPurify, currentNode, data, CONFIG); + }); + }; + + /** + * _sanitizeElements + * + * @protect nodeName + * @protect textContent + * @protect removeChild + * + * @param {Node} currentNode to check for permission to exist + * @return {Boolean} true if node was killed, false if left alive + */ + var _sanitizeElements = function _sanitizeElements(currentNode) { + var content = void 0; + + /* Execute a hook if present */ + _executeHook('beforeSanitizeElements', currentNode, null); + + /* Check if element is clobbered or can clobber */ + if (_isClobbered(currentNode)) { + _forceRemove(currentNode); + return true; + } + + /* Check if tagname contains Unicode */ + if (stringMatch(currentNode.nodeName, /[\u0080-\uFFFF]/)) { + _forceRemove(currentNode); + return true; + } + + /* Now let's check the element's type and name */ + var tagName = stringToLowerCase(currentNode.nodeName); + + /* Execute a hook if present */ + _executeHook('uponSanitizeElement', currentNode, { + tagName: tagName, + allowedTags: ALLOWED_TAGS + }); + + /* Detect mXSS attempts abusing namespace confusion */ + if (!_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) { + _forceRemove(currentNode); + return true; + } + + /* Remove element if anything forbids its presence */ + if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) { + /* Keep content except for bad-listed elements */ + if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) { + var parentNode = getParentNode(currentNode); + var childNodes = getChildNodes(currentNode); + var childCount = childNodes.length; + for (var i = childCount - 1; i >= 0; --i) { + parentNode.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode)); + } + } + + _forceRemove(currentNode); + return true; + } + + /* Check whether element has a valid namespace */ + if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) { + _forceRemove(currentNode); + return true; + } + + if ((tagName === 'noscript' || tagName === 'noembed') && regExpTest(/<\/no(script|embed)/i, currentNode.innerHTML)) { + _forceRemove(currentNode); + return true; + } + + /* Sanitize element content to be template-safe */ + if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) { + /* Get the element's text content */ + content = currentNode.textContent; + content = stringReplace(content, MUSTACHE_EXPR$$1, ' '); + content = stringReplace(content, ERB_EXPR$$1, ' '); + if (currentNode.textContent !== content) { + arrayPush$1(DOMPurify.removed, { element: currentNode.cloneNode() }); + currentNode.textContent = content; + } + } + + /* Execute a hook if present */ + _executeHook('afterSanitizeElements', currentNode, null); + + return false; + }; + + /** + * _isValidAttribute + * + * @param {string} lcTag Lowercase tag name of containing element. + * @param {string} lcName Lowercase attribute name. + * @param {string} value Attribute value. + * @return {Boolean} Returns true if `value` is valid, otherwise false. + */ + // eslint-disable-next-line complexity + var _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) { + /* Make sure attribute cannot clobber */ + if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) { + return false; + } + + /* Allow valid data-* attributes: At least one character after "-" + (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes) + XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804) + We don't need to check the value; it's always URI safe. */ + if (ALLOW_DATA_ATTR && regExpTest(DATA_ATTR$$1, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$$1, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) { + return false; + + /* Check value is safe. First, is attr inert? If so, is safe */ + } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$$1, stringReplace(value, ATTR_WHITESPACE$$1, ''))) ; else if (!value) ; else { + return false; + } + + return true; + }; + + /** + * _sanitizeAttributes + * + * @protect attributes + * @protect nodeName + * @protect removeAttribute + * @protect setAttribute + * + * @param {Node} currentNode to sanitize + */ + var _sanitizeAttributes = function _sanitizeAttributes(currentNode) { + var attr = void 0; + var value = void 0; + var lcName = void 0; + var l = void 0; + /* Execute a hook if present */ + _executeHook('beforeSanitizeAttributes', currentNode, null); + + var attributes = currentNode.attributes; + + /* Check if we have attributes; if not we might have a text node */ + + if (!attributes) { + return; + } + + var hookEvent = { + attrName: '', + attrValue: '', + keepAttr: true, + allowedAttributes: ALLOWED_ATTR + }; + l = attributes.length; + + /* Go backwards over all attributes; safely remove bad ones */ + while (l--) { + attr = attributes[l]; + var _attr = attr, + name = _attr.name, + namespaceURI = _attr.namespaceURI; + + value = stringTrim$1(attr.value); + lcName = stringToLowerCase(name); + + /* Execute a hook if present */ + hookEvent.attrName = lcName; + hookEvent.attrValue = value; + hookEvent.keepAttr = true; + hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set + _executeHook('uponSanitizeAttribute', currentNode, hookEvent); + value = hookEvent.attrValue; + /* Did the hooks approve of the attribute? */ + if (hookEvent.forceKeepAttr) { + continue; + } + + /* Remove attribute */ + _removeAttribute(name, currentNode); + + /* Did the hooks approve of the attribute? */ + if (!hookEvent.keepAttr) { + continue; + } + + /* Work around a security issue in jQuery 3.0 */ + if (regExpTest(/\/>/i, value)) { + _removeAttribute(name, currentNode); + continue; + } + + /* Sanitize attribute content to be template-safe */ + if (SAFE_FOR_TEMPLATES) { + value = stringReplace(value, MUSTACHE_EXPR$$1, ' '); + value = stringReplace(value, ERB_EXPR$$1, ' '); + } + + /* Is `value` valid for this attribute? */ + var lcTag = currentNode.nodeName.toLowerCase(); + if (!_isValidAttribute(lcTag, lcName, value)) { + continue; + } + + /* Handle invalid data-* attribute set by try-catching it */ + try { + if (namespaceURI) { + currentNode.setAttributeNS(namespaceURI, name, value); + } else { + /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */ + currentNode.setAttribute(name, value); + } + + arrayPop(DOMPurify.removed); + } catch (_) {} + } + + /* Execute a hook if present */ + _executeHook('afterSanitizeAttributes', currentNode, null); + }; + + /** + * _sanitizeShadowDOM + * + * @param {DocumentFragment} fragment to iterate over recursively + */ + var _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) { + var shadowNode = void 0; + var shadowIterator = _createIterator(fragment); + + /* Execute a hook if present */ + _executeHook('beforeSanitizeShadowDOM', fragment, null); + + while (shadowNode = shadowIterator.nextNode()) { + /* Execute a hook if present */ + _executeHook('uponSanitizeShadowNode', shadowNode, null); + + /* Sanitize tags and elements */ + if (_sanitizeElements(shadowNode)) { + continue; + } + + /* Deep shadow DOM detected */ + if (shadowNode.content instanceof DocumentFragment) { + _sanitizeShadowDOM(shadowNode.content); + } + + /* Check attributes, sanitize if necessary */ + _sanitizeAttributes(shadowNode); + } + + /* Execute a hook if present */ + _executeHook('afterSanitizeShadowDOM', fragment, null); + }; + + /** + * Sanitize + * Public method providing core sanitation functionality + * + * @param {String|Node} dirty string or DOM node + * @param {Object} configuration object + */ + // eslint-disable-next-line complexity + DOMPurify.sanitize = function (dirty, cfg) { + var body = void 0; + var importedNode = void 0; + var currentNode = void 0; + var oldNode = void 0; + var returnNode = void 0; + /* Make sure we have a string to sanitize. + DO NOT return early, as this will return the wrong type if + the user has requested a DOM object rather than a string */ + if (!dirty) { + dirty = ''; + } + + /* Stringify, in case dirty is an object */ + if (typeof dirty !== 'string' && !_isNode(dirty)) { + // eslint-disable-next-line no-negated-condition + if (typeof dirty.toString !== 'function') { + throw typeErrorCreate('toString is not a function'); + } else { + dirty = dirty.toString(); + if (typeof dirty !== 'string') { + throw typeErrorCreate('dirty is not a string, aborting'); + } + } + } + + /* Check we can run. Otherwise fall back or ignore */ + if (!DOMPurify.isSupported) { + if (_typeof$2(window.toStaticHTML) === 'object' || typeof window.toStaticHTML === 'function') { + if (typeof dirty === 'string') { + return window.toStaticHTML(dirty); + } + + if (_isNode(dirty)) { + return window.toStaticHTML(dirty.outerHTML); + } + } + + return dirty; + } + + /* Assign config vars */ + if (!SET_CONFIG) { + _parseConfig(cfg); + } + + /* Clean up removed elements */ + DOMPurify.removed = []; + + /* Check if dirty is correctly typed for IN_PLACE */ + if (typeof dirty === 'string') { + IN_PLACE = false; + } + + if (IN_PLACE) ; else if (dirty instanceof Node) { + /* If dirty is a DOM element, append to an empty document to avoid + elements being stripped by the parser */ + body = _initDocument(''); + importedNode = body.ownerDocument.importNode(dirty, true); + if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') { + /* Node is already a body, use as is */ + body = importedNode; + } else if (importedNode.nodeName === 'HTML') { + body = importedNode; + } else { + // eslint-disable-next-line unicorn/prefer-node-append + body.appendChild(importedNode); + } + } else { + /* Exit directly if we have nothing to do */ + if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && + // eslint-disable-next-line unicorn/prefer-includes + dirty.indexOf('<') === -1) { + return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty; + } + + /* Initialize the document to work on */ + body = _initDocument(dirty); + + /* Check we have a DOM node from the data */ + if (!body) { + return RETURN_DOM ? null : emptyHTML; + } + } + + /* Remove first element node (ours) if FORCE_BODY is set */ + if (body && FORCE_BODY) { + _forceRemove(body.firstChild); + } + + /* Get node iterator */ + var nodeIterator = _createIterator(IN_PLACE ? dirty : body); + + /* Now start iterating over the created document */ + while (currentNode = nodeIterator.nextNode()) { + /* Fix IE's strange behavior with manipulated textNodes #89 */ + if (currentNode.nodeType === 3 && currentNode === oldNode) { + continue; + } + + /* Sanitize tags and elements */ + if (_sanitizeElements(currentNode)) { + continue; + } + + /* Shadow DOM detected, sanitize it */ + if (currentNode.content instanceof DocumentFragment) { + _sanitizeShadowDOM(currentNode.content); + } + + /* Check attributes, sanitize if necessary */ + _sanitizeAttributes(currentNode); + + oldNode = currentNode; + } + + oldNode = null; + + /* If we sanitized `dirty` in-place, return it. */ + if (IN_PLACE) { + return dirty; + } + + /* Return sanitized string or DOM */ + if (RETURN_DOM) { + if (RETURN_DOM_FRAGMENT) { + returnNode = createDocumentFragment.call(body.ownerDocument); + + while (body.firstChild) { + // eslint-disable-next-line unicorn/prefer-node-append + returnNode.appendChild(body.firstChild); + } + } else { + returnNode = body; + } + + if (RETURN_DOM_IMPORT) { + /* + AdoptNode() is not used because internal state is not reset + (e.g. the past names map of a HTMLFormElement), this is safe + in theory but we would rather not risk another attack vector. + The state that is cloned by importNode() is explicitly defined + by the specs. + */ + returnNode = importNode.call(originalDocument, returnNode, true); + } + + return returnNode; + } + + var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML; + + /* Sanitize final string template-safe */ + if (SAFE_FOR_TEMPLATES) { + serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$$1, ' '); + serializedHTML = stringReplace(serializedHTML, ERB_EXPR$$1, ' '); + } + + return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML; + }; + + /** + * Public method to set the configuration once + * setConfig + * + * @param {Object} cfg configuration object + */ + DOMPurify.setConfig = function (cfg) { + _parseConfig(cfg); + SET_CONFIG = true; + }; + + /** + * Public method to remove the configuration + * clearConfig + * + */ + DOMPurify.clearConfig = function () { + CONFIG = null; + SET_CONFIG = false; + }; + + /** + * Public method to check if an attribute value is valid. + * Uses last set config, if any. Otherwise, uses config defaults. + * isValidAttribute + * + * @param {string} tag Tag name of containing element. + * @param {string} attr Attribute name. + * @param {string} value Attribute value. + * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false. + */ + DOMPurify.isValidAttribute = function (tag, attr, value) { + /* Initialize shared config vars if necessary. */ + if (!CONFIG) { + _parseConfig({}); + } + + var lcTag = stringToLowerCase(tag); + var lcName = stringToLowerCase(attr); + return _isValidAttribute(lcTag, lcName, value); + }; + + /** + * AddHook + * Public method to add DOMPurify hooks + * + * @param {String} entryPoint entry point for the hook to add + * @param {Function} hookFunction function to execute + */ + DOMPurify.addHook = function (entryPoint, hookFunction) { + if (typeof hookFunction !== 'function') { + return; + } + + hooks[entryPoint] = hooks[entryPoint] || []; + arrayPush$1(hooks[entryPoint], hookFunction); + }; + + /** + * RemoveHook + * Public method to remove a DOMPurify hook at a given entryPoint + * (pops it from the stack of hooks if more are present) + * + * @param {String} entryPoint entry point for the hook to remove + */ + DOMPurify.removeHook = function (entryPoint) { + if (hooks[entryPoint]) { + arrayPop(hooks[entryPoint]); + } + }; + + /** + * RemoveHooks + * Public method to remove all DOMPurify hooks at a given entryPoint + * + * @param {String} entryPoint entry point for the hooks to remove + */ + DOMPurify.removeHooks = function (entryPoint) { + if (hooks[entryPoint]) { + hooks[entryPoint] = []; + } + }; + + /** + * RemoveAllHooks + * Public method to remove all DOMPurify hooks + * + */ + DOMPurify.removeAllHooks = function () { + hooks = {}; + }; + + return DOMPurify; +} + +var purify = createDOMPurify(); + +var purify_cjs = purify; + +var codeAt = stringMultibyte.codeAt; + +// `String.prototype.codePointAt` method +// https://tc39.es/ecma262/#sec-string.prototype.codepointat +_export({ target: 'String', proto: true }, { + codePointAt: function codePointAt(pos) { + return codeAt(this, pos); + } +}); + +// `String.prototype.repeat` method implementation +// https://tc39.es/ecma262/#sec-string.prototype.repeat +var stringRepeat = ''.repeat || function repeat(count) { + var str = String(requireObjectCoercible(this)); + var result = ''; + var n = toInteger(count); + if (n < 0 || n == Infinity) throw RangeError('Wrong number of repetitions'); + for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str; + return result; +}; + +// https://github.com/tc39/proposal-string-pad-start-end + + + + +var ceil$1 = Math.ceil; + +// `String.prototype.{ padStart, padEnd }` methods implementation +var createMethod$4 = function (IS_END) { + return function ($this, maxLength, fillString) { + var S = String(requireObjectCoercible($this)); + var stringLength = S.length; + var fillStr = fillString === undefined ? ' ' : String(fillString); + var intMaxLength = toLength(maxLength); + var fillLen, stringFiller; + if (intMaxLength <= stringLength || fillStr == '') return S; + fillLen = intMaxLength - stringLength; + stringFiller = stringRepeat.call(fillStr, ceil$1(fillLen / fillStr.length)); + if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen); + return IS_END ? S + stringFiller : stringFiller + S; + }; +}; + +var stringPad = { + // `String.prototype.padStart` method + // https://tc39.es/ecma262/#sec-string.prototype.padstart + start: createMethod$4(false), + // `String.prototype.padEnd` method + // https://tc39.es/ecma262/#sec-string.prototype.padend + end: createMethod$4(true) +}; + +// https://github.com/zloirock/core-js/issues/280 + + +// eslint-disable-next-line unicorn/no-unsafe-regex -- safe +var stringPadWebkitBug = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(engineUserAgent); + +var $padStart = stringPad.start; + + +// `String.prototype.padStart` method +// https://tc39.es/ecma262/#sec-string.prototype.padstart +_export({ target: 'String', proto: true, forced: stringPadWebkitBug }, { + padStart: function padStart(maxLength /* , fillString = ' ' */) { + return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +var moment = createCommonjsModule(function (module, exports) { +(function (global, factory) { + module.exports = factory() ; +}(commonjsGlobal, (function () { + var hookCallback; + + function hooks () { + return hookCallback.apply(null, arguments); + } + + // This is done to register the method called with moment() + // without creating circular dependencies. + function setHookCallback (callback) { + hookCallback = callback; + } + + function isArray(input) { + return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]'; + } + + function isObject(input) { + // IE8 will treat undefined and null as object if it wasn't for + // input != null + return input != null && Object.prototype.toString.call(input) === '[object Object]'; + } + + function isObjectEmpty(obj) { + if (Object.getOwnPropertyNames) { + return (Object.getOwnPropertyNames(obj).length === 0); + } else { + var k; + for (k in obj) { + if (obj.hasOwnProperty(k)) { + return false; + } + } + return true; + } + } + + function isUndefined(input) { + return input === void 0; + } + + function isNumber(input) { + return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]'; + } + + function isDate(input) { + return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]'; + } + + function map(arr, fn) { + var res = [], i; + for (i = 0; i < arr.length; ++i) { + res.push(fn(arr[i], i)); + } + return res; + } + + function hasOwnProp(a, b) { + return Object.prototype.hasOwnProperty.call(a, b); + } + + function extend(a, b) { + for (var i in b) { + if (hasOwnProp(b, i)) { + a[i] = b[i]; + } + } + + if (hasOwnProp(b, 'toString')) { + a.toString = b.toString; + } + + if (hasOwnProp(b, 'valueOf')) { + a.valueOf = b.valueOf; + } + + return a; + } + + function createUTC (input, format, locale, strict) { + return createLocalOrUTC(input, format, locale, strict, true).utc(); + } + + function defaultParsingFlags() { + // We need to deep clone this object. + return { + empty : false, + unusedTokens : [], + unusedInput : [], + overflow : -2, + charsLeftOver : 0, + nullInput : false, + invalidMonth : null, + invalidFormat : false, + userInvalidated : false, + iso : false, + parsedDateParts : [], + meridiem : null, + rfc2822 : false, + weekdayMismatch : false + }; + } + + function getParsingFlags(m) { + if (m._pf == null) { + m._pf = defaultParsingFlags(); + } + return m._pf; + } + + var some; + if (Array.prototype.some) { + some = Array.prototype.some; + } else { + some = function (fun) { + var t = Object(this); + var len = t.length >>> 0; + + for (var i = 0; i < len; i++) { + if (i in t && fun.call(this, t[i], i, t)) { + return true; + } + } + + return false; + }; + } + + function isValid(m) { + if (m._isValid == null) { + var flags = getParsingFlags(m); + var parsedParts = some.call(flags.parsedDateParts, function (i) { + return i != null; + }); + var isNowValid = !isNaN(m._d.getTime()) && + flags.overflow < 0 && + !flags.empty && + !flags.invalidMonth && + !flags.invalidWeekday && + !flags.weekdayMismatch && + !flags.nullInput && + !flags.invalidFormat && + !flags.userInvalidated && + (!flags.meridiem || (flags.meridiem && parsedParts)); + + if (m._strict) { + isNowValid = isNowValid && + flags.charsLeftOver === 0 && + flags.unusedTokens.length === 0 && + flags.bigHour === undefined; + } + + if (Object.isFrozen == null || !Object.isFrozen(m)) { + m._isValid = isNowValid; + } + else { + return isNowValid; + } + } + return m._isValid; + } + + function createInvalid (flags) { + var m = createUTC(NaN); + if (flags != null) { + extend(getParsingFlags(m), flags); + } + else { + getParsingFlags(m).userInvalidated = true; + } + + return m; + } + + // Plugins that add properties should also add the key here (null value), + // so we can properly clone ourselves. + var momentProperties = hooks.momentProperties = []; + + function copyConfig(to, from) { + var i, prop, val; + + if (!isUndefined(from._isAMomentObject)) { + to._isAMomentObject = from._isAMomentObject; + } + if (!isUndefined(from._i)) { + to._i = from._i; + } + if (!isUndefined(from._f)) { + to._f = from._f; + } + if (!isUndefined(from._l)) { + to._l = from._l; + } + if (!isUndefined(from._strict)) { + to._strict = from._strict; + } + if (!isUndefined(from._tzm)) { + to._tzm = from._tzm; + } + if (!isUndefined(from._isUTC)) { + to._isUTC = from._isUTC; + } + if (!isUndefined(from._offset)) { + to._offset = from._offset; + } + if (!isUndefined(from._pf)) { + to._pf = getParsingFlags(from); + } + if (!isUndefined(from._locale)) { + to._locale = from._locale; + } + + if (momentProperties.length > 0) { + for (i = 0; i < momentProperties.length; i++) { + prop = momentProperties[i]; + val = from[prop]; + if (!isUndefined(val)) { + to[prop] = val; + } + } + } + + return to; + } + + var updateInProgress = false; + + // Moment prototype object + function Moment(config) { + copyConfig(this, config); + this._d = new Date(config._d != null ? config._d.getTime() : NaN); + if (!this.isValid()) { + this._d = new Date(NaN); + } + // Prevent infinite loop in case updateOffset creates new moment + // objects. + if (updateInProgress === false) { + updateInProgress = true; + hooks.updateOffset(this); + updateInProgress = false; + } + } + + function isMoment (obj) { + return obj instanceof Moment || (obj != null && obj._isAMomentObject != null); + } + + function absFloor (number) { + if (number < 0) { + // -0 -> 0 + return Math.ceil(number) || 0; + } else { + return Math.floor(number); + } + } + + function toInt(argumentForCoercion) { + var coercedNumber = +argumentForCoercion, + value = 0; + + if (coercedNumber !== 0 && isFinite(coercedNumber)) { + value = absFloor(coercedNumber); + } + + return value; + } + + // compare two arrays, return the number of differences + function compareArrays(array1, array2, dontConvert) { + var len = Math.min(array1.length, array2.length), + lengthDiff = Math.abs(array1.length - array2.length), + diffs = 0, + i; + for (i = 0; i < len; i++) { + if ((dontConvert && array1[i] !== array2[i]) || + (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) { + diffs++; + } + } + return diffs + lengthDiff; + } + + function warn(msg) { + if (hooks.suppressDeprecationWarnings === false && + (typeof console !== 'undefined') && console.warn) { + console.warn('Deprecation warning: ' + msg); + } + } + + function deprecate(msg, fn) { + var firstTime = true; + + return extend(function () { + if (hooks.deprecationHandler != null) { + hooks.deprecationHandler(null, msg); + } + if (firstTime) { + var args = []; + var arg; + for (var i = 0; i < arguments.length; i++) { + arg = ''; + if (typeof arguments[i] === 'object') { + arg += '\n[' + i + '] '; + for (var key in arguments[0]) { + arg += key + ': ' + arguments[0][key] + ', '; + } + arg = arg.slice(0, -2); // Remove trailing comma and space + } else { + arg = arguments[i]; + } + args.push(arg); + } + warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack); + firstTime = false; + } + return fn.apply(this, arguments); + }, fn); + } + + var deprecations = {}; + + function deprecateSimple(name, msg) { + if (hooks.deprecationHandler != null) { + hooks.deprecationHandler(name, msg); + } + if (!deprecations[name]) { + warn(msg); + deprecations[name] = true; + } + } + + hooks.suppressDeprecationWarnings = false; + hooks.deprecationHandler = null; + + function isFunction(input) { + return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]'; + } + + function set (config) { + var prop, i; + for (i in config) { + prop = config[i]; + if (isFunction(prop)) { + this[i] = prop; + } else { + this['_' + i] = prop; + } + } + this._config = config; + // Lenient ordinal parsing accepts just a number in addition to + // number + (possibly) stuff coming from _dayOfMonthOrdinalParse. + // TODO: Remove "ordinalParse" fallback in next major release. + this._dayOfMonthOrdinalParseLenient = new RegExp( + (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + + '|' + (/\d{1,2}/).source); + } + + function mergeConfigs(parentConfig, childConfig) { + var res = extend({}, parentConfig), prop; + for (prop in childConfig) { + if (hasOwnProp(childConfig, prop)) { + if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) { + res[prop] = {}; + extend(res[prop], parentConfig[prop]); + extend(res[prop], childConfig[prop]); + } else if (childConfig[prop] != null) { + res[prop] = childConfig[prop]; + } else { + delete res[prop]; + } + } + } + for (prop in parentConfig) { + if (hasOwnProp(parentConfig, prop) && + !hasOwnProp(childConfig, prop) && + isObject(parentConfig[prop])) { + // make sure changes to properties don't modify parent config + res[prop] = extend({}, res[prop]); + } + } + return res; + } + + function Locale(config) { + if (config != null) { + this.set(config); + } + } + + var keys; + + if (Object.keys) { + keys = Object.keys; + } else { + keys = function (obj) { + var i, res = []; + for (i in obj) { + if (hasOwnProp(obj, i)) { + res.push(i); + } + } + return res; + }; + } + + var defaultCalendar = { + sameDay : '[Today at] LT', + nextDay : '[Tomorrow at] LT', + nextWeek : 'dddd [at] LT', + lastDay : '[Yesterday at] LT', + lastWeek : '[Last] dddd [at] LT', + sameElse : 'L' + }; + + function calendar (key, mom, now) { + var output = this._calendar[key] || this._calendar['sameElse']; + return isFunction(output) ? output.call(mom, now) : output; + } + + var defaultLongDateFormat = { + LTS : 'h:mm:ss A', + LT : 'h:mm A', + L : 'MM/DD/YYYY', + LL : 'MMMM D, YYYY', + LLL : 'MMMM D, YYYY h:mm A', + LLLL : 'dddd, MMMM D, YYYY h:mm A' + }; + + function longDateFormat (key) { + var format = this._longDateFormat[key], + formatUpper = this._longDateFormat[key.toUpperCase()]; + + if (format || !formatUpper) { + return format; + } + + this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) { + return val.slice(1); + }); + + return this._longDateFormat[key]; + } + + var defaultInvalidDate = 'Invalid date'; + + function invalidDate () { + return this._invalidDate; + } + + var defaultOrdinal = '%d'; + var defaultDayOfMonthOrdinalParse = /\d{1,2}/; + + function ordinal (number) { + return this._ordinal.replace('%d', number); + } + + var defaultRelativeTime = { + future : 'in %s', + past : '%s ago', + s : 'a few seconds', + ss : '%d seconds', + m : 'a minute', + mm : '%d minutes', + h : 'an hour', + hh : '%d hours', + d : 'a day', + dd : '%d days', + M : 'a month', + MM : '%d months', + y : 'a year', + yy : '%d years' + }; + + function relativeTime (number, withoutSuffix, string, isFuture) { + var output = this._relativeTime[string]; + return (isFunction(output)) ? + output(number, withoutSuffix, string, isFuture) : + output.replace(/%d/i, number); + } + + function pastFuture (diff, output) { + var format = this._relativeTime[diff > 0 ? 'future' : 'past']; + return isFunction(format) ? format(output) : format.replace(/%s/i, output); + } + + var aliases = {}; + + function addUnitAlias (unit, shorthand) { + var lowerCase = unit.toLowerCase(); + aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit; + } + + function normalizeUnits(units) { + return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined; + } + + function normalizeObjectUnits(inputObject) { + var normalizedInput = {}, + normalizedProp, + prop; + + for (prop in inputObject) { + if (hasOwnProp(inputObject, prop)) { + normalizedProp = normalizeUnits(prop); + if (normalizedProp) { + normalizedInput[normalizedProp] = inputObject[prop]; + } + } + } + + return normalizedInput; + } + + var priorities = {}; + + function addUnitPriority(unit, priority) { + priorities[unit] = priority; + } + + function getPrioritizedUnits(unitsObj) { + var units = []; + for (var u in unitsObj) { + units.push({unit: u, priority: priorities[u]}); + } + units.sort(function (a, b) { + return a.priority - b.priority; + }); + return units; + } + + function zeroFill(number, targetLength, forceSign) { + var absNumber = '' + Math.abs(number), + zerosToFill = targetLength - absNumber.length, + sign = number >= 0; + return (sign ? (forceSign ? '+' : '') : '-') + + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber; + } + + var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g; + + var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g; + + var formatFunctions = {}; + + var formatTokenFunctions = {}; + + // token: 'M' + // padded: ['MM', 2] + // ordinal: 'Mo' + // callback: function () { this.month() + 1 } + function addFormatToken (token, padded, ordinal, callback) { + var func = callback; + if (typeof callback === 'string') { + func = function () { + return this[callback](); + }; + } + if (token) { + formatTokenFunctions[token] = func; + } + if (padded) { + formatTokenFunctions[padded[0]] = function () { + return zeroFill(func.apply(this, arguments), padded[1], padded[2]); + }; + } + if (ordinal) { + formatTokenFunctions[ordinal] = function () { + return this.localeData().ordinal(func.apply(this, arguments), token); + }; + } + } + + function removeFormattingTokens(input) { + if (input.match(/\[[\s\S]/)) { + return input.replace(/^\[|\]$/g, ''); + } + return input.replace(/\\/g, ''); + } + + function makeFormatFunction(format) { + var array = format.match(formattingTokens), i, length; + + for (i = 0, length = array.length; i < length; i++) { + if (formatTokenFunctions[array[i]]) { + array[i] = formatTokenFunctions[array[i]]; + } else { + array[i] = removeFormattingTokens(array[i]); + } + } + + return function (mom) { + var output = '', i; + for (i = 0; i < length; i++) { + output += isFunction(array[i]) ? array[i].call(mom, format) : array[i]; + } + return output; + }; + } + + // format date using native date object + function formatMoment(m, format) { + if (!m.isValid()) { + return m.localeData().invalidDate(); + } + + format = expandFormat(format, m.localeData()); + formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format); + + return formatFunctions[format](m); + } + + function expandFormat(format, locale) { + var i = 5; + + function replaceLongDateFormatTokens(input) { + return locale.longDateFormat(input) || input; + } + + localFormattingTokens.lastIndex = 0; + while (i >= 0 && localFormattingTokens.test(format)) { + format = format.replace(localFormattingTokens, replaceLongDateFormatTokens); + localFormattingTokens.lastIndex = 0; + i -= 1; + } + + return format; + } + + var match1 = /\d/; // 0 - 9 + var match2 = /\d\d/; // 00 - 99 + var match3 = /\d{3}/; // 000 - 999 + var match4 = /\d{4}/; // 0000 - 9999 + var match6 = /[+-]?\d{6}/; // -999999 - 999999 + var match1to2 = /\d\d?/; // 0 - 99 + var match3to4 = /\d\d\d\d?/; // 999 - 9999 + var match5to6 = /\d\d\d\d\d\d?/; // 99999 - 999999 + var match1to3 = /\d{1,3}/; // 0 - 999 + var match1to4 = /\d{1,4}/; // 0 - 9999 + var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999 + + var matchUnsigned = /\d+/; // 0 - inf + var matchSigned = /[+-]?\d+/; // -inf - inf + + var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z + var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z + + var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123 + + // any word (or two) characters or numbers including two/three word month in arabic. + // includes scottish gaelic two word and hyphenated months + var matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i; + + var regexes = {}; + + function addRegexToken (token, regex, strictRegex) { + regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) { + return (isStrict && strictRegex) ? strictRegex : regex; + }; + } + + function getParseRegexForToken (token, config) { + if (!hasOwnProp(regexes, token)) { + return new RegExp(unescapeFormat(token)); + } + + return regexes[token](config._strict, config._locale); + } + + // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript + function unescapeFormat(s) { + return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) { + return p1 || p2 || p3 || p4; + })); + } + + function regexEscape(s) { + return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); + } + + var tokens = {}; + + function addParseToken (token, callback) { + var i, func = callback; + if (typeof token === 'string') { + token = [token]; + } + if (isNumber(callback)) { + func = function (input, array) { + array[callback] = toInt(input); + }; + } + for (i = 0; i < token.length; i++) { + tokens[token[i]] = func; + } + } + + function addWeekParseToken (token, callback) { + addParseToken(token, function (input, array, config, token) { + config._w = config._w || {}; + callback(input, config._w, config, token); + }); + } + + function addTimeToArrayFromToken(token, input, config) { + if (input != null && hasOwnProp(tokens, token)) { + tokens[token](input, config._a, config, token); + } + } + + var YEAR = 0; + var MONTH = 1; + var DATE = 2; + var HOUR = 3; + var MINUTE = 4; + var SECOND = 5; + var MILLISECOND = 6; + var WEEK = 7; + var WEEKDAY = 8; + + // FORMATTING + + addFormatToken('Y', 0, 0, function () { + var y = this.year(); + return y <= 9999 ? '' + y : '+' + y; + }); + + addFormatToken(0, ['YY', 2], 0, function () { + return this.year() % 100; + }); + + addFormatToken(0, ['YYYY', 4], 0, 'year'); + addFormatToken(0, ['YYYYY', 5], 0, 'year'); + addFormatToken(0, ['YYYYYY', 6, true], 0, 'year'); + + // ALIASES + + addUnitAlias('year', 'y'); + + // PRIORITIES + + addUnitPriority('year', 1); + + // PARSING + + addRegexToken('Y', matchSigned); + addRegexToken('YY', match1to2, match2); + addRegexToken('YYYY', match1to4, match4); + addRegexToken('YYYYY', match1to6, match6); + addRegexToken('YYYYYY', match1to6, match6); + + addParseToken(['YYYYY', 'YYYYYY'], YEAR); + addParseToken('YYYY', function (input, array) { + array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input); + }); + addParseToken('YY', function (input, array) { + array[YEAR] = hooks.parseTwoDigitYear(input); + }); + addParseToken('Y', function (input, array) { + array[YEAR] = parseInt(input, 10); + }); + + // HELPERS + + function daysInYear(year) { + return isLeapYear(year) ? 366 : 365; + } + + function isLeapYear(year) { + return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0; + } + + // HOOKS + + hooks.parseTwoDigitYear = function (input) { + return toInt(input) + (toInt(input) > 68 ? 1900 : 2000); + }; + + // MOMENTS + + var getSetYear = makeGetSet('FullYear', true); + + function getIsLeapYear () { + return isLeapYear(this.year()); + } + + function makeGetSet (unit, keepTime) { + return function (value) { + if (value != null) { + set$1(this, unit, value); + hooks.updateOffset(this, keepTime); + return this; + } else { + return get(this, unit); + } + }; + } + + function get (mom, unit) { + return mom.isValid() ? + mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN; + } + + function set$1 (mom, unit, value) { + if (mom.isValid() && !isNaN(value)) { + if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) { + mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month())); + } + else { + mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value); + } + } + } + + // MOMENTS + + function stringGet (units) { + units = normalizeUnits(units); + if (isFunction(this[units])) { + return this[units](); + } + return this; + } + + + function stringSet (units, value) { + if (typeof units === 'object') { + units = normalizeObjectUnits(units); + var prioritized = getPrioritizedUnits(units); + for (var i = 0; i < prioritized.length; i++) { + this[prioritized[i].unit](units[prioritized[i].unit]); + } + } else { + units = normalizeUnits(units); + if (isFunction(this[units])) { + return this[units](value); + } + } + return this; + } + + function mod(n, x) { + return ((n % x) + x) % x; + } + + var indexOf; + + if (Array.prototype.indexOf) { + indexOf = Array.prototype.indexOf; + } else { + indexOf = function (o) { + // I know + var i; + for (i = 0; i < this.length; ++i) { + if (this[i] === o) { + return i; + } + } + return -1; + }; + } + + function daysInMonth(year, month) { + if (isNaN(year) || isNaN(month)) { + return NaN; + } + var modMonth = mod(month, 12); + year += (month - modMonth) / 12; + return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2); + } + + // FORMATTING + + addFormatToken('M', ['MM', 2], 'Mo', function () { + return this.month() + 1; + }); + + addFormatToken('MMM', 0, 0, function (format) { + return this.localeData().monthsShort(this, format); + }); + + addFormatToken('MMMM', 0, 0, function (format) { + return this.localeData().months(this, format); + }); + + // ALIASES + + addUnitAlias('month', 'M'); + + // PRIORITY + + addUnitPriority('month', 8); + + // PARSING + + addRegexToken('M', match1to2); + addRegexToken('MM', match1to2, match2); + addRegexToken('MMM', function (isStrict, locale) { + return locale.monthsShortRegex(isStrict); + }); + addRegexToken('MMMM', function (isStrict, locale) { + return locale.monthsRegex(isStrict); + }); + + addParseToken(['M', 'MM'], function (input, array) { + array[MONTH] = toInt(input) - 1; + }); + + addParseToken(['MMM', 'MMMM'], function (input, array, config, token) { + var month = config._locale.monthsParse(input, token, config._strict); + // if we didn't find a month name, mark the date as invalid. + if (month != null) { + array[MONTH] = month; + } else { + getParsingFlags(config).invalidMonth = input; + } + }); + + // LOCALES + + var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/; + var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'); + function localeMonths (m, format) { + if (!m) { + return isArray(this._months) ? this._months : + this._months['standalone']; + } + return isArray(this._months) ? this._months[m.month()] : + this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()]; + } + + var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'); + function localeMonthsShort (m, format) { + if (!m) { + return isArray(this._monthsShort) ? this._monthsShort : + this._monthsShort['standalone']; + } + return isArray(this._monthsShort) ? this._monthsShort[m.month()] : + this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()]; + } + + function handleStrictParse(monthName, format, strict) { + var i, ii, mom, llc = monthName.toLocaleLowerCase(); + if (!this._monthsParse) { + // this is not used + this._monthsParse = []; + this._longMonthsParse = []; + this._shortMonthsParse = []; + for (i = 0; i < 12; ++i) { + mom = createUTC([2000, i]); + this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase(); + this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase(); + } + } + + if (strict) { + if (format === 'MMM') { + ii = indexOf.call(this._shortMonthsParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._longMonthsParse, llc); + return ii !== -1 ? ii : null; + } + } else { + if (format === 'MMM') { + ii = indexOf.call(this._shortMonthsParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._longMonthsParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._longMonthsParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._shortMonthsParse, llc); + return ii !== -1 ? ii : null; + } + } + } + + function localeMonthsParse (monthName, format, strict) { + var i, mom, regex; + + if (this._monthsParseExact) { + return handleStrictParse.call(this, monthName, format, strict); + } + + if (!this._monthsParse) { + this._monthsParse = []; + this._longMonthsParse = []; + this._shortMonthsParse = []; + } + + // TODO: add sorting + // Sorting makes sure if one month (or abbr) is a prefix of another + // see sorting in computeMonthsParse + for (i = 0; i < 12; i++) { + // make the regex if we don't have it already + mom = createUTC([2000, i]); + if (strict && !this._longMonthsParse[i]) { + this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i'); + this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i'); + } + if (!strict && !this._monthsParse[i]) { + regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, ''); + this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i'); + } + // test the regex + if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) { + return i; + } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) { + return i; + } else if (!strict && this._monthsParse[i].test(monthName)) { + return i; + } + } + } + + // MOMENTS + + function setMonth (mom, value) { + var dayOfMonth; + + if (!mom.isValid()) { + // No op + return mom; + } + + if (typeof value === 'string') { + if (/^\d+$/.test(value)) { + value = toInt(value); + } else { + value = mom.localeData().monthsParse(value); + // TODO: Another silent failure? + if (!isNumber(value)) { + return mom; + } + } + } + + dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value)); + mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth); + return mom; + } + + function getSetMonth (value) { + if (value != null) { + setMonth(this, value); + hooks.updateOffset(this, true); + return this; + } else { + return get(this, 'Month'); + } + } + + function getDaysInMonth () { + return daysInMonth(this.year(), this.month()); + } + + var defaultMonthsShortRegex = matchWord; + function monthsShortRegex (isStrict) { + if (this._monthsParseExact) { + if (!hasOwnProp(this, '_monthsRegex')) { + computeMonthsParse.call(this); + } + if (isStrict) { + return this._monthsShortStrictRegex; + } else { + return this._monthsShortRegex; + } + } else { + if (!hasOwnProp(this, '_monthsShortRegex')) { + this._monthsShortRegex = defaultMonthsShortRegex; + } + return this._monthsShortStrictRegex && isStrict ? + this._monthsShortStrictRegex : this._monthsShortRegex; + } + } + + var defaultMonthsRegex = matchWord; + function monthsRegex (isStrict) { + if (this._monthsParseExact) { + if (!hasOwnProp(this, '_monthsRegex')) { + computeMonthsParse.call(this); + } + if (isStrict) { + return this._monthsStrictRegex; + } else { + return this._monthsRegex; + } + } else { + if (!hasOwnProp(this, '_monthsRegex')) { + this._monthsRegex = defaultMonthsRegex; + } + return this._monthsStrictRegex && isStrict ? + this._monthsStrictRegex : this._monthsRegex; + } + } + + function computeMonthsParse () { + function cmpLenRev(a, b) { + return b.length - a.length; + } + + var shortPieces = [], longPieces = [], mixedPieces = [], + i, mom; + for (i = 0; i < 12; i++) { + // make the regex if we don't have it already + mom = createUTC([2000, i]); + shortPieces.push(this.monthsShort(mom, '')); + longPieces.push(this.months(mom, '')); + mixedPieces.push(this.months(mom, '')); + mixedPieces.push(this.monthsShort(mom, '')); + } + // Sorting makes sure if one month (or abbr) is a prefix of another it + // will match the longer piece. + shortPieces.sort(cmpLenRev); + longPieces.sort(cmpLenRev); + mixedPieces.sort(cmpLenRev); + for (i = 0; i < 12; i++) { + shortPieces[i] = regexEscape(shortPieces[i]); + longPieces[i] = regexEscape(longPieces[i]); + } + for (i = 0; i < 24; i++) { + mixedPieces[i] = regexEscape(mixedPieces[i]); + } + + this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); + this._monthsShortRegex = this._monthsRegex; + this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i'); + this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i'); + } + + function createDate (y, m, d, h, M, s, ms) { + // can't just apply() to create a date: + // https://stackoverflow.com/q/181348 + var date; + // the date constructor remaps years 0-99 to 1900-1999 + if (y < 100 && y >= 0) { + // preserve leap years using a full 400 year cycle, then reset + date = new Date(y + 400, m, d, h, M, s, ms); + if (isFinite(date.getFullYear())) { + date.setFullYear(y); + } + } else { + date = new Date(y, m, d, h, M, s, ms); + } + + return date; + } + + function createUTCDate (y) { + var date; + // the Date.UTC function remaps years 0-99 to 1900-1999 + if (y < 100 && y >= 0) { + var args = Array.prototype.slice.call(arguments); + // preserve leap years using a full 400 year cycle, then reset + args[0] = y + 400; + date = new Date(Date.UTC.apply(null, args)); + if (isFinite(date.getUTCFullYear())) { + date.setUTCFullYear(y); + } + } else { + date = new Date(Date.UTC.apply(null, arguments)); + } + + return date; + } + + // start-of-first-week - start-of-year + function firstWeekOffset(year, dow, doy) { + var // first-week day -- which january is always in the first week (4 for iso, 1 for other) + fwd = 7 + dow - doy, + // first-week day local weekday -- which local weekday is fwd + fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7; + + return -fwdlw + fwd - 1; + } + + // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday + function dayOfYearFromWeeks(year, week, weekday, dow, doy) { + var localWeekday = (7 + weekday - dow) % 7, + weekOffset = firstWeekOffset(year, dow, doy), + dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, + resYear, resDayOfYear; + + if (dayOfYear <= 0) { + resYear = year - 1; + resDayOfYear = daysInYear(resYear) + dayOfYear; + } else if (dayOfYear > daysInYear(year)) { + resYear = year + 1; + resDayOfYear = dayOfYear - daysInYear(year); + } else { + resYear = year; + resDayOfYear = dayOfYear; + } + + return { + year: resYear, + dayOfYear: resDayOfYear + }; + } + + function weekOfYear(mom, dow, doy) { + var weekOffset = firstWeekOffset(mom.year(), dow, doy), + week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, + resWeek, resYear; + + if (week < 1) { + resYear = mom.year() - 1; + resWeek = week + weeksInYear(resYear, dow, doy); + } else if (week > weeksInYear(mom.year(), dow, doy)) { + resWeek = week - weeksInYear(mom.year(), dow, doy); + resYear = mom.year() + 1; + } else { + resYear = mom.year(); + resWeek = week; + } + + return { + week: resWeek, + year: resYear + }; + } + + function weeksInYear(year, dow, doy) { + var weekOffset = firstWeekOffset(year, dow, doy), + weekOffsetNext = firstWeekOffset(year + 1, dow, doy); + return (daysInYear(year) - weekOffset + weekOffsetNext) / 7; + } + + // FORMATTING + + addFormatToken('w', ['ww', 2], 'wo', 'week'); + addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek'); + + // ALIASES + + addUnitAlias('week', 'w'); + addUnitAlias('isoWeek', 'W'); + + // PRIORITIES + + addUnitPriority('week', 5); + addUnitPriority('isoWeek', 5); + + // PARSING + + addRegexToken('w', match1to2); + addRegexToken('ww', match1to2, match2); + addRegexToken('W', match1to2); + addRegexToken('WW', match1to2, match2); + + addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) { + week[token.substr(0, 1)] = toInt(input); + }); + + // HELPERS + + // LOCALES + + function localeWeek (mom) { + return weekOfYear(mom, this._week.dow, this._week.doy).week; + } + + var defaultLocaleWeek = { + dow : 0, // Sunday is the first day of the week. + doy : 6 // The week that contains Jan 6th is the first week of the year. + }; + + function localeFirstDayOfWeek () { + return this._week.dow; + } + + function localeFirstDayOfYear () { + return this._week.doy; + } + + // MOMENTS + + function getSetWeek (input) { + var week = this.localeData().week(this); + return input == null ? week : this.add((input - week) * 7, 'd'); + } + + function getSetISOWeek (input) { + var week = weekOfYear(this, 1, 4).week; + return input == null ? week : this.add((input - week) * 7, 'd'); + } + + // FORMATTING + + addFormatToken('d', 0, 'do', 'day'); + + addFormatToken('dd', 0, 0, function (format) { + return this.localeData().weekdaysMin(this, format); + }); + + addFormatToken('ddd', 0, 0, function (format) { + return this.localeData().weekdaysShort(this, format); + }); + + addFormatToken('dddd', 0, 0, function (format) { + return this.localeData().weekdays(this, format); + }); + + addFormatToken('e', 0, 0, 'weekday'); + addFormatToken('E', 0, 0, 'isoWeekday'); + + // ALIASES + + addUnitAlias('day', 'd'); + addUnitAlias('weekday', 'e'); + addUnitAlias('isoWeekday', 'E'); + + // PRIORITY + addUnitPriority('day', 11); + addUnitPriority('weekday', 11); + addUnitPriority('isoWeekday', 11); + + // PARSING + + addRegexToken('d', match1to2); + addRegexToken('e', match1to2); + addRegexToken('E', match1to2); + addRegexToken('dd', function (isStrict, locale) { + return locale.weekdaysMinRegex(isStrict); + }); + addRegexToken('ddd', function (isStrict, locale) { + return locale.weekdaysShortRegex(isStrict); + }); + addRegexToken('dddd', function (isStrict, locale) { + return locale.weekdaysRegex(isStrict); + }); + + addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) { + var weekday = config._locale.weekdaysParse(input, token, config._strict); + // if we didn't get a weekday name, mark the date as invalid + if (weekday != null) { + week.d = weekday; + } else { + getParsingFlags(config).invalidWeekday = input; + } + }); + + addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) { + week[token] = toInt(input); + }); + + // HELPERS + + function parseWeekday(input, locale) { + if (typeof input !== 'string') { + return input; + } + + if (!isNaN(input)) { + return parseInt(input, 10); + } + + input = locale.weekdaysParse(input); + if (typeof input === 'number') { + return input; + } + + return null; + } + + function parseIsoWeekday(input, locale) { + if (typeof input === 'string') { + return locale.weekdaysParse(input) % 7 || 7; + } + return isNaN(input) ? null : input; + } + + // LOCALES + function shiftWeekdays (ws, n) { + return ws.slice(n, 7).concat(ws.slice(0, n)); + } + + var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'); + function localeWeekdays (m, format) { + var weekdays = isArray(this._weekdays) ? this._weekdays : + this._weekdays[(m && m !== true && this._weekdays.isFormat.test(format)) ? 'format' : 'standalone']; + return (m === true) ? shiftWeekdays(weekdays, this._week.dow) + : (m) ? weekdays[m.day()] : weekdays; + } + + var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'); + function localeWeekdaysShort (m) { + return (m === true) ? shiftWeekdays(this._weekdaysShort, this._week.dow) + : (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort; + } + + var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'); + function localeWeekdaysMin (m) { + return (m === true) ? shiftWeekdays(this._weekdaysMin, this._week.dow) + : (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin; + } + + function handleStrictParse$1(weekdayName, format, strict) { + var i, ii, mom, llc = weekdayName.toLocaleLowerCase(); + if (!this._weekdaysParse) { + this._weekdaysParse = []; + this._shortWeekdaysParse = []; + this._minWeekdaysParse = []; + + for (i = 0; i < 7; ++i) { + mom = createUTC([2000, 1]).day(i); + this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase(); + this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase(); + this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase(); + } + } + + if (strict) { + if (format === 'dddd') { + ii = indexOf.call(this._weekdaysParse, llc); + return ii !== -1 ? ii : null; + } else if (format === 'ddd') { + ii = indexOf.call(this._shortWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._minWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } + } else { + if (format === 'dddd') { + ii = indexOf.call(this._weekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._shortWeekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._minWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } else if (format === 'ddd') { + ii = indexOf.call(this._shortWeekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._weekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._minWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._minWeekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._weekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._shortWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } + } + } + + function localeWeekdaysParse (weekdayName, format, strict) { + var i, mom, regex; + + if (this._weekdaysParseExact) { + return handleStrictParse$1.call(this, weekdayName, format, strict); + } + + if (!this._weekdaysParse) { + this._weekdaysParse = []; + this._minWeekdaysParse = []; + this._shortWeekdaysParse = []; + this._fullWeekdaysParse = []; + } + + for (i = 0; i < 7; i++) { + // make the regex if we don't have it already + + mom = createUTC([2000, 1]).day(i); + if (strict && !this._fullWeekdaysParse[i]) { + this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i'); + this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i'); + this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i'); + } + if (!this._weekdaysParse[i]) { + regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, ''); + this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i'); + } + // test the regex + if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) { + return i; + } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) { + return i; + } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) { + return i; + } else if (!strict && this._weekdaysParse[i].test(weekdayName)) { + return i; + } + } + } + + // MOMENTS + + function getSetDayOfWeek (input) { + if (!this.isValid()) { + return input != null ? this : NaN; + } + var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay(); + if (input != null) { + input = parseWeekday(input, this.localeData()); + return this.add(input - day, 'd'); + } else { + return day; + } + } + + function getSetLocaleDayOfWeek (input) { + if (!this.isValid()) { + return input != null ? this : NaN; + } + var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7; + return input == null ? weekday : this.add(input - weekday, 'd'); + } + + function getSetISODayOfWeek (input) { + if (!this.isValid()) { + return input != null ? this : NaN; + } + + // behaves the same as moment#day except + // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6) + // as a setter, sunday should belong to the previous week. + + if (input != null) { + var weekday = parseIsoWeekday(input, this.localeData()); + return this.day(this.day() % 7 ? weekday : weekday - 7); + } else { + return this.day() || 7; + } + } + + var defaultWeekdaysRegex = matchWord; + function weekdaysRegex (isStrict) { + if (this._weekdaysParseExact) { + if (!hasOwnProp(this, '_weekdaysRegex')) { + computeWeekdaysParse.call(this); + } + if (isStrict) { + return this._weekdaysStrictRegex; + } else { + return this._weekdaysRegex; + } + } else { + if (!hasOwnProp(this, '_weekdaysRegex')) { + this._weekdaysRegex = defaultWeekdaysRegex; + } + return this._weekdaysStrictRegex && isStrict ? + this._weekdaysStrictRegex : this._weekdaysRegex; + } + } + + var defaultWeekdaysShortRegex = matchWord; + function weekdaysShortRegex (isStrict) { + if (this._weekdaysParseExact) { + if (!hasOwnProp(this, '_weekdaysRegex')) { + computeWeekdaysParse.call(this); + } + if (isStrict) { + return this._weekdaysShortStrictRegex; + } else { + return this._weekdaysShortRegex; + } + } else { + if (!hasOwnProp(this, '_weekdaysShortRegex')) { + this._weekdaysShortRegex = defaultWeekdaysShortRegex; + } + return this._weekdaysShortStrictRegex && isStrict ? + this._weekdaysShortStrictRegex : this._weekdaysShortRegex; + } + } + + var defaultWeekdaysMinRegex = matchWord; + function weekdaysMinRegex (isStrict) { + if (this._weekdaysParseExact) { + if (!hasOwnProp(this, '_weekdaysRegex')) { + computeWeekdaysParse.call(this); + } + if (isStrict) { + return this._weekdaysMinStrictRegex; + } else { + return this._weekdaysMinRegex; + } + } else { + if (!hasOwnProp(this, '_weekdaysMinRegex')) { + this._weekdaysMinRegex = defaultWeekdaysMinRegex; + } + return this._weekdaysMinStrictRegex && isStrict ? + this._weekdaysMinStrictRegex : this._weekdaysMinRegex; + } + } + + + function computeWeekdaysParse () { + function cmpLenRev(a, b) { + return b.length - a.length; + } + + var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], + i, mom, minp, shortp, longp; + for (i = 0; i < 7; i++) { + // make the regex if we don't have it already + mom = createUTC([2000, 1]).day(i); + minp = this.weekdaysMin(mom, ''); + shortp = this.weekdaysShort(mom, ''); + longp = this.weekdays(mom, ''); + minPieces.push(minp); + shortPieces.push(shortp); + longPieces.push(longp); + mixedPieces.push(minp); + mixedPieces.push(shortp); + mixedPieces.push(longp); + } + // Sorting makes sure if one weekday (or abbr) is a prefix of another it + // will match the longer piece. + minPieces.sort(cmpLenRev); + shortPieces.sort(cmpLenRev); + longPieces.sort(cmpLenRev); + mixedPieces.sort(cmpLenRev); + for (i = 0; i < 7; i++) { + shortPieces[i] = regexEscape(shortPieces[i]); + longPieces[i] = regexEscape(longPieces[i]); + mixedPieces[i] = regexEscape(mixedPieces[i]); + } + + this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i'); + this._weekdaysShortRegex = this._weekdaysRegex; + this._weekdaysMinRegex = this._weekdaysRegex; + + this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i'); + this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i'); + this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i'); + } + + // FORMATTING + + function hFormat() { + return this.hours() % 12 || 12; + } + + function kFormat() { + return this.hours() || 24; + } + + addFormatToken('H', ['HH', 2], 0, 'hour'); + addFormatToken('h', ['hh', 2], 0, hFormat); + addFormatToken('k', ['kk', 2], 0, kFormat); + + addFormatToken('hmm', 0, 0, function () { + return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2); + }); + + addFormatToken('hmmss', 0, 0, function () { + return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) + + zeroFill(this.seconds(), 2); + }); + + addFormatToken('Hmm', 0, 0, function () { + return '' + this.hours() + zeroFill(this.minutes(), 2); + }); + + addFormatToken('Hmmss', 0, 0, function () { + return '' + this.hours() + zeroFill(this.minutes(), 2) + + zeroFill(this.seconds(), 2); + }); + + function meridiem (token, lowercase) { + addFormatToken(token, 0, 0, function () { + return this.localeData().meridiem(this.hours(), this.minutes(), lowercase); + }); + } + + meridiem('a', true); + meridiem('A', false); + + // ALIASES + + addUnitAlias('hour', 'h'); + + // PRIORITY + addUnitPriority('hour', 13); + + // PARSING + + function matchMeridiem (isStrict, locale) { + return locale._meridiemParse; + } + + addRegexToken('a', matchMeridiem); + addRegexToken('A', matchMeridiem); + addRegexToken('H', match1to2); + addRegexToken('h', match1to2); + addRegexToken('k', match1to2); + addRegexToken('HH', match1to2, match2); + addRegexToken('hh', match1to2, match2); + addRegexToken('kk', match1to2, match2); + + addRegexToken('hmm', match3to4); + addRegexToken('hmmss', match5to6); + addRegexToken('Hmm', match3to4); + addRegexToken('Hmmss', match5to6); + + addParseToken(['H', 'HH'], HOUR); + addParseToken(['k', 'kk'], function (input, array, config) { + var kInput = toInt(input); + array[HOUR] = kInput === 24 ? 0 : kInput; + }); + addParseToken(['a', 'A'], function (input, array, config) { + config._isPm = config._locale.isPM(input); + config._meridiem = input; + }); + addParseToken(['h', 'hh'], function (input, array, config) { + array[HOUR] = toInt(input); + getParsingFlags(config).bigHour = true; + }); + addParseToken('hmm', function (input, array, config) { + var pos = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos)); + array[MINUTE] = toInt(input.substr(pos)); + getParsingFlags(config).bigHour = true; + }); + addParseToken('hmmss', function (input, array, config) { + var pos1 = input.length - 4; + var pos2 = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos1)); + array[MINUTE] = toInt(input.substr(pos1, 2)); + array[SECOND] = toInt(input.substr(pos2)); + getParsingFlags(config).bigHour = true; + }); + addParseToken('Hmm', function (input, array, config) { + var pos = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos)); + array[MINUTE] = toInt(input.substr(pos)); + }); + addParseToken('Hmmss', function (input, array, config) { + var pos1 = input.length - 4; + var pos2 = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos1)); + array[MINUTE] = toInt(input.substr(pos1, 2)); + array[SECOND] = toInt(input.substr(pos2)); + }); + + // LOCALES + + function localeIsPM (input) { + // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays + // Using charAt should be more compatible. + return ((input + '').toLowerCase().charAt(0) === 'p'); + } + + var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i; + function localeMeridiem (hours, minutes, isLower) { + if (hours > 11) { + return isLower ? 'pm' : 'PM'; + } else { + return isLower ? 'am' : 'AM'; + } + } + + + // MOMENTS + + // Setting the hour should keep the time, because the user explicitly + // specified which hour they want. So trying to maintain the same hour (in + // a new timezone) makes sense. Adding/subtracting hours does not follow + // this rule. + var getSetHour = makeGetSet('Hours', true); + + var baseConfig = { + calendar: defaultCalendar, + longDateFormat: defaultLongDateFormat, + invalidDate: defaultInvalidDate, + ordinal: defaultOrdinal, + dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse, + relativeTime: defaultRelativeTime, + + months: defaultLocaleMonths, + monthsShort: defaultLocaleMonthsShort, + + week: defaultLocaleWeek, + + weekdays: defaultLocaleWeekdays, + weekdaysMin: defaultLocaleWeekdaysMin, + weekdaysShort: defaultLocaleWeekdaysShort, + + meridiemParse: defaultLocaleMeridiemParse + }; + + // internal storage for locale config files + var locales = {}; + var localeFamilies = {}; + var globalLocale; + + function normalizeLocale(key) { + return key ? key.toLowerCase().replace('_', '-') : key; + } + + // pick the locale from the array + // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each + // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root + function chooseLocale(names) { + var i = 0, j, next, locale, split; + + while (i < names.length) { + split = normalizeLocale(names[i]).split('-'); + j = split.length; + next = normalizeLocale(names[i + 1]); + next = next ? next.split('-') : null; + while (j > 0) { + locale = loadLocale(split.slice(0, j).join('-')); + if (locale) { + return locale; + } + if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) { + //the next array item is better than a shallower substring of this one + break; + } + j--; + } + i++; + } + return globalLocale; + } + + function loadLocale(name) { + var oldLocale = null; + // TODO: Find a better way to register and load all the locales in Node + if (!locales[name] && ('object' !== 'undefined') && + module && module.exports) { + try { + oldLocale = globalLocale._abbr; + var aliasedRequire = commonjsRequire; + aliasedRequire('./locale/' + name); + getSetGlobalLocale(oldLocale); + } catch (e) {} + } + return locales[name]; + } + + // This function will load locale and then set the global locale. If + // no arguments are passed in, it will simply return the current global + // locale key. + function getSetGlobalLocale (key, values) { + var data; + if (key) { + if (isUndefined(values)) { + data = getLocale(key); + } + else { + data = defineLocale(key, values); + } + + if (data) { + // moment.duration._locale = moment._locale = data; + globalLocale = data; + } + else { + if ((typeof console !== 'undefined') && console.warn) { + //warn user if arguments are passed but the locale could not be set + console.warn('Locale ' + key + ' not found. Did you forget to load it?'); + } + } + } + + return globalLocale._abbr; + } + + function defineLocale (name, config) { + if (config !== null) { + var locale, parentConfig = baseConfig; + config.abbr = name; + if (locales[name] != null) { + deprecateSimple('defineLocaleOverride', + 'use moment.updateLocale(localeName, config) to change ' + + 'an existing locale. moment.defineLocale(localeName, ' + + 'config) should only be used for creating a new locale ' + + 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.'); + parentConfig = locales[name]._config; + } else if (config.parentLocale != null) { + if (locales[config.parentLocale] != null) { + parentConfig = locales[config.parentLocale]._config; + } else { + locale = loadLocale(config.parentLocale); + if (locale != null) { + parentConfig = locale._config; + } else { + if (!localeFamilies[config.parentLocale]) { + localeFamilies[config.parentLocale] = []; + } + localeFamilies[config.parentLocale].push({ + name: name, + config: config + }); + return null; + } + } + } + locales[name] = new Locale(mergeConfigs(parentConfig, config)); + + if (localeFamilies[name]) { + localeFamilies[name].forEach(function (x) { + defineLocale(x.name, x.config); + }); + } + + // backwards compat for now: also set the locale + // make sure we set the locale AFTER all child locales have been + // created, so we won't end up with the child locale set. + getSetGlobalLocale(name); + + + return locales[name]; + } else { + // useful for testing + delete locales[name]; + return null; + } + } + + function updateLocale(name, config) { + if (config != null) { + var locale, tmpLocale, parentConfig = baseConfig; + // MERGE + tmpLocale = loadLocale(name); + if (tmpLocale != null) { + parentConfig = tmpLocale._config; + } + config = mergeConfigs(parentConfig, config); + locale = new Locale(config); + locale.parentLocale = locales[name]; + locales[name] = locale; + + // backwards compat for now: also set the locale + getSetGlobalLocale(name); + } else { + // pass null for config to unupdate, useful for tests + if (locales[name] != null) { + if (locales[name].parentLocale != null) { + locales[name] = locales[name].parentLocale; + } else if (locales[name] != null) { + delete locales[name]; + } + } + } + return locales[name]; + } + + // returns locale data + function getLocale (key) { + var locale; + + if (key && key._locale && key._locale._abbr) { + key = key._locale._abbr; + } + + if (!key) { + return globalLocale; + } + + if (!isArray(key)) { + //short-circuit everything else + locale = loadLocale(key); + if (locale) { + return locale; + } + key = [key]; + } + + return chooseLocale(key); + } + + function listLocales() { + return keys(locales); + } + + function checkOverflow (m) { + var overflow; + var a = m._a; + + if (a && getParsingFlags(m).overflow === -2) { + overflow = + a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : + a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : + a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR : + a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : + a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : + a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : + -1; + + if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) { + overflow = DATE; + } + if (getParsingFlags(m)._overflowWeeks && overflow === -1) { + overflow = WEEK; + } + if (getParsingFlags(m)._overflowWeekday && overflow === -1) { + overflow = WEEKDAY; + } + + getParsingFlags(m).overflow = overflow; + } + + return m; + } + + // Pick the first defined of two or three arguments. + function defaults(a, b, c) { + if (a != null) { + return a; + } + if (b != null) { + return b; + } + return c; + } + + function currentDateArray(config) { + // hooks is actually the exported moment object + var nowValue = new Date(hooks.now()); + if (config._useUTC) { + return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()]; + } + return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()]; + } + + // convert an array to a date. + // the array should mirror the parameters below + // note: all values past the year are optional and will default to the lowest possible value. + // [year, month, day , hour, minute, second, millisecond] + function configFromArray (config) { + var i, date, input = [], currentDate, expectedWeekday, yearToUse; + + if (config._d) { + return; + } + + currentDate = currentDateArray(config); + + //compute day of the year from weeks and weekdays + if (config._w && config._a[DATE] == null && config._a[MONTH] == null) { + dayOfYearFromWeekInfo(config); + } + + //if the day of the year is set, figure out what it is + if (config._dayOfYear != null) { + yearToUse = defaults(config._a[YEAR], currentDate[YEAR]); + + if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) { + getParsingFlags(config)._overflowDayOfYear = true; + } + + date = createUTCDate(yearToUse, 0, config._dayOfYear); + config._a[MONTH] = date.getUTCMonth(); + config._a[DATE] = date.getUTCDate(); + } + + // Default to current date. + // * if no year, month, day of month are given, default to today + // * if day of month is given, default month and year + // * if month is given, default only year + // * if year is given, don't default anything + for (i = 0; i < 3 && config._a[i] == null; ++i) { + config._a[i] = input[i] = currentDate[i]; + } + + // Zero out whatever was not defaulted, including time + for (; i < 7; i++) { + config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i]; + } + + // Check for 24:00:00.000 + if (config._a[HOUR] === 24 && + config._a[MINUTE] === 0 && + config._a[SECOND] === 0 && + config._a[MILLISECOND] === 0) { + config._nextDay = true; + config._a[HOUR] = 0; + } + + config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input); + expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay(); + + // Apply timezone offset from input. The actual utcOffset can be changed + // with parseZone. + if (config._tzm != null) { + config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); + } + + if (config._nextDay) { + config._a[HOUR] = 24; + } + + // check for mismatching day of week + if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) { + getParsingFlags(config).weekdayMismatch = true; + } + } + + function dayOfYearFromWeekInfo(config) { + var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow; + + w = config._w; + if (w.GG != null || w.W != null || w.E != null) { + dow = 1; + doy = 4; + + // TODO: We need to take the current isoWeekYear, but that depends on + // how we interpret now (local, utc, fixed offset). So create + // a now version of current config (take local/utc/offset flags, and + // create now). + weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year); + week = defaults(w.W, 1); + weekday = defaults(w.E, 1); + if (weekday < 1 || weekday > 7) { + weekdayOverflow = true; + } + } else { + dow = config._locale._week.dow; + doy = config._locale._week.doy; + + var curWeek = weekOfYear(createLocal(), dow, doy); + + weekYear = defaults(w.gg, config._a[YEAR], curWeek.year); + + // Default to current week. + week = defaults(w.w, curWeek.week); + + if (w.d != null) { + // weekday -- low day numbers are considered next week + weekday = w.d; + if (weekday < 0 || weekday > 6) { + weekdayOverflow = true; + } + } else if (w.e != null) { + // local weekday -- counting starts from beginning of week + weekday = w.e + dow; + if (w.e < 0 || w.e > 6) { + weekdayOverflow = true; + } + } else { + // default to beginning of week + weekday = dow; + } + } + if (week < 1 || week > weeksInYear(weekYear, dow, doy)) { + getParsingFlags(config)._overflowWeeks = true; + } else if (weekdayOverflow != null) { + getParsingFlags(config)._overflowWeekday = true; + } else { + temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy); + config._a[YEAR] = temp.year; + config._dayOfYear = temp.dayOfYear; + } + } + + // iso 8601 regex + // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00) + var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/; + var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/; + + var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/; + + var isoDates = [ + ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/], + ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/], + ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/], + ['GGGG-[W]WW', /\d{4}-W\d\d/, false], + ['YYYY-DDD', /\d{4}-\d{3}/], + ['YYYY-MM', /\d{4}-\d\d/, false], + ['YYYYYYMMDD', /[+-]\d{10}/], + ['YYYYMMDD', /\d{8}/], + // YYYYMM is NOT allowed by the standard + ['GGGG[W]WWE', /\d{4}W\d{3}/], + ['GGGG[W]WW', /\d{4}W\d{2}/, false], + ['YYYYDDD', /\d{7}/] + ]; + + // iso time formats and regexes + var isoTimes = [ + ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/], + ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/], + ['HH:mm:ss', /\d\d:\d\d:\d\d/], + ['HH:mm', /\d\d:\d\d/], + ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/], + ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/], + ['HHmmss', /\d\d\d\d\d\d/], + ['HHmm', /\d\d\d\d/], + ['HH', /\d\d/] + ]; + + var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i; + + // date from iso format + function configFromISO(config) { + var i, l, + string = config._i, + match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), + allowTime, dateFormat, timeFormat, tzFormat; + + if (match) { + getParsingFlags(config).iso = true; + + for (i = 0, l = isoDates.length; i < l; i++) { + if (isoDates[i][1].exec(match[1])) { + dateFormat = isoDates[i][0]; + allowTime = isoDates[i][2] !== false; + break; + } + } + if (dateFormat == null) { + config._isValid = false; + return; + } + if (match[3]) { + for (i = 0, l = isoTimes.length; i < l; i++) { + if (isoTimes[i][1].exec(match[3])) { + // match[2] should be 'T' or space + timeFormat = (match[2] || ' ') + isoTimes[i][0]; + break; + } + } + if (timeFormat == null) { + config._isValid = false; + return; + } + } + if (!allowTime && timeFormat != null) { + config._isValid = false; + return; + } + if (match[4]) { + if (tzRegex.exec(match[4])) { + tzFormat = 'Z'; + } else { + config._isValid = false; + return; + } + } + config._f = dateFormat + (timeFormat || '') + (tzFormat || ''); + configFromStringAndFormat(config); + } else { + config._isValid = false; + } + } + + // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3 + var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/; + + function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) { + var result = [ + untruncateYear(yearStr), + defaultLocaleMonthsShort.indexOf(monthStr), + parseInt(dayStr, 10), + parseInt(hourStr, 10), + parseInt(minuteStr, 10) + ]; + + if (secondStr) { + result.push(parseInt(secondStr, 10)); + } + + return result; + } + + function untruncateYear(yearStr) { + var year = parseInt(yearStr, 10); + if (year <= 49) { + return 2000 + year; + } else if (year <= 999) { + return 1900 + year; + } + return year; + } + + function preprocessRFC2822(s) { + // Remove comments and folding whitespace and replace multiple-spaces with a single space + return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').replace(/^\s\s*/, '').replace(/\s\s*$/, ''); + } + + function checkWeekday(weekdayStr, parsedInput, config) { + if (weekdayStr) { + // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check. + var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), + weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay(); + if (weekdayProvided !== weekdayActual) { + getParsingFlags(config).weekdayMismatch = true; + config._isValid = false; + return false; + } + } + return true; + } + + var obsOffsets = { + UT: 0, + GMT: 0, + EDT: -4 * 60, + EST: -5 * 60, + CDT: -5 * 60, + CST: -6 * 60, + MDT: -6 * 60, + MST: -7 * 60, + PDT: -7 * 60, + PST: -8 * 60 + }; + + function calculateOffset(obsOffset, militaryOffset, numOffset) { + if (obsOffset) { + return obsOffsets[obsOffset]; + } else if (militaryOffset) { + // the only allowed military tz is Z + return 0; + } else { + var hm = parseInt(numOffset, 10); + var m = hm % 100, h = (hm - m) / 100; + return h * 60 + m; + } + } + + // date and time from ref 2822 format + function configFromRFC2822(config) { + var match = rfc2822.exec(preprocessRFC2822(config._i)); + if (match) { + var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]); + if (!checkWeekday(match[1], parsedArray, config)) { + return; + } + + config._a = parsedArray; + config._tzm = calculateOffset(match[8], match[9], match[10]); + + config._d = createUTCDate.apply(null, config._a); + config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); + + getParsingFlags(config).rfc2822 = true; + } else { + config._isValid = false; + } + } + + // date from iso format or fallback + function configFromString(config) { + var matched = aspNetJsonRegex.exec(config._i); + + if (matched !== null) { + config._d = new Date(+matched[1]); + return; + } + + configFromISO(config); + if (config._isValid === false) { + delete config._isValid; + } else { + return; + } + + configFromRFC2822(config); + if (config._isValid === false) { + delete config._isValid; + } else { + return; + } + + // Final attempt, use Input Fallback + hooks.createFromInputFallback(config); + } + + hooks.createFromInputFallback = deprecate( + 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' + + 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' + + 'discouraged and will be removed in an upcoming major release. Please refer to ' + + 'http://momentjs.com/guides/#/warnings/js-date/ for more info.', + function (config) { + config._d = new Date(config._i + (config._useUTC ? ' UTC' : '')); + } + ); + + // constant that refers to the ISO standard + hooks.ISO_8601 = function () {}; + + // constant that refers to the RFC 2822 form + hooks.RFC_2822 = function () {}; + + // date from string and format string + function configFromStringAndFormat(config) { + // TODO: Move this to another part of the creation flow to prevent circular deps + if (config._f === hooks.ISO_8601) { + configFromISO(config); + return; + } + if (config._f === hooks.RFC_2822) { + configFromRFC2822(config); + return; + } + config._a = []; + getParsingFlags(config).empty = true; + + // This array is used to make a Date, either with `new Date` or `Date.UTC` + var string = '' + config._i, + i, parsedInput, tokens, token, skipped, + stringLength = string.length, + totalParsedInputLength = 0; + + tokens = expandFormat(config._f, config._locale).match(formattingTokens) || []; + + for (i = 0; i < tokens.length; i++) { + token = tokens[i]; + parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0]; + // console.log('token', token, 'parsedInput', parsedInput, + // 'regex', getParseRegexForToken(token, config)); + if (parsedInput) { + skipped = string.substr(0, string.indexOf(parsedInput)); + if (skipped.length > 0) { + getParsingFlags(config).unusedInput.push(skipped); + } + string = string.slice(string.indexOf(parsedInput) + parsedInput.length); + totalParsedInputLength += parsedInput.length; + } + // don't parse if it's not a known token + if (formatTokenFunctions[token]) { + if (parsedInput) { + getParsingFlags(config).empty = false; + } + else { + getParsingFlags(config).unusedTokens.push(token); + } + addTimeToArrayFromToken(token, parsedInput, config); + } + else if (config._strict && !parsedInput) { + getParsingFlags(config).unusedTokens.push(token); + } + } + + // add remaining unparsed input length to the string + getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength; + if (string.length > 0) { + getParsingFlags(config).unusedInput.push(string); + } + + // clear _12h flag if hour is <= 12 + if (config._a[HOUR] <= 12 && + getParsingFlags(config).bigHour === true && + config._a[HOUR] > 0) { + getParsingFlags(config).bigHour = undefined; + } + + getParsingFlags(config).parsedDateParts = config._a.slice(0); + getParsingFlags(config).meridiem = config._meridiem; + // handle meridiem + config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem); + + configFromArray(config); + checkOverflow(config); + } + + + function meridiemFixWrap (locale, hour, meridiem) { + var isPm; + + if (meridiem == null) { + // nothing to do + return hour; + } + if (locale.meridiemHour != null) { + return locale.meridiemHour(hour, meridiem); + } else if (locale.isPM != null) { + // Fallback + isPm = locale.isPM(meridiem); + if (isPm && hour < 12) { + hour += 12; + } + if (!isPm && hour === 12) { + hour = 0; + } + return hour; + } else { + // this is not supposed to happen + return hour; + } + } + + // date from string and array of format strings + function configFromStringAndArray(config) { + var tempConfig, + bestMoment, + + scoreToBeat, + i, + currentScore; + + if (config._f.length === 0) { + getParsingFlags(config).invalidFormat = true; + config._d = new Date(NaN); + return; + } + + for (i = 0; i < config._f.length; i++) { + currentScore = 0; + tempConfig = copyConfig({}, config); + if (config._useUTC != null) { + tempConfig._useUTC = config._useUTC; + } + tempConfig._f = config._f[i]; + configFromStringAndFormat(tempConfig); + + if (!isValid(tempConfig)) { + continue; + } + + // if there is any input that was not parsed add a penalty for that format + currentScore += getParsingFlags(tempConfig).charsLeftOver; + + //or tokens + currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10; + + getParsingFlags(tempConfig).score = currentScore; + + if (scoreToBeat == null || currentScore < scoreToBeat) { + scoreToBeat = currentScore; + bestMoment = tempConfig; + } + } + + extend(config, bestMoment || tempConfig); + } + + function configFromObject(config) { + if (config._d) { + return; + } + + var i = normalizeObjectUnits(config._i); + config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) { + return obj && parseInt(obj, 10); + }); + + configFromArray(config); + } + + function createFromConfig (config) { + var res = new Moment(checkOverflow(prepareConfig(config))); + if (res._nextDay) { + // Adding is smart enough around DST + res.add(1, 'd'); + res._nextDay = undefined; + } + + return res; + } + + function prepareConfig (config) { + var input = config._i, + format = config._f; + + config._locale = config._locale || getLocale(config._l); + + if (input === null || (format === undefined && input === '')) { + return createInvalid({nullInput: true}); + } + + if (typeof input === 'string') { + config._i = input = config._locale.preparse(input); + } + + if (isMoment(input)) { + return new Moment(checkOverflow(input)); + } else if (isDate(input)) { + config._d = input; + } else if (isArray(format)) { + configFromStringAndArray(config); + } else if (format) { + configFromStringAndFormat(config); + } else { + configFromInput(config); + } + + if (!isValid(config)) { + config._d = null; + } + + return config; + } + + function configFromInput(config) { + var input = config._i; + if (isUndefined(input)) { + config._d = new Date(hooks.now()); + } else if (isDate(input)) { + config._d = new Date(input.valueOf()); + } else if (typeof input === 'string') { + configFromString(config); + } else if (isArray(input)) { + config._a = map(input.slice(0), function (obj) { + return parseInt(obj, 10); + }); + configFromArray(config); + } else if (isObject(input)) { + configFromObject(config); + } else if (isNumber(input)) { + // from milliseconds + config._d = new Date(input); + } else { + hooks.createFromInputFallback(config); + } + } + + function createLocalOrUTC (input, format, locale, strict, isUTC) { + var c = {}; + + if (locale === true || locale === false) { + strict = locale; + locale = undefined; + } + + if ((isObject(input) && isObjectEmpty(input)) || + (isArray(input) && input.length === 0)) { + input = undefined; + } + // object construction must be done this way. + // https://github.com/moment/moment/issues/1423 + c._isAMomentObject = true; + c._useUTC = c._isUTC = isUTC; + c._l = locale; + c._i = input; + c._f = format; + c._strict = strict; + + return createFromConfig(c); + } + + function createLocal (input, format, locale, strict) { + return createLocalOrUTC(input, format, locale, strict, false); + } + + var prototypeMin = deprecate( + 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/', + function () { + var other = createLocal.apply(null, arguments); + if (this.isValid() && other.isValid()) { + return other < this ? this : other; + } else { + return createInvalid(); + } + } + ); + + var prototypeMax = deprecate( + 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/', + function () { + var other = createLocal.apply(null, arguments); + if (this.isValid() && other.isValid()) { + return other > this ? this : other; + } else { + return createInvalid(); + } + } + ); + + // Pick a moment m from moments so that m[fn](other) is true for all + // other. This relies on the function fn to be transitive. + // + // moments should either be an array of moment objects or an array, whose + // first element is an array of moment objects. + function pickBy(fn, moments) { + var res, i; + if (moments.length === 1 && isArray(moments[0])) { + moments = moments[0]; + } + if (!moments.length) { + return createLocal(); + } + res = moments[0]; + for (i = 1; i < moments.length; ++i) { + if (!moments[i].isValid() || moments[i][fn](res)) { + res = moments[i]; + } + } + return res; + } + + // TODO: Use [].sort instead? + function min () { + var args = [].slice.call(arguments, 0); + + return pickBy('isBefore', args); + } + + function max () { + var args = [].slice.call(arguments, 0); + + return pickBy('isAfter', args); + } + + var now = function () { + return Date.now ? Date.now() : +(new Date()); + }; + + var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond']; + + function isDurationValid(m) { + for (var key in m) { + if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) { + return false; + } + } + + var unitHasDecimal = false; + for (var i = 0; i < ordering.length; ++i) { + if (m[ordering[i]]) { + if (unitHasDecimal) { + return false; // only allow non-integers for smallest unit + } + if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) { + unitHasDecimal = true; + } + } + } + + return true; + } + + function isValid$1() { + return this._isValid; + } + + function createInvalid$1() { + return createDuration(NaN); + } + + function Duration (duration) { + var normalizedInput = normalizeObjectUnits(duration), + years = normalizedInput.year || 0, + quarters = normalizedInput.quarter || 0, + months = normalizedInput.month || 0, + weeks = normalizedInput.week || normalizedInput.isoWeek || 0, + days = normalizedInput.day || 0, + hours = normalizedInput.hour || 0, + minutes = normalizedInput.minute || 0, + seconds = normalizedInput.second || 0, + milliseconds = normalizedInput.millisecond || 0; + + this._isValid = isDurationValid(normalizedInput); + + // representation for dateAddRemove + this._milliseconds = +milliseconds + + seconds * 1e3 + // 1000 + minutes * 6e4 + // 1000 * 60 + hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978 + // Because of dateAddRemove treats 24 hours as different from a + // day when working around DST, we need to store them separately + this._days = +days + + weeks * 7; + // It is impossible to translate months into days without knowing + // which months you are are talking about, so we have to store + // it separately. + this._months = +months + + quarters * 3 + + years * 12; + + this._data = {}; + + this._locale = getLocale(); + + this._bubble(); + } + + function isDuration (obj) { + return obj instanceof Duration; + } + + function absRound (number) { + if (number < 0) { + return Math.round(-1 * number) * -1; + } else { + return Math.round(number); + } + } + + // FORMATTING + + function offset (token, separator) { + addFormatToken(token, 0, 0, function () { + var offset = this.utcOffset(); + var sign = '+'; + if (offset < 0) { + offset = -offset; + sign = '-'; + } + return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2); + }); + } + + offset('Z', ':'); + offset('ZZ', ''); + + // PARSING + + addRegexToken('Z', matchShortOffset); + addRegexToken('ZZ', matchShortOffset); + addParseToken(['Z', 'ZZ'], function (input, array, config) { + config._useUTC = true; + config._tzm = offsetFromString(matchShortOffset, input); + }); + + // HELPERS + + // timezone chunker + // '+10:00' > ['10', '00'] + // '-1530' > ['-15', '30'] + var chunkOffset = /([\+\-]|\d\d)/gi; + + function offsetFromString(matcher, string) { + var matches = (string || '').match(matcher); + + if (matches === null) { + return null; + } + + var chunk = matches[matches.length - 1] || []; + var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0]; + var minutes = +(parts[1] * 60) + toInt(parts[2]); + + return minutes === 0 ? + 0 : + parts[0] === '+' ? minutes : -minutes; + } + + // Return a moment from input, that is local/utc/zone equivalent to model. + function cloneWithOffset(input, model) { + var res, diff; + if (model._isUTC) { + res = model.clone(); + diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf(); + // Use low-level api, because this fn is low-level api. + res._d.setTime(res._d.valueOf() + diff); + hooks.updateOffset(res, false); + return res; + } else { + return createLocal(input).local(); + } + } + + function getDateOffset (m) { + // On Firefox.24 Date#getTimezoneOffset returns a floating point. + // https://github.com/moment/moment/pull/1871 + return -Math.round(m._d.getTimezoneOffset() / 15) * 15; + } + + // HOOKS + + // This function will be called whenever a moment is mutated. + // It is intended to keep the offset in sync with the timezone. + hooks.updateOffset = function () {}; + + // MOMENTS + + // keepLocalTime = true means only change the timezone, without + // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]--> + // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset + // +0200, so we adjust the time as needed, to be valid. + // + // Keeping the time actually adds/subtracts (one hour) + // from the actual represented time. That is why we call updateOffset + // a second time. In case it wants us to change the offset again + // _changeInProgress == true case, then we have to adjust, because + // there is no such time in the given timezone. + function getSetOffset (input, keepLocalTime, keepMinutes) { + var offset = this._offset || 0, + localAdjust; + if (!this.isValid()) { + return input != null ? this : NaN; + } + if (input != null) { + if (typeof input === 'string') { + input = offsetFromString(matchShortOffset, input); + if (input === null) { + return this; + } + } else if (Math.abs(input) < 16 && !keepMinutes) { + input = input * 60; + } + if (!this._isUTC && keepLocalTime) { + localAdjust = getDateOffset(this); + } + this._offset = input; + this._isUTC = true; + if (localAdjust != null) { + this.add(localAdjust, 'm'); + } + if (offset !== input) { + if (!keepLocalTime || this._changeInProgress) { + addSubtract(this, createDuration(input - offset, 'm'), 1, false); + } else if (!this._changeInProgress) { + this._changeInProgress = true; + hooks.updateOffset(this, true); + this._changeInProgress = null; + } + } + return this; + } else { + return this._isUTC ? offset : getDateOffset(this); + } + } + + function getSetZone (input, keepLocalTime) { + if (input != null) { + if (typeof input !== 'string') { + input = -input; + } + + this.utcOffset(input, keepLocalTime); + + return this; + } else { + return -this.utcOffset(); + } + } + + function setOffsetToUTC (keepLocalTime) { + return this.utcOffset(0, keepLocalTime); + } + + function setOffsetToLocal (keepLocalTime) { + if (this._isUTC) { + this.utcOffset(0, keepLocalTime); + this._isUTC = false; + + if (keepLocalTime) { + this.subtract(getDateOffset(this), 'm'); + } + } + return this; + } + + function setOffsetToParsedOffset () { + if (this._tzm != null) { + this.utcOffset(this._tzm, false, true); + } else if (typeof this._i === 'string') { + var tZone = offsetFromString(matchOffset, this._i); + if (tZone != null) { + this.utcOffset(tZone); + } + else { + this.utcOffset(0, true); + } + } + return this; + } + + function hasAlignedHourOffset (input) { + if (!this.isValid()) { + return false; + } + input = input ? createLocal(input).utcOffset() : 0; + + return (this.utcOffset() - input) % 60 === 0; + } + + function isDaylightSavingTime () { + return ( + this.utcOffset() > this.clone().month(0).utcOffset() || + this.utcOffset() > this.clone().month(5).utcOffset() + ); + } + + function isDaylightSavingTimeShifted () { + if (!isUndefined(this._isDSTShifted)) { + return this._isDSTShifted; + } + + var c = {}; + + copyConfig(c, this); + c = prepareConfig(c); + + if (c._a) { + var other = c._isUTC ? createUTC(c._a) : createLocal(c._a); + this._isDSTShifted = this.isValid() && + compareArrays(c._a, other.toArray()) > 0; + } else { + this._isDSTShifted = false; + } + + return this._isDSTShifted; + } + + function isLocal () { + return this.isValid() ? !this._isUTC : false; + } + + function isUtcOffset () { + return this.isValid() ? this._isUTC : false; + } + + function isUtc () { + return this.isValid() ? this._isUTC && this._offset === 0 : false; + } + + // ASP.NET json date format regex + var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/; + + // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html + // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere + // and further modified to allow for strings containing both week and day + var isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/; + + function createDuration (input, key) { + var duration = input, + // matching against regexp is expensive, do it on demand + match = null, + sign, + ret, + diffRes; + + if (isDuration(input)) { + duration = { + ms : input._milliseconds, + d : input._days, + M : input._months + }; + } else if (isNumber(input)) { + duration = {}; + if (key) { + duration[key] = input; + } else { + duration.milliseconds = input; + } + } else if (!!(match = aspNetRegex.exec(input))) { + sign = (match[1] === '-') ? -1 : 1; + duration = { + y : 0, + d : toInt(match[DATE]) * sign, + h : toInt(match[HOUR]) * sign, + m : toInt(match[MINUTE]) * sign, + s : toInt(match[SECOND]) * sign, + ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match + }; + } else if (!!(match = isoRegex.exec(input))) { + sign = (match[1] === '-') ? -1 : 1; + duration = { + y : parseIso(match[2], sign), + M : parseIso(match[3], sign), + w : parseIso(match[4], sign), + d : parseIso(match[5], sign), + h : parseIso(match[6], sign), + m : parseIso(match[7], sign), + s : parseIso(match[8], sign) + }; + } else if (duration == null) {// checks for null or undefined + duration = {}; + } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) { + diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to)); + + duration = {}; + duration.ms = diffRes.milliseconds; + duration.M = diffRes.months; + } + + ret = new Duration(duration); + + if (isDuration(input) && hasOwnProp(input, '_locale')) { + ret._locale = input._locale; + } + + return ret; + } + + createDuration.fn = Duration.prototype; + createDuration.invalid = createInvalid$1; + + function parseIso (inp, sign) { + // We'd normally use ~~inp for this, but unfortunately it also + // converts floats to ints. + // inp may be undefined, so careful calling replace on it. + var res = inp && parseFloat(inp.replace(',', '.')); + // apply sign while we're at it + return (isNaN(res) ? 0 : res) * sign; + } + + function positiveMomentsDifference(base, other) { + var res = {}; + + res.months = other.month() - base.month() + + (other.year() - base.year()) * 12; + if (base.clone().add(res.months, 'M').isAfter(other)) { + --res.months; + } + + res.milliseconds = +other - +(base.clone().add(res.months, 'M')); + + return res; + } + + function momentsDifference(base, other) { + var res; + if (!(base.isValid() && other.isValid())) { + return {milliseconds: 0, months: 0}; + } + + other = cloneWithOffset(other, base); + if (base.isBefore(other)) { + res = positiveMomentsDifference(base, other); + } else { + res = positiveMomentsDifference(other, base); + res.milliseconds = -res.milliseconds; + res.months = -res.months; + } + + return res; + } + + // TODO: remove 'name' arg after deprecation is removed + function createAdder(direction, name) { + return function (val, period) { + var dur, tmp; + //invert the arguments, but complain about it + if (period !== null && !isNaN(+period)) { + deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' + + 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.'); + tmp = val; val = period; period = tmp; + } + + val = typeof val === 'string' ? +val : val; + dur = createDuration(val, period); + addSubtract(this, dur, direction); + return this; + }; + } + + function addSubtract (mom, duration, isAdding, updateOffset) { + var milliseconds = duration._milliseconds, + days = absRound(duration._days), + months = absRound(duration._months); + + if (!mom.isValid()) { + // No op + return; + } + + updateOffset = updateOffset == null ? true : updateOffset; + + if (months) { + setMonth(mom, get(mom, 'Month') + months * isAdding); + } + if (days) { + set$1(mom, 'Date', get(mom, 'Date') + days * isAdding); + } + if (milliseconds) { + mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding); + } + if (updateOffset) { + hooks.updateOffset(mom, days || months); + } + } + + var add = createAdder(1, 'add'); + var subtract = createAdder(-1, 'subtract'); + + function getCalendarFormat(myMoment, now) { + var diff = myMoment.diff(now, 'days', true); + return diff < -6 ? 'sameElse' : + diff < -1 ? 'lastWeek' : + diff < 0 ? 'lastDay' : + diff < 1 ? 'sameDay' : + diff < 2 ? 'nextDay' : + diff < 7 ? 'nextWeek' : 'sameElse'; + } + + function calendar$1 (time, formats) { + // We want to compare the start of today, vs this. + // Getting start-of-today depends on whether we're local/utc/offset or not. + var now = time || createLocal(), + sod = cloneWithOffset(now, this).startOf('day'), + format = hooks.calendarFormat(this, sod) || 'sameElse'; + + var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]); + + return this.format(output || this.localeData().calendar(format, this, createLocal(now))); + } + + function clone () { + return new Moment(this); + } + + function isAfter (input, units) { + var localInput = isMoment(input) ? input : createLocal(input); + if (!(this.isValid() && localInput.isValid())) { + return false; + } + units = normalizeUnits(units) || 'millisecond'; + if (units === 'millisecond') { + return this.valueOf() > localInput.valueOf(); + } else { + return localInput.valueOf() < this.clone().startOf(units).valueOf(); + } + } + + function isBefore (input, units) { + var localInput = isMoment(input) ? input : createLocal(input); + if (!(this.isValid() && localInput.isValid())) { + return false; + } + units = normalizeUnits(units) || 'millisecond'; + if (units === 'millisecond') { + return this.valueOf() < localInput.valueOf(); + } else { + return this.clone().endOf(units).valueOf() < localInput.valueOf(); + } + } + + function isBetween (from, to, units, inclusivity) { + var localFrom = isMoment(from) ? from : createLocal(from), + localTo = isMoment(to) ? to : createLocal(to); + if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) { + return false; + } + inclusivity = inclusivity || '()'; + return (inclusivity[0] === '(' ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) && + (inclusivity[1] === ')' ? this.isBefore(localTo, units) : !this.isAfter(localTo, units)); + } + + function isSame (input, units) { + var localInput = isMoment(input) ? input : createLocal(input), + inputMs; + if (!(this.isValid() && localInput.isValid())) { + return false; + } + units = normalizeUnits(units) || 'millisecond'; + if (units === 'millisecond') { + return this.valueOf() === localInput.valueOf(); + } else { + inputMs = localInput.valueOf(); + return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf(); + } + } + + function isSameOrAfter (input, units) { + return this.isSame(input, units) || this.isAfter(input, units); + } + + function isSameOrBefore (input, units) { + return this.isSame(input, units) || this.isBefore(input, units); + } + + function diff (input, units, asFloat) { + var that, + zoneDelta, + output; + + if (!this.isValid()) { + return NaN; + } + + that = cloneWithOffset(input, this); + + if (!that.isValid()) { + return NaN; + } + + zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4; + + units = normalizeUnits(units); + + switch (units) { + case 'year': output = monthDiff(this, that) / 12; break; + case 'month': output = monthDiff(this, that); break; + case 'quarter': output = monthDiff(this, that) / 3; break; + case 'second': output = (this - that) / 1e3; break; // 1000 + case 'minute': output = (this - that) / 6e4; break; // 1000 * 60 + case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60 + case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst + case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst + default: output = this - that; + } + + return asFloat ? output : absFloor(output); + } + + function monthDiff (a, b) { + // difference in months + var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()), + // b is in (anchor - 1 month, anchor + 1 month) + anchor = a.clone().add(wholeMonthDiff, 'months'), + anchor2, adjust; + + if (b - anchor < 0) { + anchor2 = a.clone().add(wholeMonthDiff - 1, 'months'); + // linear across the month + adjust = (b - anchor) / (anchor - anchor2); + } else { + anchor2 = a.clone().add(wholeMonthDiff + 1, 'months'); + // linear across the month + adjust = (b - anchor) / (anchor2 - anchor); + } + + //check for negative zero, return zero if negative zero + return -(wholeMonthDiff + adjust) || 0; + } + + hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ'; + hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]'; + + function toString () { + return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ'); + } + + function toISOString(keepOffset) { + if (!this.isValid()) { + return null; + } + var utc = keepOffset !== true; + var m = utc ? this.clone().utc() : this; + if (m.year() < 0 || m.year() > 9999) { + return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ'); + } + if (isFunction(Date.prototype.toISOString)) { + // native implementation is ~50x faster, use it when we can + if (utc) { + return this.toDate().toISOString(); + } else { + return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z')); + } + } + return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ'); + } + + /** + * Return a human readable representation of a moment that can + * also be evaluated to get a new moment which is the same + * + * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects + */ + function inspect () { + if (!this.isValid()) { + return 'moment.invalid(/* ' + this._i + ' */)'; + } + var func = 'moment'; + var zone = ''; + if (!this.isLocal()) { + func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone'; + zone = 'Z'; + } + var prefix = '[' + func + '("]'; + var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY'; + var datetime = '-MM-DD[T]HH:mm:ss.SSS'; + var suffix = zone + '[")]'; + + return this.format(prefix + year + datetime + suffix); + } + + function format (inputString) { + if (!inputString) { + inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat; + } + var output = formatMoment(this, inputString); + return this.localeData().postformat(output); + } + + function from (time, withoutSuffix) { + if (this.isValid() && + ((isMoment(time) && time.isValid()) || + createLocal(time).isValid())) { + return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix); + } else { + return this.localeData().invalidDate(); + } + } + + function fromNow (withoutSuffix) { + return this.from(createLocal(), withoutSuffix); + } + + function to (time, withoutSuffix) { + if (this.isValid() && + ((isMoment(time) && time.isValid()) || + createLocal(time).isValid())) { + return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix); + } else { + return this.localeData().invalidDate(); + } + } + + function toNow (withoutSuffix) { + return this.to(createLocal(), withoutSuffix); + } + + // If passed a locale key, it will set the locale for this + // instance. Otherwise, it will return the locale configuration + // variables for this instance. + function locale (key) { + var newLocaleData; + + if (key === undefined) { + return this._locale._abbr; + } else { + newLocaleData = getLocale(key); + if (newLocaleData != null) { + this._locale = newLocaleData; + } + return this; + } + } + + var lang = deprecate( + 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', + function (key) { + if (key === undefined) { + return this.localeData(); + } else { + return this.locale(key); + } + } + ); + + function localeData () { + return this._locale; + } + + var MS_PER_SECOND = 1000; + var MS_PER_MINUTE = 60 * MS_PER_SECOND; + var MS_PER_HOUR = 60 * MS_PER_MINUTE; + var MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR; + + // actual modulo - handles negative numbers (for dates before 1970): + function mod$1(dividend, divisor) { + return (dividend % divisor + divisor) % divisor; + } + + function localStartOfDate(y, m, d) { + // the date constructor remaps years 0-99 to 1900-1999 + if (y < 100 && y >= 0) { + // preserve leap years using a full 400 year cycle, then reset + return new Date(y + 400, m, d) - MS_PER_400_YEARS; + } else { + return new Date(y, m, d).valueOf(); + } + } + + function utcStartOfDate(y, m, d) { + // Date.UTC remaps years 0-99 to 1900-1999 + if (y < 100 && y >= 0) { + // preserve leap years using a full 400 year cycle, then reset + return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS; + } else { + return Date.UTC(y, m, d); + } + } + + function startOf (units) { + var time; + units = normalizeUnits(units); + if (units === undefined || units === 'millisecond' || !this.isValid()) { + return this; + } + + var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; + + switch (units) { + case 'year': + time = startOfDate(this.year(), 0, 1); + break; + case 'quarter': + time = startOfDate(this.year(), this.month() - this.month() % 3, 1); + break; + case 'month': + time = startOfDate(this.year(), this.month(), 1); + break; + case 'week': + time = startOfDate(this.year(), this.month(), this.date() - this.weekday()); + break; + case 'isoWeek': + time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1)); + break; + case 'day': + case 'date': + time = startOfDate(this.year(), this.month(), this.date()); + break; + case 'hour': + time = this._d.valueOf(); + time -= mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR); + break; + case 'minute': + time = this._d.valueOf(); + time -= mod$1(time, MS_PER_MINUTE); + break; + case 'second': + time = this._d.valueOf(); + time -= mod$1(time, MS_PER_SECOND); + break; + } + + this._d.setTime(time); + hooks.updateOffset(this, true); + return this; + } + + function endOf (units) { + var time; + units = normalizeUnits(units); + if (units === undefined || units === 'millisecond' || !this.isValid()) { + return this; + } + + var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; + + switch (units) { + case 'year': + time = startOfDate(this.year() + 1, 0, 1) - 1; + break; + case 'quarter': + time = startOfDate(this.year(), this.month() - this.month() % 3 + 3, 1) - 1; + break; + case 'month': + time = startOfDate(this.year(), this.month() + 1, 1) - 1; + break; + case 'week': + time = startOfDate(this.year(), this.month(), this.date() - this.weekday() + 7) - 1; + break; + case 'isoWeek': + time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1) + 7) - 1; + break; + case 'day': + case 'date': + time = startOfDate(this.year(), this.month(), this.date() + 1) - 1; + break; + case 'hour': + time = this._d.valueOf(); + time += MS_PER_HOUR - mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR) - 1; + break; + case 'minute': + time = this._d.valueOf(); + time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1; + break; + case 'second': + time = this._d.valueOf(); + time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1; + break; + } + + this._d.setTime(time); + hooks.updateOffset(this, true); + return this; + } + + function valueOf () { + return this._d.valueOf() - ((this._offset || 0) * 60000); + } + + function unix () { + return Math.floor(this.valueOf() / 1000); + } + + function toDate () { + return new Date(this.valueOf()); + } + + function toArray () { + var m = this; + return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()]; + } + + function toObject () { + var m = this; + return { + years: m.year(), + months: m.month(), + date: m.date(), + hours: m.hours(), + minutes: m.minutes(), + seconds: m.seconds(), + milliseconds: m.milliseconds() + }; + } + + function toJSON () { + // new Date(NaN).toJSON() === null + return this.isValid() ? this.toISOString() : null; + } + + function isValid$2 () { + return isValid(this); + } + + function parsingFlags () { + return extend({}, getParsingFlags(this)); + } + + function invalidAt () { + return getParsingFlags(this).overflow; + } + + function creationData() { + return { + input: this._i, + format: this._f, + locale: this._locale, + isUTC: this._isUTC, + strict: this._strict + }; + } + + // FORMATTING + + addFormatToken(0, ['gg', 2], 0, function () { + return this.weekYear() % 100; + }); + + addFormatToken(0, ['GG', 2], 0, function () { + return this.isoWeekYear() % 100; + }); + + function addWeekYearFormatToken (token, getter) { + addFormatToken(0, [token, token.length], 0, getter); + } + + addWeekYearFormatToken('gggg', 'weekYear'); + addWeekYearFormatToken('ggggg', 'weekYear'); + addWeekYearFormatToken('GGGG', 'isoWeekYear'); + addWeekYearFormatToken('GGGGG', 'isoWeekYear'); + + // ALIASES + + addUnitAlias('weekYear', 'gg'); + addUnitAlias('isoWeekYear', 'GG'); + + // PRIORITY + + addUnitPriority('weekYear', 1); + addUnitPriority('isoWeekYear', 1); + + + // PARSING + + addRegexToken('G', matchSigned); + addRegexToken('g', matchSigned); + addRegexToken('GG', match1to2, match2); + addRegexToken('gg', match1to2, match2); + addRegexToken('GGGG', match1to4, match4); + addRegexToken('gggg', match1to4, match4); + addRegexToken('GGGGG', match1to6, match6); + addRegexToken('ggggg', match1to6, match6); + + addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) { + week[token.substr(0, 2)] = toInt(input); + }); + + addWeekParseToken(['gg', 'GG'], function (input, week, config, token) { + week[token] = hooks.parseTwoDigitYear(input); + }); + + // MOMENTS + + function getSetWeekYear (input) { + return getSetWeekYearHelper.call(this, + input, + this.week(), + this.weekday(), + this.localeData()._week.dow, + this.localeData()._week.doy); + } + + function getSetISOWeekYear (input) { + return getSetWeekYearHelper.call(this, + input, this.isoWeek(), this.isoWeekday(), 1, 4); + } + + function getISOWeeksInYear () { + return weeksInYear(this.year(), 1, 4); + } + + function getWeeksInYear () { + var weekInfo = this.localeData()._week; + return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy); + } + + function getSetWeekYearHelper(input, week, weekday, dow, doy) { + var weeksTarget; + if (input == null) { + return weekOfYear(this, dow, doy).year; + } else { + weeksTarget = weeksInYear(input, dow, doy); + if (week > weeksTarget) { + week = weeksTarget; + } + return setWeekAll.call(this, input, week, weekday, dow, doy); + } + } + + function setWeekAll(weekYear, week, weekday, dow, doy) { + var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), + date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear); + + this.year(date.getUTCFullYear()); + this.month(date.getUTCMonth()); + this.date(date.getUTCDate()); + return this; + } + + // FORMATTING + + addFormatToken('Q', 0, 'Qo', 'quarter'); + + // ALIASES + + addUnitAlias('quarter', 'Q'); + + // PRIORITY + + addUnitPriority('quarter', 7); + + // PARSING + + addRegexToken('Q', match1); + addParseToken('Q', function (input, array) { + array[MONTH] = (toInt(input) - 1) * 3; + }); + + // MOMENTS + + function getSetQuarter (input) { + return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3); + } + + // FORMATTING + + addFormatToken('D', ['DD', 2], 'Do', 'date'); + + // ALIASES + + addUnitAlias('date', 'D'); + + // PRIORITY + addUnitPriority('date', 9); + + // PARSING + + addRegexToken('D', match1to2); + addRegexToken('DD', match1to2, match2); + addRegexToken('Do', function (isStrict, locale) { + // TODO: Remove "ordinalParse" fallback in next major release. + return isStrict ? + (locale._dayOfMonthOrdinalParse || locale._ordinalParse) : + locale._dayOfMonthOrdinalParseLenient; + }); + + addParseToken(['D', 'DD'], DATE); + addParseToken('Do', function (input, array) { + array[DATE] = toInt(input.match(match1to2)[0]); + }); + + // MOMENTS + + var getSetDayOfMonth = makeGetSet('Date', true); + + // FORMATTING + + addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear'); + + // ALIASES + + addUnitAlias('dayOfYear', 'DDD'); + + // PRIORITY + addUnitPriority('dayOfYear', 4); + + // PARSING + + addRegexToken('DDD', match1to3); + addRegexToken('DDDD', match3); + addParseToken(['DDD', 'DDDD'], function (input, array, config) { + config._dayOfYear = toInt(input); + }); + + // HELPERS + + // MOMENTS + + function getSetDayOfYear (input) { + var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1; + return input == null ? dayOfYear : this.add((input - dayOfYear), 'd'); + } + + // FORMATTING + + addFormatToken('m', ['mm', 2], 0, 'minute'); + + // ALIASES + + addUnitAlias('minute', 'm'); + + // PRIORITY + + addUnitPriority('minute', 14); + + // PARSING + + addRegexToken('m', match1to2); + addRegexToken('mm', match1to2, match2); + addParseToken(['m', 'mm'], MINUTE); + + // MOMENTS + + var getSetMinute = makeGetSet('Minutes', false); + + // FORMATTING + + addFormatToken('s', ['ss', 2], 0, 'second'); + + // ALIASES + + addUnitAlias('second', 's'); + + // PRIORITY + + addUnitPriority('second', 15); + + // PARSING + + addRegexToken('s', match1to2); + addRegexToken('ss', match1to2, match2); + addParseToken(['s', 'ss'], SECOND); + + // MOMENTS + + var getSetSecond = makeGetSet('Seconds', false); + + // FORMATTING + + addFormatToken('S', 0, 0, function () { + return ~~(this.millisecond() / 100); + }); + + addFormatToken(0, ['SS', 2], 0, function () { + return ~~(this.millisecond() / 10); + }); + + addFormatToken(0, ['SSS', 3], 0, 'millisecond'); + addFormatToken(0, ['SSSS', 4], 0, function () { + return this.millisecond() * 10; + }); + addFormatToken(0, ['SSSSS', 5], 0, function () { + return this.millisecond() * 100; + }); + addFormatToken(0, ['SSSSSS', 6], 0, function () { + return this.millisecond() * 1000; + }); + addFormatToken(0, ['SSSSSSS', 7], 0, function () { + return this.millisecond() * 10000; + }); + addFormatToken(0, ['SSSSSSSS', 8], 0, function () { + return this.millisecond() * 100000; + }); + addFormatToken(0, ['SSSSSSSSS', 9], 0, function () { + return this.millisecond() * 1000000; + }); + + + // ALIASES + + addUnitAlias('millisecond', 'ms'); + + // PRIORITY + + addUnitPriority('millisecond', 16); + + // PARSING + + addRegexToken('S', match1to3, match1); + addRegexToken('SS', match1to3, match2); + addRegexToken('SSS', match1to3, match3); + + var token; + for (token = 'SSSS'; token.length <= 9; token += 'S') { + addRegexToken(token, matchUnsigned); + } + + function parseMs(input, array) { + array[MILLISECOND] = toInt(('0.' + input) * 1000); + } + + for (token = 'S'; token.length <= 9; token += 'S') { + addParseToken(token, parseMs); + } + // MOMENTS + + var getSetMillisecond = makeGetSet('Milliseconds', false); + + // FORMATTING + + addFormatToken('z', 0, 0, 'zoneAbbr'); + addFormatToken('zz', 0, 0, 'zoneName'); + + // MOMENTS + + function getZoneAbbr () { + return this._isUTC ? 'UTC' : ''; + } + + function getZoneName () { + return this._isUTC ? 'Coordinated Universal Time' : ''; + } + + var proto = Moment.prototype; + + proto.add = add; + proto.calendar = calendar$1; + proto.clone = clone; + proto.diff = diff; + proto.endOf = endOf; + proto.format = format; + proto.from = from; + proto.fromNow = fromNow; + proto.to = to; + proto.toNow = toNow; + proto.get = stringGet; + proto.invalidAt = invalidAt; + proto.isAfter = isAfter; + proto.isBefore = isBefore; + proto.isBetween = isBetween; + proto.isSame = isSame; + proto.isSameOrAfter = isSameOrAfter; + proto.isSameOrBefore = isSameOrBefore; + proto.isValid = isValid$2; + proto.lang = lang; + proto.locale = locale; + proto.localeData = localeData; + proto.max = prototypeMax; + proto.min = prototypeMin; + proto.parsingFlags = parsingFlags; + proto.set = stringSet; + proto.startOf = startOf; + proto.subtract = subtract; + proto.toArray = toArray; + proto.toObject = toObject; + proto.toDate = toDate; + proto.toISOString = toISOString; + proto.inspect = inspect; + proto.toJSON = toJSON; + proto.toString = toString; + proto.unix = unix; + proto.valueOf = valueOf; + proto.creationData = creationData; + proto.year = getSetYear; + proto.isLeapYear = getIsLeapYear; + proto.weekYear = getSetWeekYear; + proto.isoWeekYear = getSetISOWeekYear; + proto.quarter = proto.quarters = getSetQuarter; + proto.month = getSetMonth; + proto.daysInMonth = getDaysInMonth; + proto.week = proto.weeks = getSetWeek; + proto.isoWeek = proto.isoWeeks = getSetISOWeek; + proto.weeksInYear = getWeeksInYear; + proto.isoWeeksInYear = getISOWeeksInYear; + proto.date = getSetDayOfMonth; + proto.day = proto.days = getSetDayOfWeek; + proto.weekday = getSetLocaleDayOfWeek; + proto.isoWeekday = getSetISODayOfWeek; + proto.dayOfYear = getSetDayOfYear; + proto.hour = proto.hours = getSetHour; + proto.minute = proto.minutes = getSetMinute; + proto.second = proto.seconds = getSetSecond; + proto.millisecond = proto.milliseconds = getSetMillisecond; + proto.utcOffset = getSetOffset; + proto.utc = setOffsetToUTC; + proto.local = setOffsetToLocal; + proto.parseZone = setOffsetToParsedOffset; + proto.hasAlignedHourOffset = hasAlignedHourOffset; + proto.isDST = isDaylightSavingTime; + proto.isLocal = isLocal; + proto.isUtcOffset = isUtcOffset; + proto.isUtc = isUtc; + proto.isUTC = isUtc; + proto.zoneAbbr = getZoneAbbr; + proto.zoneName = getZoneName; + proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth); + proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth); + proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear); + proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone); + proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted); + + function createUnix (input) { + return createLocal(input * 1000); + } + + function createInZone () { + return createLocal.apply(null, arguments).parseZone(); + } + + function preParsePostFormat (string) { + return string; + } + + var proto$1 = Locale.prototype; + + proto$1.calendar = calendar; + proto$1.longDateFormat = longDateFormat; + proto$1.invalidDate = invalidDate; + proto$1.ordinal = ordinal; + proto$1.preparse = preParsePostFormat; + proto$1.postformat = preParsePostFormat; + proto$1.relativeTime = relativeTime; + proto$1.pastFuture = pastFuture; + proto$1.set = set; + + proto$1.months = localeMonths; + proto$1.monthsShort = localeMonthsShort; + proto$1.monthsParse = localeMonthsParse; + proto$1.monthsRegex = monthsRegex; + proto$1.monthsShortRegex = monthsShortRegex; + proto$1.week = localeWeek; + proto$1.firstDayOfYear = localeFirstDayOfYear; + proto$1.firstDayOfWeek = localeFirstDayOfWeek; + + proto$1.weekdays = localeWeekdays; + proto$1.weekdaysMin = localeWeekdaysMin; + proto$1.weekdaysShort = localeWeekdaysShort; + proto$1.weekdaysParse = localeWeekdaysParse; + + proto$1.weekdaysRegex = weekdaysRegex; + proto$1.weekdaysShortRegex = weekdaysShortRegex; + proto$1.weekdaysMinRegex = weekdaysMinRegex; + + proto$1.isPM = localeIsPM; + proto$1.meridiem = localeMeridiem; + + function get$1 (format, index, field, setter) { + var locale = getLocale(); + var utc = createUTC().set(setter, index); + return locale[field](utc, format); + } + + function listMonthsImpl (format, index, field) { + if (isNumber(format)) { + index = format; + format = undefined; + } + + format = format || ''; + + if (index != null) { + return get$1(format, index, field, 'month'); + } + + var i; + var out = []; + for (i = 0; i < 12; i++) { + out[i] = get$1(format, i, field, 'month'); + } + return out; + } + + // () + // (5) + // (fmt, 5) + // (fmt) + // (true) + // (true, 5) + // (true, fmt, 5) + // (true, fmt) + function listWeekdaysImpl (localeSorted, format, index, field) { + if (typeof localeSorted === 'boolean') { + if (isNumber(format)) { + index = format; + format = undefined; + } + + format = format || ''; + } else { + format = localeSorted; + index = format; + localeSorted = false; + + if (isNumber(format)) { + index = format; + format = undefined; + } + + format = format || ''; + } + + var locale = getLocale(), + shift = localeSorted ? locale._week.dow : 0; + + if (index != null) { + return get$1(format, (index + shift) % 7, field, 'day'); + } + + var i; + var out = []; + for (i = 0; i < 7; i++) { + out[i] = get$1(format, (i + shift) % 7, field, 'day'); + } + return out; + } + + function listMonths (format, index) { + return listMonthsImpl(format, index, 'months'); + } + + function listMonthsShort (format, index) { + return listMonthsImpl(format, index, 'monthsShort'); + } + + function listWeekdays (localeSorted, format, index) { + return listWeekdaysImpl(localeSorted, format, index, 'weekdays'); + } + + function listWeekdaysShort (localeSorted, format, index) { + return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort'); + } + + function listWeekdaysMin (localeSorted, format, index) { + return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin'); + } + + getSetGlobalLocale('en', { + dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/, + ordinal : function (number) { + var b = number % 10, + output = (toInt(number % 100 / 10) === 1) ? 'th' : + (b === 1) ? 'st' : + (b === 2) ? 'nd' : + (b === 3) ? 'rd' : 'th'; + return number + output; + } + }); + + // Side effect imports + + hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale); + hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale); + + var mathAbs = Math.abs; + + function abs () { + var data = this._data; + + this._milliseconds = mathAbs(this._milliseconds); + this._days = mathAbs(this._days); + this._months = mathAbs(this._months); + + data.milliseconds = mathAbs(data.milliseconds); + data.seconds = mathAbs(data.seconds); + data.minutes = mathAbs(data.minutes); + data.hours = mathAbs(data.hours); + data.months = mathAbs(data.months); + data.years = mathAbs(data.years); + + return this; + } + + function addSubtract$1 (duration, input, value, direction) { + var other = createDuration(input, value); + + duration._milliseconds += direction * other._milliseconds; + duration._days += direction * other._days; + duration._months += direction * other._months; + + return duration._bubble(); + } + + // supports only 2.0-style add(1, 's') or add(duration) + function add$1 (input, value) { + return addSubtract$1(this, input, value, 1); + } + + // supports only 2.0-style subtract(1, 's') or subtract(duration) + function subtract$1 (input, value) { + return addSubtract$1(this, input, value, -1); + } + + function absCeil (number) { + if (number < 0) { + return Math.floor(number); + } else { + return Math.ceil(number); + } + } + + function bubble () { + var milliseconds = this._milliseconds; + var days = this._days; + var months = this._months; + var data = this._data; + var seconds, minutes, hours, years, monthsFromDays; + + // if we have a mix of positive and negative values, bubble down first + // check: https://github.com/moment/moment/issues/2166 + if (!((milliseconds >= 0 && days >= 0 && months >= 0) || + (milliseconds <= 0 && days <= 0 && months <= 0))) { + milliseconds += absCeil(monthsToDays(months) + days) * 864e5; + days = 0; + months = 0; + } + + // The following code bubbles up values, see the tests for + // examples of what that means. + data.milliseconds = milliseconds % 1000; + + seconds = absFloor(milliseconds / 1000); + data.seconds = seconds % 60; + + minutes = absFloor(seconds / 60); + data.minutes = minutes % 60; + + hours = absFloor(minutes / 60); + data.hours = hours % 24; + + days += absFloor(hours / 24); + + // convert days to months + monthsFromDays = absFloor(daysToMonths(days)); + months += monthsFromDays; + days -= absCeil(monthsToDays(monthsFromDays)); + + // 12 months -> 1 year + years = absFloor(months / 12); + months %= 12; + + data.days = days; + data.months = months; + data.years = years; + + return this; + } + + function daysToMonths (days) { + // 400 years have 146097 days (taking into account leap year rules) + // 400 years have 12 months === 4800 + return days * 4800 / 146097; + } + + function monthsToDays (months) { + // the reverse of daysToMonths + return months * 146097 / 4800; + } + + function as (units) { + if (!this.isValid()) { + return NaN; + } + var days; + var months; + var milliseconds = this._milliseconds; + + units = normalizeUnits(units); + + if (units === 'month' || units === 'quarter' || units === 'year') { + days = this._days + milliseconds / 864e5; + months = this._months + daysToMonths(days); + switch (units) { + case 'month': return months; + case 'quarter': return months / 3; + case 'year': return months / 12; + } + } else { + // handle milliseconds separately because of floating point math errors (issue #1867) + days = this._days + Math.round(monthsToDays(this._months)); + switch (units) { + case 'week' : return days / 7 + milliseconds / 6048e5; + case 'day' : return days + milliseconds / 864e5; + case 'hour' : return days * 24 + milliseconds / 36e5; + case 'minute' : return days * 1440 + milliseconds / 6e4; + case 'second' : return days * 86400 + milliseconds / 1000; + // Math.floor prevents floating point math errors here + case 'millisecond': return Math.floor(days * 864e5) + milliseconds; + default: throw new Error('Unknown unit ' + units); + } + } + } + + // TODO: Use this.as('ms')? + function valueOf$1 () { + if (!this.isValid()) { + return NaN; + } + return ( + this._milliseconds + + this._days * 864e5 + + (this._months % 12) * 2592e6 + + toInt(this._months / 12) * 31536e6 + ); + } + + function makeAs (alias) { + return function () { + return this.as(alias); + }; + } + + var asMilliseconds = makeAs('ms'); + var asSeconds = makeAs('s'); + var asMinutes = makeAs('m'); + var asHours = makeAs('h'); + var asDays = makeAs('d'); + var asWeeks = makeAs('w'); + var asMonths = makeAs('M'); + var asQuarters = makeAs('Q'); + var asYears = makeAs('y'); + + function clone$1 () { + return createDuration(this); + } + + function get$2 (units) { + units = normalizeUnits(units); + return this.isValid() ? this[units + 's']() : NaN; + } + + function makeGetter(name) { + return function () { + return this.isValid() ? this._data[name] : NaN; + }; + } + + var milliseconds = makeGetter('milliseconds'); + var seconds = makeGetter('seconds'); + var minutes = makeGetter('minutes'); + var hours = makeGetter('hours'); + var days = makeGetter('days'); + var months = makeGetter('months'); + var years = makeGetter('years'); + + function weeks () { + return absFloor(this.days() / 7); + } + + var round = Math.round; + var thresholds = { + ss: 44, // a few seconds to seconds + s : 45, // seconds to minute + m : 45, // minutes to hour + h : 22, // hours to day + d : 26, // days to month + M : 11 // months to year + }; + + // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize + function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) { + return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture); + } + + function relativeTime$1 (posNegDuration, withoutSuffix, locale) { + var duration = createDuration(posNegDuration).abs(); + var seconds = round(duration.as('s')); + var minutes = round(duration.as('m')); + var hours = round(duration.as('h')); + var days = round(duration.as('d')); + var months = round(duration.as('M')); + var years = round(duration.as('y')); + + var a = seconds <= thresholds.ss && ['s', seconds] || + seconds < thresholds.s && ['ss', seconds] || + minutes <= 1 && ['m'] || + minutes < thresholds.m && ['mm', minutes] || + hours <= 1 && ['h'] || + hours < thresholds.h && ['hh', hours] || + days <= 1 && ['d'] || + days < thresholds.d && ['dd', days] || + months <= 1 && ['M'] || + months < thresholds.M && ['MM', months] || + years <= 1 && ['y'] || ['yy', years]; + + a[2] = withoutSuffix; + a[3] = +posNegDuration > 0; + a[4] = locale; + return substituteTimeAgo.apply(null, a); + } + + // This function allows you to set the rounding function for relative time strings + function getSetRelativeTimeRounding (roundingFunction) { + if (roundingFunction === undefined) { + return round; + } + if (typeof(roundingFunction) === 'function') { + round = roundingFunction; + return true; + } + return false; + } + + // This function allows you to set a threshold for relative time strings + function getSetRelativeTimeThreshold (threshold, limit) { + if (thresholds[threshold] === undefined) { + return false; + } + if (limit === undefined) { + return thresholds[threshold]; + } + thresholds[threshold] = limit; + if (threshold === 's') { + thresholds.ss = limit - 1; + } + return true; + } + + function humanize (withSuffix) { + if (!this.isValid()) { + return this.localeData().invalidDate(); + } + + var locale = this.localeData(); + var output = relativeTime$1(this, !withSuffix, locale); + + if (withSuffix) { + output = locale.pastFuture(+this, output); + } + + return locale.postformat(output); + } + + var abs$1 = Math.abs; + + function sign(x) { + return ((x > 0) - (x < 0)) || +x; + } + + function toISOString$1() { + // for ISO strings we do not use the normal bubbling rules: + // * milliseconds bubble up until they become hours + // * days do not bubble at all + // * months bubble up until they become years + // This is because there is no context-free conversion between hours and days + // (think of clock changes) + // and also not between days and months (28-31 days per month) + if (!this.isValid()) { + return this.localeData().invalidDate(); + } + + var seconds = abs$1(this._milliseconds) / 1000; + var days = abs$1(this._days); + var months = abs$1(this._months); + var minutes, hours, years; + + // 3600 seconds -> 60 minutes -> 1 hour + minutes = absFloor(seconds / 60); + hours = absFloor(minutes / 60); + seconds %= 60; + minutes %= 60; + + // 12 months -> 1 year + years = absFloor(months / 12); + months %= 12; + + + // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js + var Y = years; + var M = months; + var D = days; + var h = hours; + var m = minutes; + var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : ''; + var total = this.asSeconds(); + + if (!total) { + // this is the same as C#'s (Noda) and python (isodate)... + // but not other JS (goog.date) + return 'P0D'; + } + + var totalSign = total < 0 ? '-' : ''; + var ymSign = sign(this._months) !== sign(total) ? '-' : ''; + var daysSign = sign(this._days) !== sign(total) ? '-' : ''; + var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : ''; + + return totalSign + 'P' + + (Y ? ymSign + Y + 'Y' : '') + + (M ? ymSign + M + 'M' : '') + + (D ? daysSign + D + 'D' : '') + + ((h || m || s) ? 'T' : '') + + (h ? hmsSign + h + 'H' : '') + + (m ? hmsSign + m + 'M' : '') + + (s ? hmsSign + s + 'S' : ''); + } + + var proto$2 = Duration.prototype; + + proto$2.isValid = isValid$1; + proto$2.abs = abs; + proto$2.add = add$1; + proto$2.subtract = subtract$1; + proto$2.as = as; + proto$2.asMilliseconds = asMilliseconds; + proto$2.asSeconds = asSeconds; + proto$2.asMinutes = asMinutes; + proto$2.asHours = asHours; + proto$2.asDays = asDays; + proto$2.asWeeks = asWeeks; + proto$2.asMonths = asMonths; + proto$2.asQuarters = asQuarters; + proto$2.asYears = asYears; + proto$2.valueOf = valueOf$1; + proto$2._bubble = bubble; + proto$2.clone = clone$1; + proto$2.get = get$2; + proto$2.milliseconds = milliseconds; + proto$2.seconds = seconds; + proto$2.minutes = minutes; + proto$2.hours = hours; + proto$2.days = days; + proto$2.weeks = weeks; + proto$2.months = months; + proto$2.years = years; + proto$2.humanize = humanize; + proto$2.toISOString = toISOString$1; + proto$2.toString = toISOString$1; + proto$2.toJSON = toISOString$1; + proto$2.locale = locale; + proto$2.localeData = localeData; + + proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1); + proto$2.lang = lang; + + // Side effect imports + + // FORMATTING + + addFormatToken('X', 0, 0, 'unix'); + addFormatToken('x', 0, 0, 'valueOf'); + + // PARSING + + addRegexToken('x', matchSigned); + addRegexToken('X', matchTimestamp); + addParseToken('X', function (input, array, config) { + config._d = new Date(parseFloat(input, 10) * 1000); + }); + addParseToken('x', function (input, array, config) { + config._d = new Date(toInt(input)); + }); + + // Side effect imports + + + hooks.version = '2.24.0'; + + setHookCallback(createLocal); + + hooks.fn = proto; + hooks.min = min; + hooks.max = max; + hooks.now = now; + hooks.utc = createUTC; + hooks.unix = createUnix; + hooks.months = listMonths; + hooks.isDate = isDate; + hooks.locale = getSetGlobalLocale; + hooks.invalid = createInvalid; + hooks.duration = createDuration; + hooks.isMoment = isMoment; + hooks.weekdays = listWeekdays; + hooks.parseZone = createInZone; + hooks.localeData = getLocale; + hooks.isDuration = isDuration; + hooks.monthsShort = listMonthsShort; + hooks.weekdaysMin = listWeekdaysMin; + hooks.defineLocale = defineLocale; + hooks.updateLocale = updateLocale; + hooks.locales = listLocales; + hooks.weekdaysShort = listWeekdaysShort; + hooks.normalizeUnits = normalizeUnits; + hooks.relativeTimeRounding = getSetRelativeTimeRounding; + hooks.relativeTimeThreshold = getSetRelativeTimeThreshold; + hooks.calendarFormat = getCalendarFormat; + hooks.prototype = proto; + + // currently HTML5 input type only supports 24-hour formats + hooks.HTML5_FMT = { + DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // + DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss', // + DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS', // + DATE: 'YYYY-MM-DD', // + TIME: 'HH:mm', // + TIME_SECONDS: 'HH:mm:ss', // + TIME_MS: 'HH:mm:ss.SSS', // + WEEK: 'GGGG-[W]WW', // + MONTH: 'YYYY-MM' // + }; + + return hooks; + +}))); +}); + +/** + * Tags a multiline string and return new one without line break characters and following spaces. + * + * @param {Array} strings Parts of the entire string without expressions. + * @param {...string} expressions Expressions converted to strings, which are added to the entire string. + * @returns {string} + */ + +function toSingleLine(strings) { + for (var _len = arguments.length, expressions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + expressions[_key - 1] = arguments[_key]; + } + + var result = arrayReduce(strings, function (previousValue, currentValue, index) { + var valueWithoutWhiteSpaces = currentValue.replace(/\r?\n\s*/g, ''); + var expressionForIndex = expressions[index] ? expressions[index] : ''; + return previousValue + valueWithoutWhiteSpaces + expressionForIndex; + }, ''); + return result.trim(); +} + +var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6; + +function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _typeof$3(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$3 = function _typeof(obj) { return typeof obj; }; } else { _typeof$3 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$3(obj); } +/** + * Converts any value to string. + * + * @param {*} value The value to stringify. + * @returns {string} + */ + +function stringify(value) { + var result; + + switch (_typeof$3(value)) { + case 'string': + case 'number': + result = "".concat(value); + break; + + case 'object': + result = value === null ? '' : value.toString(); + break; + + case 'undefined': + result = ''; + break; + + default: + result = value.toString(); + break; + } + + return result; +} +/** + * Checks if given variable is defined. + * + * @param {*} variable Variable to check. + * @returns {boolean} + */ + +function isDefined(variable) { + return typeof variable !== 'undefined'; +} +/** + * Checks if given variable is undefined. + * + * @param {*} variable Variable to check. + * @returns {boolean} + */ + +function isUndefined(variable) { + return typeof variable === 'undefined'; +} +/** + * Check if given variable is null, empty string or undefined. + * + * @param {*} variable Variable to check. + * @returns {boolean} + */ + +function isEmpty(variable) { + return variable === null || variable === '' || isUndefined(variable); +} +/** + * Check if given variable is a regular expression. + * + * @param {*} variable Variable to check. + * @returns {boolean} + */ + +function isRegExp(variable) { + return Object.prototype.toString.call(variable) === '[object RegExp]'; +} +/* eslint-disable */ + +var _m = '\x6C\x65\x6E\x67\x74\x68'; + +var _hd = function _hd(v) { + return parseInt(v, 16); +}; + +var _pi = function _pi(v) { + return parseInt(v, 10); +}; + +var _ss = function _ss(v, s, l) { + return v['\x73\x75\x62\x73\x74\x72'](s, l); +}; + +var _cp = function _cp(v) { + return v['\x63\x6F\x64\x65\x50\x6F\x69\x6E\x74\x41\x74'](0) - 65; +}; + +var _norm = function _norm(v) { + return "".concat(v).replace(/\-/g, ''); +}; + +var _extractTime = function _extractTime(v) { + return _hd(_ss(_norm(v), _hd('12'), _cp('\x46'))) / (_hd(_ss(_norm(v), _cp('\x42'), ~~![][_m])) || 9); +}; + +var _ignored = function _ignored() { + return typeof location !== 'undefined' && /^([a-z0-9\-]+\.)?\x68\x61\x6E\x64\x73\x6F\x6E\x74\x61\x62\x6C\x65\x2E\x63\x6F\x6D$/i.test(location.host); +}; + +var _notified = false; +var consoleMessages = { + invalid: function invalid() { + return toSingleLine(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n The license key for Handsontable is invalid. \n If you need any help, contact us at support@handsontable.com."], ["\n The license key for Handsontable is invalid.\\x20\n If you need any help, contact us at support@handsontable.com."]))); + }, + expired: function expired(_ref) { + var keyValidityDate = _ref.keyValidityDate, + hotVersion = _ref.hotVersion; + return toSingleLine(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n The license key for Handsontable expired on ", ", and is not valid for the installed \n version ", ". Renew your license key at handsontable.com or downgrade to a version released prior \n to ", ". If you need any help, contact us at sales@handsontable.com."], ["\n The license key for Handsontable expired on ", ", and is not valid for the installed\\x20\n version ", ". Renew your license key at handsontable.com or downgrade to a version released prior\\x20\n to ", ". If you need any help, contact us at sales@handsontable.com."])), keyValidityDate, hotVersion, keyValidityDate); + }, + missing: function missing() { + return toSingleLine(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n The license key for Handsontable is missing. Use your purchased key to activate the product. \n Alternatively, you can activate Handsontable to use for non-commercial purposes by \n passing the key: 'non-commercial-and-evaluation'. If you need any help, contact \n us at support@handsontable.com."], ["\n The license key for Handsontable is missing. Use your purchased key to activate the product.\\x20\n Alternatively, you can activate Handsontable to use for non-commercial purposes by\\x20\n passing the key: 'non-commercial-and-evaluation'. If you need any help, contact\\x20\n us at support@handsontable.com."]))); + }, + non_commercial: function non_commercial() { + return ''; + } +}; +var domMessages = { + invalid: function invalid() { + return toSingleLine(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n The license key for Handsontable is invalid. \n Read more on how to \n install it properly or contact us at support@handsontable.com."], ["\n The license key for Handsontable is invalid.\\x20\n Read more on how to\\x20\n install it properly or contact us at support@handsontable.com."]))); + }, + expired: function expired(_ref2) { + var keyValidityDate = _ref2.keyValidityDate, + hotVersion = _ref2.hotVersion; + return toSingleLine(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n The license key for Handsontable expired on ", ", and is not valid for the installed \n version ", ". Renew your \n license key or downgrade to a version released prior to ", ". If you need any \n help, contact us at sales@handsontable.com."], ["\n The license key for Handsontable expired on ", ", and is not valid for the installed\\x20\n version ", ". Renew your\\x20\n license key or downgrade to a version released prior to ", ". If you need any\\x20\n help, contact us at sales@handsontable.com."])), keyValidityDate, hotVersion, keyValidityDate); + }, + missing: function missing() { + return toSingleLine(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n The license key for Handsontable is missing. Use your purchased key to activate the product. \n Alternatively, you can activate Handsontable to use for non-commercial purposes by \n passing the key: 'non-commercial-and-evaluation'. \n Read more about it in \n the documentation or contact us at support@handsontable.com."], ["\n The license key for Handsontable is missing. Use your purchased key to activate the product.\\x20\n Alternatively, you can activate Handsontable to use for non-commercial purposes by\\x20\n passing the key: 'non-commercial-and-evaluation'.\\x20\n Read more about it in\\x20\n the documentation or contact us at support@handsontable.com."]))); + }, + non_commercial: function non_commercial() { + return ''; + } +}; +function _injectProductInfo(key, element) { + var hasValidType = !isEmpty(key); + var isNonCommercial = typeof key === 'string' && key.toLowerCase() === 'non-commercial-and-evaluation'; + var hotVersion = "8.3.1"; + var keyValidityDate; + var consoleMessageState = 'invalid'; + var domMessageState = 'invalid'; + key = _norm(key || ''); + + var schemaValidity = _checkKeySchema(key); + + if (hasValidType || isNonCommercial || schemaValidity) { + if (schemaValidity) { + var releaseDate = moment("10/02/2021", 'DD/MM/YYYY'); + var releaseDays = Math.floor(releaseDate.toDate().getTime() / 8.64e7); + + var keyValidityDays = _extractTime(key); + + keyValidityDate = moment((keyValidityDays + 1) * 8.64e7, 'x').format('MMMM DD, YYYY'); + + if (releaseDays > keyValidityDays) { + var daysAfterRelease = moment().diff(releaseDate, 'days'); + consoleMessageState = daysAfterRelease <= 1 ? 'valid' : 'expired'; + domMessageState = daysAfterRelease <= 15 ? 'valid' : 'expired'; + } else { + consoleMessageState = 'valid'; + domMessageState = 'valid'; + } + } else if (isNonCommercial) { + consoleMessageState = 'non_commercial'; + domMessageState = 'valid'; + } else { + consoleMessageState = 'invalid'; + domMessageState = 'invalid'; + } + } else { + consoleMessageState = 'missing'; + domMessageState = 'missing'; + } + + if (_ignored()) { + consoleMessageState = 'valid'; + domMessageState = 'valid'; + } + + if (!_notified && consoleMessageState !== 'valid') { + var message = consoleMessages[consoleMessageState]({ + keyValidityDate: keyValidityDate, + hotVersion: hotVersion + }); + + if (message) { + console[consoleMessageState === 'non_commercial' ? 'info' : 'warn'](consoleMessages[consoleMessageState]({ + keyValidityDate: keyValidityDate, + hotVersion: hotVersion + })); + } + + _notified = true; + } + + if (domMessageState !== 'valid' && element.parentNode) { + var _message = domMessages[domMessageState]({ + keyValidityDate: keyValidityDate, + hotVersion: hotVersion + }); + + if (_message) { + var messageNode = document.createElement('div'); + messageNode.id = 'hot-display-license-info'; + messageNode.innerHTML = domMessages[domMessageState]({ + keyValidityDate: keyValidityDate, + hotVersion: hotVersion + }); + element.parentNode.insertBefore(messageNode, element.nextSibling); + } + } +} + +function _checkKeySchema(v) { + var z = [][_m]; + var p = z; + + if (v[_m] !== _cp('\x5A')) { + return false; + } + + for (var c = '', i = '\x42\x3C\x48\x34\x50\x2B'.split(''), j = _cp(i.shift()); j; j = _cp(i.shift() || 'A')) { + --j < ''[_m] ? p = p | (_pi("".concat(_pi(_hd(c) + (_hd(_ss(v, Math.abs(j), 2)) + []).padStart(2, '0')))) % 97 || 2) >> 1 : c = _ss(v, j, !j ? 6 : i[_m] === 1 ? 9 : 8); + } + + return p === z; +} +/* eslint-enable */ + +var mixedHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + stringify: stringify, + isDefined: isDefined, + isUndefined: isUndefined, + isEmpty: isEmpty, + isRegExp: isRegExp, + _injectProductInfo: _injectProductInfo +}); + +/** + * Convert string to upper case first letter. + * + * @param {string} string String to convert. + * @returns {string} + */ + +function toUpperCaseFirst(string) { + return string[0].toUpperCase() + string.substr(1); +} +/** + * Compare strings case insensitively. + * + * @param {...string} strings Strings to compare. + * @returns {boolean} + */ + +function equalsIgnoreCase() { + var unique = []; + + for (var _len = arguments.length, strings = new Array(_len), _key = 0; _key < _len; _key++) { + strings[_key] = arguments[_key]; + } + + var length = strings.length; + + while (length) { + length -= 1; + var string = stringify(strings[length]).toLowerCase(); + + if (unique.indexOf(string) === -1) { + unique.push(string); + } + } + + return unique.length === 1; +} +/** + * Generates a random hex string. Used as namespace for Handsontable instance events. + * + * @returns {string} Returns 16-long character random string (eq. `'92b1bfc74ec4'`). + */ + +function randomString() { + /** + * @returns {string} + */ + function s4() { + return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1); + } + + return s4() + s4() + s4() + s4(); +} +/** + * Checks if value is valid percent. + * + * @param {string} value The value to check. + * @returns {boolean} + */ + +function isPercentValue(value) { + return /^([0-9][0-9]?%$)|(^100%$)/.test(value); +} +/** + * Substitute strings placed beetwen square brackets into value defined in `variables` object. String names defined in + * square brackets must be the same as property name of `variables` object. + * + * @param {string} template Template string. + * @param {object} variables Object which contains all available values which can be injected into template. + * @returns {string} + */ + +function substitute(template) { + var variables = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + return "".concat(template).replace(/(?:\\)?\[([^[\]]+)]/g, function (match, name) { + if (match.charAt(0) === '\\') { + return match.substr(1, match.length - 1); + } + + return variables[name] === void 0 ? '' : variables[name]; + }); +} +/** + * Strip any HTML tag from the string. + * + * @param {string} string String to cut HTML from. + * @returns {string} + */ + +function stripTags(string) { + return sanitize("".concat(string), { + ALLOWED_TAGS: [] + }); +} +/** + * Sanitizes string from potential security vulnerabilities. + * + * @param {string} string String to sanitize. + * @param {object} [options] DOMPurify's configuration object. + * @returns {string} + */ + +function sanitize(string, options) { + return purify_cjs.sanitize(string, options); +} + +var stringHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + toUpperCaseFirst: toUpperCaseFirst, + equalsIgnoreCase: equalsIgnoreCase, + randomString: randomString, + isPercentValue: isPercentValue, + substitute: substitute, + stripTags: stripTags, + sanitize: sanitize +}); + +function _toConsumableArray$2(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } + +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } +/** + * Get the parent of the specified node in the DOM tree. + * + * @param {HTMLElement} element Element from which traversing is started. + * @param {number} [level=0] Traversing deep level. + * @returns {HTMLElement|null} + */ + +function getParent(element) { + var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + var iteration = -1; + var parent = null; + var elementToCheck = element; + + while (elementToCheck !== null) { + if (iteration === level) { + parent = elementToCheck; + break; + } + + if (elementToCheck.host && elementToCheck.nodeType === Node.DOCUMENT_FRAGMENT_NODE) { + elementToCheck = elementToCheck.host; + } else { + iteration += 1; + elementToCheck = elementToCheck.parentNode; + } + } + + return parent; +} +/** + * Gets `frameElement` of the specified frame. Returns null if it is a top frame or if script has no access to read property. + * + * @param {Window} frame Frame from which should be get frameElement in safe way. + * @returns {HTMLIFrameElement|null} + */ + +function getFrameElement(frame) { + return Object.getPrototypeOf(frame.parent) && frame.frameElement; +} +/** + * Gets parent frame of the specified frame. Returns null if it is a top frame or if script has no access to read property. + * + * @param {Window} frame Frame from which should be get frameElement in safe way. + * @returns {Window|null} + */ + +function getParentWindow(frame) { + return getFrameElement(frame) && frame.parent; +} +/** + * Checks if script has access to read from parent frame of specified frame. + * + * @param {Window} frame Frame from which should be get frameElement in safe way. + * @returns {boolean} + */ + +function hasAccessToParentWindow(frame) { + return !!Object.getPrototypeOf(frame.parent); +} +/** + * Goes up the DOM tree (including given element) until it finds an parent element that matches the nodes or nodes name. + * This method goes up through web components. + * + * @param {Node} element Element from which traversing is started. + * @param {Array} [nodes] Array of elements or Array of elements name (in uppercase form). + * @param {Node} [until] The element until the traversing ends. + * @returns {Node|null} + */ + +function closest(element) { + var nodes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + var until = arguments.length > 2 ? arguments[2] : undefined; + var _Node = Node, + ELEMENT_NODE = _Node.ELEMENT_NODE, + DOCUMENT_FRAGMENT_NODE = _Node.DOCUMENT_FRAGMENT_NODE; + var elementToCheck = element; + + while (elementToCheck !== null && elementToCheck !== void 0 && elementToCheck !== until) { + var _elementToCheck = elementToCheck, + nodeType = _elementToCheck.nodeType, + nodeName = _elementToCheck.nodeName; + + if (nodeType === ELEMENT_NODE && (nodes.includes(nodeName) || nodes.includes(elementToCheck))) { + return elementToCheck; + } + + var _elementToCheck2 = elementToCheck, + host = _elementToCheck2.host; + + if (host && nodeType === DOCUMENT_FRAGMENT_NODE) { + elementToCheck = host; + } else { + elementToCheck = elementToCheck.parentNode; + } + } + + return null; +} +/** + * Goes "down" the DOM tree (including given element) until it finds an element that matches the nodes or nodes name. + * + * @param {HTMLElement} element Element from which traversing is started. + * @param {Array} nodes Array of elements or Array of elements name. + * @param {HTMLElement} [until] The list of elements until the traversing ends. + * @returns {HTMLElement|null} + */ + +function closestDown(element, nodes, until) { + var matched = []; + var elementToCheck = element; + + while (elementToCheck) { + elementToCheck = closest(elementToCheck, nodes, until); + + if (!elementToCheck || until && !until.contains(elementToCheck)) { + break; + } + + matched.push(elementToCheck); + + if (elementToCheck.host && elementToCheck.nodeType === Node.DOCUMENT_FRAGMENT_NODE) { + elementToCheck = elementToCheck.host; + } else { + elementToCheck = elementToCheck.parentNode; + } + } + + var length = matched.length; + return length ? matched[length - 1] : null; +} +/** + * Goes up the DOM tree and checks if element is child of another element. + * + * @param {HTMLElement} child Child element An element to check. + * @param {object|string} parent Parent element OR selector of the parent element. + * If string provided, function returns `true` for the first occurrence of element with that class. + * @returns {boolean} + */ + +function isChildOf(child, parent) { + var node = child.parentNode; + var queriedParents = []; + + if (typeof parent === 'string') { + if (child.defaultView) { + queriedParents = Array.prototype.slice.call(child.querySelectorAll(parent), 0); + } else { + queriedParents = Array.prototype.slice.call(child.ownerDocument.querySelectorAll(parent), 0); + } + } else { + queriedParents.push(parent); + } + + while (node !== null) { + if (queriedParents.indexOf(node) > -1) { + return true; + } + + node = node.parentNode; + } + + return false; +} +/** + * Counts index of element within its parent. + * WARNING: for performance reasons, assumes there are only element nodes (no text nodes). This is true + * for Walkotnable, otherwise would need to check for nodeType or use previousElementSibling. + * + * @see http://jsperf.com/sibling-index/10 + * @param {Element} element The element to check. + * @returns {number} + */ + +function index$1(element) { + var i = 0; + var elementToCheck = element; + + if (elementToCheck.previousSibling) { + /* eslint-disable no-cond-assign */ + while (elementToCheck = elementToCheck.previousSibling) { + i += 1; + } + } + + return i; +} +/** + * Check if the provided overlay contains the provided element. + * + * @param {string} overlayType The type of the overlay. + * @param {HTMLElement} element An element to check. + * @param {HTMLElement} root The root element. + * @returns {boolean} + */ + +function overlayContainsElement(overlayType, element, root) { + var overlayElement = root.parentElement.querySelector(".ht_clone_".concat(overlayType)); + return overlayElement ? overlayElement.contains(element) : null; +} + +var _hasClass; + +var _addClass; + +var _removeClass; +/** + * @param {string} classNames The element "class" attribute string. + * @returns {string[]} + */ + + +function filterEmptyClassNames(classNames) { + if (!classNames || !classNames.length) { + return []; + } + + return classNames.filter(function (x) { + return !!x; + }); +} + +if (isClassListSupported()) { + var isSupportMultipleClassesArg = function isSupportMultipleClassesArg(rootDocument) { + var element = rootDocument.createElement('div'); + element.classList.add('test', 'test2'); + return element.classList.contains('test2'); + }; + + _hasClass = function _hasClass(element, className) { + if (element.classList === void 0 || typeof className !== 'string' || className === '') { + return false; + } + + return element.classList.contains(className); + }; + + _addClass = function _addClass(element, classes) { + var rootDocument = element.ownerDocument; + var className = classes; + + if (typeof className === 'string') { + className = className.split(' '); + } + + className = filterEmptyClassNames(className); + + if (className.length > 0) { + if (isSupportMultipleClassesArg(rootDocument)) { + var _element$classList; + + (_element$classList = element.classList).add.apply(_element$classList, _toConsumableArray$2(className)); + } else { + var len = 0; + + while (className && className[len]) { + element.classList.add(className[len]); + len += 1; + } + } + } + }; + + _removeClass = function _removeClass(element, classes) { + var rootDocument = element.ownerDocument; + var className = classes; + + if (typeof className === 'string') { + className = className.split(' '); + } + + className = filterEmptyClassNames(className); + + if (className.length > 0) { + if (isSupportMultipleClassesArg(rootDocument)) { + var _element$classList2; + + (_element$classList2 = element.classList).remove.apply(_element$classList2, _toConsumableArray$2(className)); + } else { + var len = 0; + + while (className && className[len]) { + element.classList.remove(className[len]); + len += 1; + } + } + } + }; +} else { + var createClassNameRegExp = function createClassNameRegExp(className) { + return new RegExp("(\\s|^)".concat(className, "(\\s|$)")); + }; + + _hasClass = function _hasClass(element, className) { + // http://snipplr.com/view/3561/addclass-removeclass-hasclass/ + return element.className !== void 0 && createClassNameRegExp(className).test(element.className); + }; + + _addClass = function _addClass(element, classes) { + var _className = element.className; + var className = classes; + + if (typeof className === 'string') { + className = className.split(' '); + } + + className = filterEmptyClassNames(className); + + if (_className === '') { + _className = className.join(' '); + } else { + for (var len = 0; len < className.length; len++) { + if (className[len] && !createClassNameRegExp(className[len]).test(_className)) { + _className += " ".concat(className[len]); + } + } + } + + element.className = _className; + }; + + _removeClass = function _removeClass(element, classes) { + var len = 0; + var _className = element.className; + var className = classes; + + if (typeof className === 'string') { + className = className.split(' '); + } + + className = filterEmptyClassNames(className); + + while (className && className[len]) { + // String.prototype.trim is defined in polyfill.js + _className = _className.replace(createClassNameRegExp(className[len]), ' ').trim(); + len += 1; + } + + if (element.className !== _className) { + element.className = _className; + } + }; +} +/** + * Checks if element has class name. + * + * @param {HTMLElement} element An element to check. + * @param {string} className Class name to check. + * @returns {boolean} + */ + + +function hasClass(element, className) { + return _hasClass(element, className); +} +/** + * Add class name to an element. + * + * @param {HTMLElement} element An element to process. + * @param {string|Array} className Class name as string or array of strings. + */ + +function addClass(element, className) { + _addClass(element, className); +} +/** + * Remove class name from an element. + * + * @param {HTMLElement} element An element to process. + * @param {string|Array} className Class name as string or array of strings. + */ + +function removeClass(element, className) { + _removeClass(element, className); +} +/** + * @param {HTMLElement} element An element from the text is removed. + */ + +function removeTextNodes(element) { + if (element.nodeType === 3) { + element.parentNode.removeChild(element); // bye text nodes! + } else if (['TABLE', 'THEAD', 'TBODY', 'TFOOT', 'TR'].indexOf(element.nodeName) > -1) { + var childs = element.childNodes; + + for (var i = childs.length - 1; i >= 0; i--) { + removeTextNodes(childs[i]); + } + } +} +/** + * Remove childs function + * WARNING - this doesn't unload events and data attached by jQuery + * http://jsperf.com/jquery-html-vs-empty-vs-innerhtml/9 + * http://jsperf.com/jquery-html-vs-empty-vs-innerhtml/11 - no siginificant improvement with Chrome remove() method. + * + * @param {HTMLElement} element An element to clear. + */ + +function empty(element) { + var child; + /* eslint-disable no-cond-assign */ + + while (child = element.lastChild) { + element.removeChild(child); + } +} +var HTML_CHARACTERS = /(<(.*)>|&(.*);)/; +/** + * Insert content into element trying avoid innerHTML method. + * + * @param {HTMLElement} element An element to write into. + * @param {string} content The text to write. + * @param {boolean} [sanitizeContent=true] If `true`, the content will be sanitized before writing to the element. + */ + +function fastInnerHTML(element, content) { + var sanitizeContent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + + if (HTML_CHARACTERS.test(content)) { + element.innerHTML = sanitizeContent ? sanitize(content) : content; + } else { + fastInnerText(element, content); + } +} +/** + * Insert text content into element. + * + * @param {HTMLElement} element An element to write into. + * @param {string} content The text to write. + */ + +function fastInnerText(element, content) { + var child = element.firstChild; + + if (child && child.nodeType === 3 && child.nextSibling === null) { + // fast lane - replace existing text node + if (isTextContentSupported) { + // http://jsperf.com/replace-text-vs-reuse + child.textContent = content; + } else { + // http://jsperf.com/replace-text-vs-reuse + child.data = content; + } + } else { + // slow lane - empty element and insert a text node + empty(element); + element.appendChild(element.ownerDocument.createTextNode(content)); + } +} +/** + * Returns true if element is attached to the DOM and visible, false otherwise. + * + * @param {HTMLElement} element An element to check. + * @returns {boolean} + */ + +function isVisible(element) { + var documentElement = element.ownerDocument.documentElement; + var next = element; + + while (next !== documentElement) { + // until reached + if (next === null) { + // parent detached from DOM + return false; + } else if (next.nodeType === Node.DOCUMENT_FRAGMENT_NODE) { + if (next.host) { + // this is Web Components Shadow DOM + // see: http://w3c.github.io/webcomponents/spec/shadow/#encapsulation + // according to spec, should be if (next.ownerDocument !== window.document), but that doesn't work yet + if (next.host.impl) { + // Chrome 33.0.1723.0 canary (2013-11-29) Web Platform features disabled + return isVisible(next.host.impl); + } else if (next.host) { + // Chrome 33.0.1723.0 canary (2013-11-29) Web Platform features enabled + return isVisible(next.host); + } + + throw new Error('Lost in Web Components world'); + } else { + return false; // this is a node detached from document in IE8 + } + } else if (next.style && next.style.display === 'none') { + return false; + } + + next = next.parentNode; + } + + return true; +} +/** + * Returns elements top and left offset relative to the document. Function is not compatible with jQuery offset. + * + * @param {HTMLElement} element An element to get the offset position from. + * @returns {object} Returns object with `top` and `left` props. + */ + +function offset(element) { + var rootDocument = element.ownerDocument; + var rootWindow = rootDocument.defaultView; + var documentElement = rootDocument.documentElement; + var elementToCheck = element; + var offsetLeft; + var offsetTop; + var lastElem; + var box; + + if (hasCaptionProblem() && elementToCheck.firstChild && elementToCheck.firstChild.nodeName === 'CAPTION') { + // fixes problem with Firefox ignoring in TABLE offset (see also export outerHeight) + // http://jsperf.com/offset-vs-getboundingclientrect/8 + box = elementToCheck.getBoundingClientRect(); + return { + top: box.top + (rootWindow.pageYOffset || documentElement.scrollTop) - (documentElement.clientTop || 0), + left: box.left + (rootWindow.pageXOffset || documentElement.scrollLeft) - (documentElement.clientLeft || 0) + }; + } + + offsetLeft = elementToCheck.offsetLeft; + offsetTop = elementToCheck.offsetTop; + lastElem = elementToCheck; + /* eslint-disable no-cond-assign */ + + while (elementToCheck = elementToCheck.offsetParent) { + // from my observation, document.body always has scrollLeft/scrollTop == 0 + if (elementToCheck === rootDocument.body) { + break; + } + + offsetLeft += elementToCheck.offsetLeft; + offsetTop += elementToCheck.offsetTop; + lastElem = elementToCheck; + } // slow - http://jsperf.com/offset-vs-getboundingclientrect/6 + + + if (lastElem && lastElem.style.position === 'fixed') { + // if(lastElem !== document.body) { //faster but does gives false positive in Firefox + offsetLeft += rootWindow.pageXOffset || documentElement.scrollLeft; + offsetTop += rootWindow.pageYOffset || documentElement.scrollTop; + } + + return { + left: offsetLeft, + top: offsetTop + }; +} +/** + * Returns the document's scrollTop property. + * + * @param {Window} [rootWindow] The document window owner. + * @returns {number} + */ +// eslint-disable-next-line no-restricted-globals + +function getWindowScrollTop() { + var rootWindow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window; + var res = rootWindow.scrollY; + + if (res === void 0) { + // IE8-11 + res = rootWindow.document.documentElement.scrollTop; + } + + return res; +} +/** + * Returns the document's scrollLeft property. + * + * @param {Window} [rootWindow] The document window owner. + * @returns {number} + */ +// eslint-disable-next-line no-restricted-globals + +function getWindowScrollLeft() { + var rootWindow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window; + var res = rootWindow.scrollX; + + if (res === void 0) { + // IE8-11 + res = rootWindow.document.documentElement.scrollLeft; + } + + return res; +} +/** + * Returns the provided element's scrollTop property. + * + * @param {HTMLElement} element An element to get the scroll top position from. + * @param {Window} [rootWindow] The document window owner. + * @returns {number} + */ +// eslint-disable-next-line no-restricted-globals + +function getScrollTop(element) { + var rootWindow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window; + + if (element === rootWindow) { + return getWindowScrollTop(rootWindow); + } + + return element.scrollTop; +} +/** + * Returns the provided element's scrollLeft property. + * + * @param {HTMLElement} element An element to get the scroll left position from. + * @param {Window} [rootWindow] The document window owner. + * @returns {number} + */ +// eslint-disable-next-line no-restricted-globals + +function getScrollLeft(element) { + var rootWindow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window; + + if (element === rootWindow) { + return getWindowScrollLeft(rootWindow); + } + + return element.scrollLeft; +} +/** + * Returns a DOM element responsible for scrolling of the provided element. + * + * @param {HTMLElement} element An element to get the scrollable element from. + * @returns {HTMLElement} Element's scrollable parent. + */ + +function getScrollableElement(element) { + var rootDocument = element.ownerDocument; + var rootWindow = rootDocument ? rootDocument.defaultView : void 0; + + if (!rootDocument) { + rootDocument = element.document ? element.document : element; + rootWindow = rootDocument.defaultView; + } + + var props = ['auto', 'scroll']; + var supportedGetComputedStyle = isGetComputedStyleSupported(); + var el = element.parentNode; + + while (el && el.style && rootDocument.body !== el) { + var _el$style = el.style, + overflow = _el$style.overflow, + overflowX = _el$style.overflowX, + overflowY = _el$style.overflowY; + + if ([overflow, overflowX, overflowY].includes('scroll')) { + return el; + } else if (supportedGetComputedStyle) { + var _rootWindow$getComput = rootWindow.getComputedStyle(el); + + overflow = _rootWindow$getComput.overflow; + overflowX = _rootWindow$getComput.overflowX; + overflowY = _rootWindow$getComput.overflowY; + + if (props.includes(overflow) || props.includes(overflowX) || props.includes(overflowY)) { + return el; + } + } // The '+ 1' after the scrollHeight/scrollWidth is to prevent problems with zoomed out Chrome. + + + if (el.clientHeight <= el.scrollHeight + 1 && (props.includes(overflowY) || props.includes(overflow))) { + return el; + } + + if (el.clientWidth <= el.scrollWidth + 1 && (props.includes(overflowX) || props.includes(overflow))) { + return el; + } + + el = el.parentNode; + } + + return rootWindow; +} +/** + * Returns a DOM element responsible for trimming the provided element. + * + * @param {HTMLElement} base Base element. + * @returns {HTMLElement} Base element's trimming parent. + */ + +function getTrimmingContainer(base) { + var rootDocument = base.ownerDocument; + var rootWindow = rootDocument.defaultView; + var el = base.parentNode; + + while (el && el.style && rootDocument.body !== el) { + if (el.style.overflow !== 'visible' && el.style.overflow !== '') { + return el; + } + + var computedStyle = getComputedStyle(el, rootWindow); + var allowedProperties = ['scroll', 'hidden', 'auto']; + var property = computedStyle.getPropertyValue('overflow'); + var propertyY = computedStyle.getPropertyValue('overflow-y'); + var propertyX = computedStyle.getPropertyValue('overflow-x'); + + if (allowedProperties.includes(property) || allowedProperties.includes(propertyY) || allowedProperties.includes(propertyX)) { + return el; + } + + el = el.parentNode; + } + + return rootWindow; +} +/** + * Returns a style property for the provided element. (Be it an inline or external style). + * + * @param {HTMLElement} element An element to get the style from. + * @param {string} prop Wanted property. + * @param {Window} [rootWindow] The document window owner. + * @returns {string|undefined} Element's style property. + */ +// eslint-disable-next-line no-restricted-globals + +function getStyle(element, prop) { + var rootWindow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : window; + + if (!element) { + return; + } else if (element === rootWindow) { + if (prop === 'width') { + return "".concat(rootWindow.innerWidth, "px"); + } else if (prop === 'height') { + return "".concat(rootWindow.innerHeight, "px"); + } + + return; + } + + var styleProp = element.style[prop]; + + if (styleProp !== '' && styleProp !== void 0) { + return styleProp; + } + + var computedStyle = getComputedStyle(element, rootWindow); + + if (computedStyle[prop] !== '' && computedStyle[prop] !== void 0) { + return computedStyle[prop]; + } +} +/** + * Verifies if element fit to provided CSSRule. + * + * @param {Element} element Element to verify with selector text. + * @param {CSSRule} rule Selector text from CSSRule. + * @returns {boolean} + */ + +function matchesCSSRules(element, rule) { + var selectorText = rule.selectorText; + var result = false; + + if (rule.type === CSSRule.STYLE_RULE && selectorText) { + if (element.msMatchesSelector) { + result = element.msMatchesSelector(selectorText); + } else if (element.matches) { + result = element.matches(selectorText); + } + } + + return result; +} +/** + * Returns a computed style object for the provided element. (Needed if style is declared in external stylesheet). + * + * @param {HTMLElement} element An element to get style from. + * @param {Window} [rootWindow] The document window owner. + * @returns {IEElementStyle|CssStyle} Elements computed style object. + */ +// eslint-disable-next-line no-restricted-globals + +function getComputedStyle(element) { + var rootWindow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window; + return element.currentStyle || rootWindow.getComputedStyle(element); +} +/** + * Returns the element's outer width. + * + * @param {HTMLElement} element An element to get the width from. + * @returns {number} Element's outer width. + */ + +function outerWidth(element) { + return Math.ceil(element.getBoundingClientRect().width); +} +/** + * Returns the element's outer height. + * + * @param {HTMLElement} element An element to get the height from. + * @returns {number} Element's outer height. + */ + +function outerHeight(element) { + if (hasCaptionProblem() && element.firstChild && element.firstChild.nodeName === 'CAPTION') { + // fixes problem with Firefox ignoring in TABLE.offsetHeight + // jQuery (1.10.1) still has this unsolved + // may be better to just switch to getBoundingClientRect + // http://bililite.com/blog/2009/03/27/finding-the-size-of-a-table/ + // http://lists.w3.org/Archives/Public/www-style/2009Oct/0089.html + // http://bugs.jquery.com/ticket/2196 + // http://lists.w3.org/Archives/Public/www-style/2009Oct/0140.html#start140 + return element.offsetHeight + element.firstChild.offsetHeight; + } + + return element.offsetHeight; +} +/** + * Returns the element's inner height. + * + * @param {HTMLElement} element An element to get the height from. + * @returns {number} Element's inner height. + */ + +function innerHeight(element) { + return element.clientHeight || element.innerHeight; +} +/** + * Returns the element's inner width. + * + * @param {HTMLElement} element An element to get the width from. + * @returns {number} Element's inner width. + */ + +function innerWidth(element) { + return element.clientWidth || element.innerWidth; +} +/** + * @param {HTMLElement} element An element to which the event is added. + * @param {string} event The event name. + * @param {Function} callback The callback to add. + */ + +function addEvent(element, event, callback) { + element.addEventListener(event, callback, false); +} +/** + * @param {HTMLElement} element An element from which the event is removed. + * @param {string} event The event name. + * @param {Function} callback The function reference to remove. + */ + +function removeEvent(element, event, callback) { + element.removeEventListener(event, callback, false); +} +/** + * Returns caret position in text input. + * + * @author https://stackoverflow.com/questions/263743/how-to-get-caret-position-in-textarea + * @param {HTMLElement} el An element to check. + * @returns {number} + */ + +function getCaretPosition(el) { + var rootDocument = el.ownerDocument; + + if (el.selectionStart) { + return el.selectionStart; + } else if (rootDocument.selection) { + // IE8 + el.focus(); + var r = rootDocument.selection.createRange(); + + if (r === null) { + return 0; + } + + var re = el.createTextRange(); + var rc = re.duplicate(); + re.moveToBookmark(r.getBookmark()); + rc.setEndPoint('EndToStart', re); + return rc.text.length; + } + + return 0; +} +/** + * Returns end of the selection in text input. + * + * @param {HTMLElement} el An element to check. + * @returns {number} + */ + +function getSelectionEndPosition(el) { + var rootDocument = el.ownerDocument; + + if (el.selectionEnd) { + return el.selectionEnd; + } else if (rootDocument.selection) { + // IE8 + var r = rootDocument.selection.createRange(); + + if (r === null) { + return 0; + } + + var re = el.createTextRange(); + return re.text.indexOf(r.text) + r.text.length; + } + + return 0; +} +/** + * Returns text under selection. + * + * @param {Window} [rootWindow] The document window owner. + * @returns {string} + */ +// eslint-disable-next-line no-restricted-globals + +function getSelectionText() { + var rootWindow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window; + var rootDocument = rootWindow.document; + var text = ''; + + if (rootWindow.getSelection) { + text = rootWindow.getSelection().toString(); + } else if (rootDocument.selection && rootDocument.selection.type !== 'Control') { + text = rootDocument.selection.createRange().text; + } + + return text; +} +/** + * Cross-platform helper to clear text selection. + * + * @param {Window} [rootWindow] The document window owner. + */ +// eslint-disable-next-line no-restricted-globals + +function clearTextSelection() { + var rootWindow = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window; + var rootDocument = rootWindow.document; // http://stackoverflow.com/questions/3169786/clear-text-selection-with-javascript + + if (rootWindow.getSelection) { + if (rootWindow.getSelection().empty) { + // Chrome + rootWindow.getSelection().empty(); + } else if (rootWindow.getSelection().removeAllRanges) { + // Firefox + rootWindow.getSelection().removeAllRanges(); + } + } else if (rootDocument.selection) { + // IE? + rootDocument.selection.empty(); + } +} +/** + * Sets caret position in text input. + * + * @author http://blog.vishalon.net/index.php/javascript-getting-and-setting-caret-position-in-textarea/ + * @param {Element} element An element to process. + * @param {number} pos The selection start position. + * @param {number} endPos The selection end position. + */ + +function setCaretPosition(element, pos, endPos) { + if (endPos === void 0) { + endPos = pos; + } + + if (element.setSelectionRange) { + element.focus(); + + try { + element.setSelectionRange(pos, endPos); + } catch (err) { + var elementParent = element.parentNode; + var parentDisplayValue = elementParent.style.display; + elementParent.style.display = 'block'; + element.setSelectionRange(pos, endPos); + elementParent.style.display = parentDisplayValue; + } + } +} +var cachedScrollbarWidth; +/** + * Helper to calculate scrollbar width. + * Source: https://stackoverflow.com/questions/986937/how-can-i-get-the-browsers-scrollbar-sizes. + * + * @private + * @param {Document} rootDocument The onwer of the document. + * @returns {number} + */ +// eslint-disable-next-line no-restricted-globals + +function walkontableCalculateScrollbarWidth() { + var rootDocument = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; + var inner = rootDocument.createElement('div'); + inner.style.height = '200px'; + inner.style.width = '100%'; + var outer = rootDocument.createElement('div'); + outer.style.boxSizing = 'content-box'; + outer.style.height = '150px'; + outer.style.left = '0px'; + outer.style.overflow = 'hidden'; + outer.style.position = 'absolute'; + outer.style.top = '0px'; + outer.style.width = '200px'; + outer.style.visibility = 'hidden'; + outer.appendChild(inner); + (rootDocument.body || rootDocument.documentElement).appendChild(outer); + var w1 = inner.offsetWidth; + outer.style.overflow = 'scroll'; + var w2 = inner.offsetWidth; + + if (w1 === w2) { + w2 = outer.clientWidth; + } + + (rootDocument.body || rootDocument.documentElement).removeChild(outer); + return w1 - w2; +} +/** + * Returns the computed width of the native browser scroll bar. + * + * @param {Document} [rootDocument] The owner of the document. + * @returns {number} Width. + */ +// eslint-disable-next-line no-restricted-globals + + +function getScrollbarWidth() { + var rootDocument = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document; + + if (cachedScrollbarWidth === void 0) { + cachedScrollbarWidth = walkontableCalculateScrollbarWidth(rootDocument); + } + + return cachedScrollbarWidth; +} +/** + * Checks if the provided element has a vertical scrollbar. + * + * @param {HTMLElement} element An element to check. + * @returns {boolean} + */ + +function hasVerticalScrollbar(element) { + return element.offsetWidth !== element.clientWidth; +} +/** + * Checks if the provided element has a vertical scrollbar. + * + * @param {HTMLElement} element An element to check. + * @returns {boolean} + */ + +function hasHorizontalScrollbar(element) { + return element.offsetHeight !== element.clientHeight; +} +/** + * Sets overlay position depending on it's type and used browser. + * + * @param {HTMLElement} overlayElem An element to process. + * @param {number} left The left position of the overlay. + * @param {number} top The top position of the overlay. + */ + +function setOverlayPosition(overlayElem, left, top) { + if (isIE9()) { + overlayElem.style.top = top; + overlayElem.style.left = left; + } else if (isSafari()) { + overlayElem.style['-webkit-transform'] = "translate3d(".concat(left, ",").concat(top, ",0)"); + overlayElem.style['-webkit-transform'] = "translate3d(".concat(left, ",").concat(top, ",0)"); + } else { + overlayElem.style.transform = "translate3d(".concat(left, ",").concat(top, ",0)"); + } +} +/** + * @param {HTMLElement} element An element to process. + * @returns {number|Array} + */ + +function getCssTransform(element) { + var transform; + + if (element.style.transform && (transform = element.style.transform) !== '') { + return ['transform', transform]; + } else if (element.style['-webkit-transform'] && (transform = element.style['-webkit-transform']) !== '') { + return ['-webkit-transform', transform]; + } + + return -1; +} +/** + * @param {HTMLElement} element An element to process. + */ + +function resetCssTransform(element) { + if (element.style.transform && element.style.transform !== '') { + element.style.transform = ''; + } else if (element.style['-webkit-transform'] && element.style['-webkit-transform'] !== '') { + element.style['-webkit-transform'] = ''; + } +} +/** + * Determines if the given DOM element is an input field. + * Notice: By 'input' we mean input, textarea and select nodes. + * + * @param {HTMLElement} element - DOM element. + * @returns {boolean} + */ + +function isInput(element) { + var inputs = ['INPUT', 'SELECT', 'TEXTAREA']; + return element && (inputs.indexOf(element.nodeName) > -1 || element.contentEditable === 'true'); +} +/** + * Determines if the given DOM element is an input field placed OUTSIDE of HOT. + * Notice: By 'input' we mean input, textarea and select nodes which have defined 'data-hot-input' attribute. + * + * @param {HTMLElement} element - DOM element. + * @returns {boolean} + */ + +function isOutsideInput(element) { + return isInput(element) && element.hasAttribute('data-hot-input') === false; +} +/** + * Check if the given DOM element can be focused (by using "select" method). + * + * @param {HTMLElement} element - DOM element. + */ + +function selectElementIfAllowed(element) { + var activeElement = element.ownerDocument.activeElement; + + if (!isOutsideInput(activeElement)) { + element.select(); + } +} +/** + * Check if the provided element is detached from DOM. + * + * @param {HTMLElement} element HTML element to be checked. + * @returns {boolean} `true` if the element is detached, `false` otherwise. + */ + +function isDetached(element) { + return !element.parentNode; +} + +var domHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + getParent: getParent, + getFrameElement: getFrameElement, + getParentWindow: getParentWindow, + hasAccessToParentWindow: hasAccessToParentWindow, + closest: closest, + closestDown: closestDown, + isChildOf: isChildOf, + index: index$1, + overlayContainsElement: overlayContainsElement, + hasClass: hasClass, + addClass: addClass, + removeClass: removeClass, + removeTextNodes: removeTextNodes, + empty: empty, + HTML_CHARACTERS: HTML_CHARACTERS, + fastInnerHTML: fastInnerHTML, + fastInnerText: fastInnerText, + isVisible: isVisible, + offset: offset, + getWindowScrollTop: getWindowScrollTop, + getWindowScrollLeft: getWindowScrollLeft, + getScrollTop: getScrollTop, + getScrollLeft: getScrollLeft, + getScrollableElement: getScrollableElement, + getTrimmingContainer: getTrimmingContainer, + getStyle: getStyle, + matchesCSSRules: matchesCSSRules, + getComputedStyle: getComputedStyle, + outerWidth: outerWidth, + outerHeight: outerHeight, + innerHeight: innerHeight, + innerWidth: innerWidth, + addEvent: addEvent, + removeEvent: removeEvent, + getCaretPosition: getCaretPosition, + getSelectionEndPosition: getSelectionEndPosition, + getSelectionText: getSelectionText, + clearTextSelection: clearTextSelection, + setCaretPosition: setCaretPosition, + getScrollbarWidth: getScrollbarWidth, + hasVerticalScrollbar: hasVerticalScrollbar, + hasHorizontalScrollbar: hasHorizontalScrollbar, + setOverlayPosition: setOverlayPosition, + getCssTransform: getCssTransform, + resetCssTransform: resetCssTransform, + isInput: isInput, + isOutsideInput: isOutsideInput, + selectElementIfAllowed: selectElementIfAllowed, + isDetached: isDetached +}); + +/** + * Checks if given variable is function. + * + * @param {*} func Variable to check. + * @returns {boolean} + */ + +function isFunction(func) { + return typeof func === 'function'; +} +/** + * Creates throttle function that enforces a maximum number of times a function (`func`) can be called over time (`wait`). + * + * @param {Function} func Function to invoke. + * @param {number} wait Delay in miliseconds. + * @returns {Function} + */ + +function throttle(func) { + var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200; + var lastCalled = 0; + var result = { + lastCallThrottled: true + }; + var lastTimer = null; + /** + * @param {...*} args The list of arguments passed during the function invocation. + * @returns {object} + */ + + function _throttle() { + var _this = this; + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + var stamp = Date.now(); + var needCall = false; + result.lastCallThrottled = true; + + if (!lastCalled) { + lastCalled = stamp; + needCall = true; + } + + var remaining = wait - (stamp - lastCalled); + + if (needCall) { + result.lastCallThrottled = false; + func.apply(this, args); + } else { + if (lastTimer) { + clearTimeout(lastTimer); + } + + lastTimer = setTimeout(function () { + result.lastCallThrottled = false; + func.apply(_this, args); + lastCalled = 0; + lastTimer = void 0; + }, remaining); + } + + return result; + } + + return _throttle; +} +/** + * Creates throttle function that enforces a maximum number of times a function (`func`) can be called over + * time (`wait`) after specified hits. + * + * @param {Function} func Function to invoke. + * @param {number} wait Delay in miliseconds. + * @param {number} hits Number of hits after throttling will be applied. + * @returns {Function} + */ + +function throttleAfterHits(func) { + var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200; + var hits = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10; + var funcThrottle = throttle(func, wait); + var remainHits = hits; + /** + * + */ + + function _clearHits() { + remainHits = hits; + } + /** + * @param {*} args The list of arguments passed during the function invocation. + * @returns {*} + */ + + + function _throttleAfterHits() { + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + if (remainHits) { + remainHits -= 1; + return func.apply(this, args); + } + + return funcThrottle.apply(this, args); + } + + _throttleAfterHits.clearHits = _clearHits; + return _throttleAfterHits; +} +/** + * Creates debounce function that enforces a function (`func`) not be called again until a certain amount of time (`wait`) + * has passed without it being called. + * + * @param {Function} func Function to invoke. + * @param {number} wait Delay in milliseconds. + * @returns {Function} + */ + +function debounce(func) { + var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200; + var lastTimer = null; + var result; + /** + * @param {*} args The list of arguments passed during the function invocation. + * @returns {*} + */ + + function _debounce() { + var _this2 = this; + + for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments[_key3]; + } + + if (lastTimer) { + clearTimeout(lastTimer); + } + + lastTimer = setTimeout(function () { + result = func.apply(_this2, args); + }, wait); + return result; + } + + return _debounce; +} +/** + * Creates the function that returns the result of calling the given functions. Result of the first function is passed to + * the second as an argument and so on. Only first function in the chain can handle multiple arguments. + * + * @param {Function} functions Functions to compose. + * @returns {Function} + */ + +function pipe() { + for (var _len4 = arguments.length, functions = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { + functions[_key4] = arguments[_key4]; + } + + var firstFunc = functions[0], + restFunc = functions.slice(1); + return function _pipe() { + for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { + args[_key5] = arguments[_key5]; + } + + return arrayReduce(restFunc, function (acc, fn) { + return fn(acc); + }, firstFunc.apply(this, args)); + }; +} +/** + * Creates the function that returns the function with cached arguments. + * + * @param {Function} func Function to partialization. + * @param {Array} params Function arguments to cache. + * @returns {Function} + */ + +function partial(func) { + for (var _len6 = arguments.length, params = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) { + params[_key6 - 1] = arguments[_key6]; + } + + return function _partial() { + for (var _len7 = arguments.length, restParams = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) { + restParams[_key7] = arguments[_key7]; + } + + return func.apply(this, params.concat(restParams)); + }; +} +/** + * Creates the functions that returns the function with cached arguments. If count if passed arguments will be matched + * to the arguments defined in `func` then function will be invoked. + * Arguments are added to the stack in direction from the left to the right. + * + * @example + * ``` + * var replace = curry(function(find, replace, string) { + * return string.replace(find, replace); + * }); + * + * // returns function with bounded first argument + * var replace = replace('foo') + * + * // returns replaced string - all arguments was passed so function was invoked + * replace('bar', 'Some test with foo...'); + * + * ``` + * + * @param {Function} func Function to currying. + * @returns {Function} + */ + +function curry(func) { + var argsLength = func.length; + /** + * @param {*} argsSoFar The list of arguments passed during the function invocation. + * @returns {Function} + */ + + function given(argsSoFar) { + return function _curry() { + for (var _len8 = arguments.length, params = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) { + params[_key8] = arguments[_key8]; + } + + var passedArgsSoFar = argsSoFar.concat(params); + var result; + + if (passedArgsSoFar.length >= argsLength) { + result = func.apply(this, passedArgsSoFar); + } else { + result = given(passedArgsSoFar); + } + + return result; + }; + } + + return given([]); +} +/** + * Creates the functions that returns the function with cached arguments. If count if passed arguments will be matched + * to the arguments defined in `func` then function will be invoked. + * Arguments are added to the stack in direction from the right to the left. + * + * @example + * ``` + * var replace = curry(function(find, replace, string) { + * return string.replace(find, replace); + * }); + * + * // returns function with bounded first argument + * var replace = replace('Some test with foo...') + * + * // returns replaced string - all arguments was passed so function was invoked + * replace('bar', 'foo'); + * + * ``` + * + * @param {Function} func Function to currying. + * @returns {Function} + */ + +function curryRight(func) { + var argsLength = func.length; + /** + * @param {*} argsSoFar The list of arguments passed during the function invocation. + * @returns {Function} + */ + + function given(argsSoFar) { + return function _curry() { + for (var _len9 = arguments.length, params = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) { + params[_key9] = arguments[_key9]; + } + + var passedArgsSoFar = argsSoFar.concat(params.reverse()); + var result; + + if (passedArgsSoFar.length >= argsLength) { + result = func.apply(this, passedArgsSoFar); + } else { + result = given(passedArgsSoFar); + } + + return result; + }; + } + + return given([]); +} + +var functionHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + isFunction: isFunction, + throttle: throttle, + throttleAfterHits: throttleAfterHits, + debounce: debounce, + pipe: pipe, + partial: partial, + curry: curry, + curryRight: curryRight +}); + +var getWeakData = internalMetadata.getWeakData; + + + + + + + + +var setInternalState$5 = internalState.set; +var internalStateGetterFor$1 = internalState.getterFor; +var find = arrayIteration.find; +var findIndex = arrayIteration.findIndex; +var id$1 = 0; + +// fallback for uncaught frozen keys +var uncaughtFrozenStore = function (store) { + return store.frozen || (store.frozen = new UncaughtFrozenStore()); +}; + +var UncaughtFrozenStore = function () { + this.entries = []; +}; + +var findUncaughtFrozen = function (store, key) { + return find(store.entries, 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.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) this.entries.splice(index, 1); + return !!~index; + } +}; + +var collectionWeak = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var C = wrapper(function (that, iterable) { + anInstance(that, C, CONSTRUCTOR_NAME); + setInternalState$5(that, { + type: CONSTRUCTOR_NAME, + id: id$1++, + frozen: undefined + }); + if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var getInternalState = internalStateGetterFor$1(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + redefineAll(C.prototype, { + // 23.3.3.2 WeakMap.prototype.delete(key) + // 23.4.3.3 WeakSet.prototype.delete(value) + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && has(data, state.id) && delete data[state.id]; + }, + // 23.3.3.4 WeakMap.prototype.has(key) + // 23.4.3.4 WeakSet.prototype.has(value) + has: function has$1(key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && has(data, state.id); + } + }); + + redefineAll(C.prototype, IS_MAP ? { + // 23.3.3.3 WeakMap.prototype.get(key) + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // 23.3.3.5 WeakMap.prototype.set(key, value) + set: function set(key, value) { + return define(this, key, value); + } + } : { + // 23.4.3.1 WeakSet.prototype.add(value) + add: function add(value) { + return define(this, value, true); + } + }); + + return C; + } +}; + +createCommonjsModule(function (module) { + + + + + + +var enforceIternalState = internalState.enforce; + + +var IS_IE11 = !global_1.ActiveXObject && 'ActiveXObject' in global_1; +var isExtensible = Object.isExtensible; +var InternalWeakMap; + +var wrapper = function (init) { + return function WeakMap() { + return init(this, arguments.length ? arguments[0] : undefined); + }; +}; + +// `WeakMap` constructor +// https://tc39.es/ecma262/#sec-weakmap-constructor +var $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak); + +// IE11 WeakMap frozen keys fix +// We can't use feature detection because it crash some old IE builds +// https://github.com/zloirock/core-js/issues/485 +if (nativeWeakMap && IS_IE11) { + InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true); + internalMetadata.REQUIRED = true; + var WeakMapPrototype = $WeakMap.prototype; + var nativeDelete = WeakMapPrototype['delete']; + var nativeHas = WeakMapPrototype.has; + var nativeGet = WeakMapPrototype.get; + var nativeSet = WeakMapPrototype.set; + redefineAll(WeakMapPrototype, { + 'delete': function (key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeDelete.call(this, key) || state.frozen['delete'](key); + } return nativeDelete.call(this, key); + }, + has: function has(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) || state.frozen.has(key); + } return nativeHas.call(this, key); + }, + get: function get(key) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key); + } return nativeGet.call(this, key); + }, + set: function set(key, value) { + if (isObject(key) && !isExtensible(key)) { + var state = enforceIternalState(this); + if (!state.frozen) state.frozen = new InternalWeakMap(); + nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value); + } else nativeSet.call(this, key, value); + return this; + } + }); +} +}); + +/** + * Render type calculation calculates how many DOM nodes should be created and where placed + * based on `startRow` and `endRow` properties. + * + * @type {number} + */ +var RENDER_TYPE = 1; +/** + * Fully visible type calculation calculates rows that are fully visible in the viewport. + * This type of calculation is used in scrolling by arrow keys navigation. + * + * @type {number} + */ + +var FULLY_VISIBLE_TYPE = 2; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } +var privatePool = new WeakMap(); +/** + * Calculates indexes of columns to render OR columns that are visible. + * To redo the calculation, you need to create a new calculator. + * + * @class ViewportColumnsCalculator + */ + +var ViewportColumnsCalculator = /*#__PURE__*/function () { + /** + * @param {object} options Object with all options specified for column viewport calculation. + * @param {number} options.viewportWidth Width of the viewport. + * @param {number} options.scrollOffset Current horizontal scroll position of the viewport. + * @param {number} options.totalColumns Total number of columns. + * @param {Function} options.columnWidthFn Function that returns the width of the column at a given index (in px). + * @param {Function} options.overrideFn Function that changes calculated this.startRow, this.endRow (used by MergeCells plugin). + * @param {string} options.calculationType String which describes types of calculation which will be performed. + * @param {string} [options.stretchH] Stretch mode 'all' or 'last'. + * @param {Function} [options.stretchingColumnWidthFn] Function that returns the new width of the stretched column. + */ + function ViewportColumnsCalculator() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + viewportSize = _ref.viewportSize, + scrollOffset = _ref.scrollOffset, + totalItems = _ref.totalItems, + itemSizeFn = _ref.itemSizeFn, + overrideFn = _ref.overrideFn, + calculationType = _ref.calculationType, + stretchMode = _ref.stretchMode, + _ref$stretchingItemWi = _ref.stretchingItemWidthFn, + stretchingItemWidthFn = _ref$stretchingItemWi === void 0 ? function (width) { + return width; + } : _ref$stretchingItemWi; + + _classCallCheck(this, ViewportColumnsCalculator); + + privatePool.set(this, { + viewportWidth: viewportSize, + scrollOffset: scrollOffset, + totalColumns: totalItems, + columnWidthFn: itemSizeFn, + overrideFn: overrideFn, + calculationType: calculationType, + stretchingColumnWidthFn: stretchingItemWidthFn + }); + /** + * Number of rendered/visible columns. + * + * @type {number} + */ + + this.count = 0; + /** + * Index of the first rendered/visible column (can be overwritten using overrideFn). + * + * @type {number|null} + */ + + this.startColumn = null; + /** + * Index of the last rendered/visible column (can be overwritten using overrideFn). + * + * @type {null} + */ + + this.endColumn = null; + /** + * Position of the first rendered/visible column (in px). + * + * @type {number|null} + */ + + this.startPosition = null; + this.stretchAllRatio = 0; + this.stretchLastWidth = 0; + this.stretch = stretchMode; + this.totalTargetWidth = 0; + this.needVerifyLastColumnWidth = true; + this.stretchAllColumnsWidth = []; + this.calculate(); + } + /** + * Calculates viewport. + */ + + + _createClass(ViewportColumnsCalculator, [{ + key: "calculate", + value: function calculate() { + var sum = 0; + var needReverse = true; + var startPositions = []; + var columnWidth; + var priv = privatePool.get(this); + var calculationType = priv.calculationType; + var overrideFn = priv.overrideFn; + var scrollOffset = priv.scrollOffset; + var totalColumns = priv.totalColumns; + var viewportWidth = priv.viewportWidth; + + for (var i = 0; i < totalColumns; i++) { + columnWidth = this._getColumnWidth(i); + + if (sum <= scrollOffset && calculationType !== FULLY_VISIBLE_TYPE) { + this.startColumn = i; + } // +1 pixel for row header width compensation for horizontal scroll > 0 + + + var compensatedViewportWidth = scrollOffset > 0 ? viewportWidth + 1 : viewportWidth; + + if (sum >= scrollOffset && sum + (calculationType === FULLY_VISIBLE_TYPE ? columnWidth : 0) <= scrollOffset + compensatedViewportWidth) { + // eslint-disable-line max-len + if (this.startColumn === null || this.startColumn === void 0) { + this.startColumn = i; + } + + this.endColumn = i; + } + + startPositions.push(sum); + sum += columnWidth; + + if (calculationType !== FULLY_VISIBLE_TYPE) { + this.endColumn = i; + } + + if (sum >= scrollOffset + viewportWidth) { + needReverse = false; + break; + } + } + + if (this.endColumn === totalColumns - 1 && needReverse) { + this.startColumn = this.endColumn; + + while (this.startColumn > 0) { + var viewportSum = startPositions[this.endColumn] + columnWidth - startPositions[this.startColumn - 1]; + + if (viewportSum <= viewportWidth || calculationType !== FULLY_VISIBLE_TYPE) { + this.startColumn -= 1; + } + + if (viewportSum > viewportWidth) { + break; + } + } + } + + if (calculationType === RENDER_TYPE && this.startColumn !== null && overrideFn) { + overrideFn(this); + } + + this.startPosition = startPositions[this.startColumn]; + + if (this.startPosition === void 0) { + this.startPosition = null; + } // If totalColumns exceeded its total columns size set endColumn to the latest item + + + if (totalColumns < this.endColumn) { + this.endColumn = totalColumns - 1; + } + + if (this.startColumn !== null) { + this.count = this.endColumn - this.startColumn + 1; + } + } + /** + * Recalculate columns stretching. + * + * @param {number} totalWidth The total width of the table. + */ + + }, { + key: "refreshStretching", + value: function refreshStretching(totalWidth) { + if (this.stretch === 'none') { + return; + } + + var totalColumnsWidth = totalWidth; + this.totalTargetWidth = totalColumnsWidth; + var priv = privatePool.get(this); + var totalColumns = priv.totalColumns; + var sumAll = 0; + + for (var i = 0; i < totalColumns; i++) { + var columnWidth = this._getColumnWidth(i); + + var permanentColumnWidth = priv.stretchingColumnWidthFn(void 0, i); + + if (typeof permanentColumnWidth === 'number') { + totalColumnsWidth -= permanentColumnWidth; + } else { + sumAll += columnWidth; + } + } + + var remainingSize = totalColumnsWidth - sumAll; + + if (this.stretch === 'all' && remainingSize > 0) { + this.stretchAllRatio = totalColumnsWidth / sumAll; + this.stretchAllColumnsWidth = []; + this.needVerifyLastColumnWidth = true; + } else if (this.stretch === 'last' && totalColumnsWidth !== Infinity) { + var _columnWidth = this._getColumnWidth(totalColumns - 1); + + var lastColumnWidth = remainingSize + _columnWidth; + this.stretchLastWidth = lastColumnWidth >= 0 ? lastColumnWidth : _columnWidth; + } + } + /** + * Get stretched column width based on stretchH (all or last) setting passed in handsontable instance. + * + * @param {number} column The visual column index. + * @param {number} baseWidth The default column width. + * @returns {number|null} + */ + + }, { + key: "getStretchedColumnWidth", + value: function getStretchedColumnWidth(column, baseWidth) { + var result = null; + + if (this.stretch === 'all' && this.stretchAllRatio !== 0) { + result = this._getStretchedAllColumnWidth(column, baseWidth); + } else if (this.stretch === 'last' && this.stretchLastWidth !== 0) { + result = this._getStretchedLastColumnWidth(column); + } + + return result; + } + /** + * @param {number} column The visual column index. + * @param {number} baseWidth The default column width. + * @returns {number} + * @private + */ + + }, { + key: "_getStretchedAllColumnWidth", + value: function _getStretchedAllColumnWidth(column, baseWidth) { + var sumRatioWidth = 0; + var priv = privatePool.get(this); + var totalColumns = priv.totalColumns; + + if (!this.stretchAllColumnsWidth[column]) { + var stretchedWidth = Math.round(baseWidth * this.stretchAllRatio); + var newStretchedWidth = priv.stretchingColumnWidthFn(stretchedWidth, column); + + if (newStretchedWidth === void 0) { + this.stretchAllColumnsWidth[column] = stretchedWidth; + } else { + this.stretchAllColumnsWidth[column] = isNaN(newStretchedWidth) ? this._getColumnWidth(column) : newStretchedWidth; + } + } + + if (this.stretchAllColumnsWidth.length === totalColumns && this.needVerifyLastColumnWidth) { + this.needVerifyLastColumnWidth = false; + + for (var i = 0; i < this.stretchAllColumnsWidth.length; i++) { + sumRatioWidth += this.stretchAllColumnsWidth[i]; + } + + if (sumRatioWidth !== this.totalTargetWidth) { + this.stretchAllColumnsWidth[this.stretchAllColumnsWidth.length - 1] += this.totalTargetWidth - sumRatioWidth; + } + } + + return this.stretchAllColumnsWidth[column]; + } + /** + * @param {number} column The visual column index. + * @returns {number|null} + * @private + */ + + }, { + key: "_getStretchedLastColumnWidth", + value: function _getStretchedLastColumnWidth(column) { + var priv = privatePool.get(this); + var totalColumns = priv.totalColumns; + + if (column === totalColumns - 1) { + return this.stretchLastWidth; + } + + return null; + } + /** + * @param {number} column The visual column index. + * @returns {number} + * @private + */ + + }, { + key: "_getColumnWidth", + value: function _getColumnWidth(column) { + var width = privatePool.get(this).columnWidthFn(column); + + if (isNaN(width)) { + width = ViewportColumnsCalculator.DEFAULT_WIDTH; + } + + return width; + } + }], [{ + key: "DEFAULT_WIDTH", + get: + /** + * Default column width. + * + * @type {number} + */ + function get() { + return 50; + } + }]); + + return ViewportColumnsCalculator; +}(); + +function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1(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); } } + +function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); return Constructor; } +var privatePool$1 = new WeakMap(); +/** + * Calculates indexes of rows to render OR rows that are visible. + * To redo the calculation, you need to create a new calculator. + * + * @class ViewportRowsCalculator + */ + +var ViewportRowsCalculator = /*#__PURE__*/function () { + /** + * @param {object} options Object with all options specified for row viewport calculation. + * @param {number} options.viewportHeight Height of the viewport. + * @param {number} options.scrollOffset Current vertical scroll position of the viewport. + * @param {number} options.totalRows Total number of rows. + * @param {Function} options.rowHeightFn Function that returns the height of the row at a given index (in px). + * @param {Function} options.overrideFn Function that changes calculated this.startRow, this.endRow (used by MergeCells plugin). + * @param {string} options.calculationType String which describes types of calculation which will be performed. + * @param {number} options.horizontalScrollbarHeight The scrollbar height. + */ + function ViewportRowsCalculator() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + viewportSize = _ref.viewportSize, + scrollOffset = _ref.scrollOffset, + totalItems = _ref.totalItems, + itemSizeFn = _ref.itemSizeFn, + overrideFn = _ref.overrideFn, + calculationType = _ref.calculationType, + scrollbarHeight = _ref.scrollbarHeight; + + _classCallCheck$1(this, ViewportRowsCalculator); + + privatePool$1.set(this, { + viewportHeight: viewportSize, + scrollOffset: scrollOffset, + totalRows: totalItems, + rowHeightFn: itemSizeFn, + overrideFn: overrideFn, + calculationType: calculationType, + horizontalScrollbarHeight: scrollbarHeight + }); + /** + * Number of rendered/visible rows. + * + * @type {number} + */ + + this.count = 0; + /** + * Index of the first rendered/visible row (can be overwritten using overrideFn). + * + * @type {number|null} + */ + + this.startRow = null; + /** + * Index of the last rendered/visible row (can be overwritten using overrideFn). + * + * @type {null} + */ + + this.endRow = null; + /** + * Position of the first rendered/visible row (in px). + * + * @type {number|null} + */ + + this.startPosition = null; + this.calculate(); + } + /** + * Calculates viewport. + */ + + + _createClass$1(ViewportRowsCalculator, [{ + key: "calculate", + value: function calculate() { + var sum = 0; + var needReverse = true; + var startPositions = []; + var priv = privatePool$1.get(this); + var calculationType = priv.calculationType; + var overrideFn = priv.overrideFn; + var rowHeightFn = priv.rowHeightFn; + var scrollOffset = priv.scrollOffset; + var totalRows = priv.totalRows; + var viewportHeight = priv.viewportHeight; + var horizontalScrollbarHeight = priv.horizontalScrollbarHeight || 0; + var rowHeight; // Calculate the number (start and end index) of rows needed + + for (var i = 0; i < totalRows; i++) { + rowHeight = rowHeightFn(i); + + if (isNaN(rowHeight)) { + rowHeight = ViewportRowsCalculator.DEFAULT_HEIGHT; + } + + if (sum <= scrollOffset && calculationType !== FULLY_VISIBLE_TYPE) { + this.startRow = i; + } + + if (sum >= scrollOffset && sum + (calculationType === FULLY_VISIBLE_TYPE ? rowHeight : 0) <= scrollOffset + viewportHeight - horizontalScrollbarHeight) { + // eslint-disable-line max-len + if (this.startRow === null) { + this.startRow = i; + } + + this.endRow = i; + } + + startPositions.push(sum); + sum += rowHeight; + + if (calculationType !== FULLY_VISIBLE_TYPE) { + this.endRow = i; + } + + if (sum >= scrollOffset + viewportHeight - horizontalScrollbarHeight) { + needReverse = false; + break; + } + } // If the estimation has reached the last row and there is still some space available in the viewport, + // we need to render in reverse in order to fill the whole viewport with rows + + + if (this.endRow === totalRows - 1 && needReverse) { + this.startRow = this.endRow; + + while (this.startRow > 0) { + // rowHeight is the height of the last row + var viewportSum = startPositions[this.endRow] + rowHeight - startPositions[this.startRow - 1]; + + if (viewportSum <= viewportHeight - horizontalScrollbarHeight || calculationType !== FULLY_VISIBLE_TYPE) { + this.startRow -= 1; + } + + if (viewportSum >= viewportHeight - horizontalScrollbarHeight) { + break; + } + } + } + + if (calculationType === RENDER_TYPE && this.startRow !== null && overrideFn) { + overrideFn(this); + } + + this.startPosition = startPositions[this.startRow]; + + if (this.startPosition === void 0) { + this.startPosition = null; + } // If totalRows exceeded its total rows size set endRow to the latest item + + + if (totalRows < this.endRow) { + this.endRow = totalRows - 1; + } + + if (this.startRow !== null) { + this.count = this.endRow - this.startRow + 1; + } + } + }], [{ + key: "DEFAULT_HEIGHT", + get: + /** + * Default row height. + * + * @type {number} + */ + function get() { + return 23; + } + }]); + + return ViewportRowsCalculator; +}(); + +function _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2(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); } } + +function _createClass$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); return Constructor; } + +/** + * CellCoords holds cell coordinates (row, column) and few method to validate them and retrieve as an array or an object. + * + * @util + */ +var CellCoords = /*#__PURE__*/function () { + function CellCoords(row, column) { + _classCallCheck$2(this, CellCoords); + + /** + * Row index. + * + * @type {number} + */ + this.row = null; + /** + * Column index. + * + * @type {number} + */ + + this.col = null; + + if (typeof row !== 'undefined' && typeof column !== 'undefined') { + this.row = row; + this.col = column; + } + } + /** + * Checks if given set of coordinates is valid in context of a given Walkontable instance. + * + * @param {Walkontable} wot A Walkontable instance. + * @returns {boolean} + */ + + + _createClass$2(CellCoords, [{ + key: "isValid", + value: function isValid(wot) { + // is it a valid cell index (0 or higher) + if (this.row < 0 || this.col < 0) { + return false; + } // is selection within total rows and columns + + + if (this.row >= wot.getSetting('totalRows') || this.col >= wot.getSetting('totalColumns')) { + return false; + } + + return true; + } + /** + * Checks if this cell coordinates are the same as cell coordinates given as an argument. + * + * @param {CellCoords} cellCoords Cell coordinates to equal. + * @returns {boolean} + */ + + }, { + key: "isEqual", + value: function isEqual(cellCoords) { + if (cellCoords === this) { + return true; + } + + return this.row === cellCoords.row && this.col === cellCoords.col; + } + /** + * Checks if tested coordinates are positioned in south-east from this cell coordinates. + * + * @param {object} testedCoords Cell coordinates to check. + * @returns {boolean} + */ + + }, { + key: "isSouthEastOf", + value: function isSouthEastOf(testedCoords) { + return this.row >= testedCoords.row && this.col >= testedCoords.col; + } + /** + * Checks if tested coordinates are positioned in north-east from this cell coordinates. + * + * @param {object} testedCoords Cell coordinates to check. + * @returns {boolean} + */ + + }, { + key: "isNorthWestOf", + value: function isNorthWestOf(testedCoords) { + return this.row <= testedCoords.row && this.col <= testedCoords.col; + } + /** + * Checks if tested coordinates are positioned in south-west from this cell coordinates. + * + * @param {object} testedCoords Cell coordinates to check. + * @returns {boolean} + */ + + }, { + key: "isSouthWestOf", + value: function isSouthWestOf(testedCoords) { + return this.row >= testedCoords.row && this.col <= testedCoords.col; + } + /** + * Checks if tested coordinates are positioned in north-east from this cell coordinates. + * + * @param {object} testedCoords Cell coordinates to check. + * @returns {boolean} + */ + + }, { + key: "isNorthEastOf", + value: function isNorthEastOf(testedCoords) { + return this.row <= testedCoords.row && this.col >= testedCoords.col; + } + /** + * Normalizes the coordinates to the nearest valid position. The coordinates that point + * to the headers (negative values) are normalized to 0. + * + * @returns {CellCoords} + */ + + }, { + key: "normalize", + value: function normalize() { + this.row = this.row === null ? this.row : Math.max(this.row, 0); + this.col = this.col === null ? this.col : Math.max(this.col, 0); + return this; + } + /** + * Clones the coordinates. + * + * @returns {CellCoords} + */ + + }, { + key: "clone", + value: function clone() { + return new CellCoords(this.row, this.col); + } + /** + * Converts CellCoords to literal object with `row` and `col` properties. + * + * @returns {object} Returns a literal object with `row` and `col` properties. + */ + + }, { + key: "toObject", + value: function toObject() { + return { + row: this.row, + col: this.col + }; + } + }]); + + return CellCoords; +}(); + +function _classCallCheck$3(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$3(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); } } + +function _createClass$3(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$3(Constructor.prototype, protoProps); if (staticProps) _defineProperties$3(Constructor, staticProps); return Constructor; } +/** + * CellRange holds cell coordinates as {@link CellCoords} instances. This object represent unit of the selection layer which + * can contains multiple contiquous cells or single cell. + * + * @util + */ + +var CellRange = /*#__PURE__*/function () { + function CellRange(highlight) { + var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : highlight; + var to = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : highlight; + + _classCallCheck$3(this, CellRange); + + /** + * Used to draw bold border around a cell where selection was started and to edit the cell + * when you press Enter. The highlight cannot point to headers (negative values) so its + * coordinates object is normalized while assigning. + * + * @type {CellCoords} + */ + this.highlight = highlight.clone().normalize(); + /** + * Usually the same as highlight, but in Excel there is distinction - one can change + * highlight within a selection. + * + * @type {CellCoords} + */ + + this.from = from.clone(); + /** + * End selection. + * + * @type {CellCoords} + */ + + this.to = to.clone(); + } + /** + * Set the new coordinates for highlighting selection. + * + * @param {CellCoords} coords Coordinates to use. + * @returns {CellRange} + */ + + + _createClass$3(CellRange, [{ + key: "setHighlight", + value: function setHighlight(coords) { + this.highlight = coords.clone().normalize(); + return this; + } + /** + * Set the new coordinates where selection starts from. + * + * @param {CellCoords} coords Coordinates to use. + * @returns {CellRange} + */ + + }, { + key: "setFrom", + value: function setFrom(coords) { + this.from = coords.clone(); + return this; + } + /** + * Set new coordinates where selection ends from. + * + * @param {CellCoords} coords Coordinates to use. + * @returns {CellRange} + */ + + }, { + key: "setTo", + value: function setTo(coords) { + this.to = coords.clone(); + return this; + } + /** + * Checks if given coordinates are valid in context of a given Walkontable instance. + * + * @param {Walkontable} wot The Walkontable instance. + * @returns {boolean} + */ + + }, { + key: "isValid", + value: function isValid(wot) { + return this.from.isValid(wot) && this.to.isValid(wot); + } + /** + * Checks if this cell range is restricted to one cell. + * + * @returns {boolean} + */ + + }, { + key: "isSingle", + value: function isSingle() { + return this.from.row >= 0 && this.from.row === this.to.row && this.from.col >= 0 && this.from.col === this.to.col; + } + /** + * Returns selected range height (in number of rows including rows' headers). + * + * @returns {number} + */ + + }, { + key: "getOuterHeight", + value: function getOuterHeight() { + return Math.max(this.from.row, this.to.row) - Math.min(this.from.row, this.to.row) + 1; + } + /** + * Returns selected range width (in number of columns including columns' headers). + * + * @returns {number} + */ + + }, { + key: "getOuterWidth", + value: function getOuterWidth() { + return Math.max(this.from.col, this.to.col) - Math.min(this.from.col, this.to.col) + 1; + } + /** + * Returns selected range height (in number of rows excluding rows' headers). + * + * @returns {number} + */ + + }, { + key: "getHeight", + value: function getHeight() { + var fromRow = Math.max(this.from.row, 0); + var toRow = Math.max(this.to.row, 0); + return Math.max(fromRow, toRow) - Math.min(fromRow, toRow) + 1; + } + /** + * Returns selected range width (in number of columns excluding columns' headers). + * + * @returns {number} + */ + + }, { + key: "getWidth", + value: function getWidth() { + var fromCol = Math.max(this.from.col, 0); + var toCol = Math.max(this.to.col, 0); + return Math.max(fromCol, toCol) - Math.min(fromCol, toCol) + 1; + } + /** + * Checks if given cell coordinates are within `from` and `to` cell coordinates of this range. + * + * @param {CellCoords} cellCoords The cell coordinates to check. + * @returns {boolean} + */ + + }, { + key: "includes", + value: function includes(cellCoords) { + var row = cellCoords.row, + col = cellCoords.col; + var topLeft = this.getOuterTopLeftCorner(); + var bottomRight = this.getOuterBottomRightCorner(); + return topLeft.row <= row && bottomRight.row >= row && topLeft.col <= col && bottomRight.col >= col; + } + /** + * Checks if given range is within of this range. + * + * @param {CellRange} cellRange The cells range to check. + * @returns {boolean} + */ + + }, { + key: "includesRange", + value: function includesRange(cellRange) { + return this.includes(cellRange.getOuterTopLeftCorner()) && this.includes(cellRange.getOuterBottomRightCorner()); + } + /** + * Checks if given range is equal to this range. + * + * @param {CellRange} cellRange The cells range to check. + * @returns {boolean} + */ + + }, { + key: "isEqual", + value: function isEqual(cellRange) { + return Math.min(this.from.row, this.to.row) === Math.min(cellRange.from.row, cellRange.to.row) && Math.max(this.from.row, this.to.row) === Math.max(cellRange.from.row, cellRange.to.row) && Math.min(this.from.col, this.to.col) === Math.min(cellRange.from.col, cellRange.to.col) && Math.max(this.from.col, this.to.col) === Math.max(cellRange.from.col, cellRange.to.col); + } + /** + * Checks if tested range overlaps with the range. Range A is considered to to be overlapping with range B + * if intersection of A and B or B and A is not empty. + * + * @param {CellRange} cellRange The cells range to check. + * @returns {boolean} + */ + + }, { + key: "overlaps", + value: function overlaps(cellRange) { + return cellRange.isSouthEastOf(this.getOuterTopLeftCorner()) && cellRange.isNorthWestOf(this.getOuterBottomRightCorner()); + } + /** + * Checks if tested coordinates are positioned in south-east from this cell range. + * + * @param {CellRange} cellRange The cells range to check. + * @returns {boolean} + */ + + }, { + key: "isSouthEastOf", + value: function isSouthEastOf(cellRange) { + return this.getOuterTopLeftCorner().isSouthEastOf(cellRange) || this.getOuterBottomRightCorner().isSouthEastOf(cellRange); + } + /** + * Checks if tested coordinates are positioned in north-west from this cell range. + * + * @param {CellRange} cellRange The cells range to check. + * @returns {boolean} + */ + + }, { + key: "isNorthWestOf", + value: function isNorthWestOf(cellRange) { + return this.getOuterTopLeftCorner().isNorthWestOf(cellRange) || this.getOuterBottomRightCorner().isNorthWestOf(cellRange); + } + /** + * Returns `true` if the provided range is overlapping the current range horizontally (e.g. The current range's last + * column is 5 and the provided range's first column is 3). + * + * @param {CellRange} cellRange The cells range to check. + * @returns {boolean} + */ + + }, { + key: "isOverlappingHorizontally", + value: function isOverlappingHorizontally(cellRange) { + return this.getOuterTopRightCorner().col >= cellRange.getOuterTopLeftCorner().col && this.getOuterTopRightCorner().col <= cellRange.getOuterTopRightCorner().col || this.getOuterTopLeftCorner().col <= cellRange.getOuterTopRightCorner().col && this.getOuterTopLeftCorner().col >= cellRange.getOuterTopLeftCorner().col; + } + /** + * Returns `true` if the provided range is overlapping the current range vertically (e.g. The current range's last + * row is 5 and the provided range's first row is 3). + * + * @param {CellRange} cellRange The cells range to check. + * @returns {boolean} + */ + + }, { + key: "isOverlappingVertically", + value: function isOverlappingVertically(cellRange) { + return this.getOuterBottomRightCorner().row >= cellRange.getOuterTopRightCorner().row && this.getOuterBottomRightCorner().row <= cellRange.getOuterBottomRightCorner().row || this.getOuterTopRightCorner().row <= cellRange.getOuterBottomRightCorner().row && this.getOuterTopRightCorner().row >= cellRange.getOuterTopRightCorner().row; + } + /** + * Adds a cell to a range (only if exceeds corners of the range). Returns information if range was expanded. + * + * @param {CellCoords} cellCoords The cell coordinates. + * @returns {boolean} + */ + + }, { + key: "expand", + value: function expand(cellCoords) { + var topLeft = this.getOuterTopLeftCorner(); + var bottomRight = this.getOuterBottomRightCorner(); + + if (cellCoords.row < topLeft.row || cellCoords.col < topLeft.col || cellCoords.row > bottomRight.row || cellCoords.col > bottomRight.col) { + this.from = new CellCoords(Math.min(topLeft.row, cellCoords.row), Math.min(topLeft.col, cellCoords.col)); + this.to = new CellCoords(Math.max(bottomRight.row, cellCoords.row), Math.max(bottomRight.col, cellCoords.col)); + return true; + } + + return false; + } + /** + * Expand the current object by the range passed in the first argument. + * + * @param {CellRange} expandingRange Object extending the range. + * @returns {boolean} + */ + + }, { + key: "expandByRange", + value: function expandByRange(expandingRange) { + if (this.includesRange(expandingRange) || !this.overlaps(expandingRange)) { + return false; + } + + var topLeft = this.getOuterTopLeftCorner(); + var bottomRight = this.getOuterBottomRightCorner(); + var initialDirection = this.getDirection(); + var expandingTopLeft = expandingRange.getOuterTopLeftCorner(); + var expandingBottomRight = expandingRange.getOuterBottomRightCorner(); + var resultTopRow = Math.min(topLeft.row, expandingTopLeft.row); + var resultTopCol = Math.min(topLeft.col, expandingTopLeft.col); + var resultBottomRow = Math.max(bottomRight.row, expandingBottomRight.row); + var resultBottomCol = Math.max(bottomRight.col, expandingBottomRight.col); + var finalFrom = new CellCoords(resultTopRow, resultTopCol); + var finalTo = new CellCoords(resultBottomRow, resultBottomCol); + this.from = finalFrom; + this.to = finalTo; + this.setDirection(initialDirection); + + if (this.highlight.row === this.getOuterBottomRightCorner().row && this.getVerticalDirection() === 'N-S') { + this.flipDirectionVertically(); + } + + if (this.highlight.col === this.getOuterTopRightCorner().col && this.getHorizontalDirection() === 'W-E') { + this.flipDirectionHorizontally(); + } + + return true; + } + /** + * Gets the direction of the selection. + * + * @returns {string} Returns one of the values: `'NW-SE'`, `'NE-SW'`, `'SE-NW'`, `'SW-NE'`. + */ + + }, { + key: "getDirection", + value: function getDirection() { + if (this.from.isNorthWestOf(this.to)) { + // NorthWest - SouthEast + return 'NW-SE'; + } else if (this.from.isNorthEastOf(this.to)) { + // NorthEast - SouthWest + return 'NE-SW'; + } else if (this.from.isSouthEastOf(this.to)) { + // SouthEast - NorthWest + return 'SE-NW'; + } else if (this.from.isSouthWestOf(this.to)) { + // SouthWest - NorthEast + return 'SW-NE'; + } + } + /** + * Sets the direction of the selection. + * + * @param {string} direction One of the values: `'NW-SE'`, `'NE-SW'`, `'SE-NW'`, `'SW-NE'`. + */ + + }, { + key: "setDirection", + value: function setDirection(direction) { + switch (direction) { + case 'NW-SE': + var _ref = [this.getOuterTopLeftCorner(), this.getOuterBottomRightCorner()]; + this.from = _ref[0]; + this.to = _ref[1]; + break; + + case 'NE-SW': + var _ref2 = [this.getOuterTopRightCorner(), this.getOuterBottomLeftCorner()]; + this.from = _ref2[0]; + this.to = _ref2[1]; + break; + + case 'SE-NW': + var _ref3 = [this.getOuterBottomRightCorner(), this.getOuterTopLeftCorner()]; + this.from = _ref3[0]; + this.to = _ref3[1]; + break; + + case 'SW-NE': + var _ref4 = [this.getOuterBottomLeftCorner(), this.getOuterTopRightCorner()]; + this.from = _ref4[0]; + this.to = _ref4[1]; + break; + } + } + /** + * Gets the vertical direction of the range. + * + * @returns {string} Returns one of the values: `N-S` (north->south), `S-N` (south->north). + */ + + }, { + key: "getVerticalDirection", + value: function getVerticalDirection() { + return ['NE-SW', 'NW-SE'].indexOf(this.getDirection()) > -1 ? 'N-S' : 'S-N'; + } + /** + * Gets the horizontal direction of the range. + * + * @returns {string} Returns one of the values: `W-E` (west->east), `E-W` (east->west). + */ + + }, { + key: "getHorizontalDirection", + value: function getHorizontalDirection() { + return ['NW-SE', 'SW-NE'].indexOf(this.getDirection()) > -1 ? 'W-E' : 'E-W'; + } + /** + * Flip the direction vertically. (e.g. `NW-SE` changes to `SW-NE`). + */ + + }, { + key: "flipDirectionVertically", + value: function flipDirectionVertically() { + var direction = this.getDirection(); + + switch (direction) { + case 'NW-SE': + this.setDirection('SW-NE'); + break; + + case 'NE-SW': + this.setDirection('SE-NW'); + break; + + case 'SE-NW': + this.setDirection('NE-SW'); + break; + + case 'SW-NE': + this.setDirection('NW-SE'); + break; + } + } + /** + * Flip the direction horizontally. (e.g. `NW-SE` changes to `NE-SW`). + */ + + }, { + key: "flipDirectionHorizontally", + value: function flipDirectionHorizontally() { + var direction = this.getDirection(); + + switch (direction) { + case 'NW-SE': + this.setDirection('NE-SW'); + break; + + case 'NE-SW': + this.setDirection('NW-SE'); + break; + + case 'SE-NW': + this.setDirection('SW-NE'); + break; + + case 'SW-NE': + this.setDirection('SE-NW'); + break; + } + } + /** + * Gets the top left corner of this range. If the corner contains header coordinates + * (negative values), the corner coordinates will be normalized to 0. + * + * @returns {CellCoords} + */ + + }, { + key: "getTopLeftCorner", + value: function getTopLeftCorner() { + return new CellCoords(Math.min(this.from.row, this.to.row), Math.min(this.from.col, this.to.col)).normalize(); + } + /** + * Gets the bottom right corner of this range. If the corner contains header coordinates + * (negative values), the corner coordinates will be normalized to 0. + * + * @returns {CellCoords} + */ + + }, { + key: "getBottomRightCorner", + value: function getBottomRightCorner() { + return new CellCoords(Math.max(this.from.row, this.to.row), Math.max(this.from.col, this.to.col)).normalize(); + } + /** + * Gets the top right corner of this range. If the corner contains header coordinates + * (negative values), the corner coordinates will be normalized to 0. + * + * @returns {CellCoords} + */ + + }, { + key: "getTopRightCorner", + value: function getTopRightCorner() { + return new CellCoords(Math.min(this.from.row, this.to.row), Math.max(this.from.col, this.to.col)).normalize(); + } + /** + * Gets the bottom left corner of this range. If the corner contains header coordinates + * (negative values), the corner coordinates will be normalized to 0. + * + * @returns {CellCoords} + */ + + }, { + key: "getBottomLeftCorner", + value: function getBottomLeftCorner() { + return new CellCoords(Math.max(this.from.row, this.to.row), Math.min(this.from.col, this.to.col)).normalize(); + } + /** + * Gets the top left corner of this range. If the corner contains header coordinates + * (negative values), then the top and left coordinates will be pointed to that header. + * + * @returns {CellCoords} + */ + + }, { + key: "getOuterTopLeftCorner", + value: function getOuterTopLeftCorner() { + return new CellCoords(Math.min(this.from.row, this.to.row), Math.min(this.from.col, this.to.col)); + } + /** + * Gets the bottom right corner of this range. + * + * @returns {CellCoords} + */ + + }, { + key: "getOuterBottomRightCorner", + value: function getOuterBottomRightCorner() { + return new CellCoords(Math.max(this.from.row, this.to.row), Math.max(this.from.col, this.to.col)); + } + /** + * Gets the top right corner of this range. If the corner contains header coordinates + * (negative values), then the top coordinate will be pointed to that header. + * + * @returns {CellCoords} + */ + + }, { + key: "getOuterTopRightCorner", + value: function getOuterTopRightCorner() { + return new CellCoords(Math.min(this.from.row, this.to.row), Math.max(this.from.col, this.to.col)); + } + /** + * Gets the bottom left corner of this range. If the corner contains header coordinates + * (negative values), then the left coordinate will be pointed to that header. + * + * @returns {CellCoords} + */ + + }, { + key: "getOuterBottomLeftCorner", + value: function getOuterBottomLeftCorner() { + return new CellCoords(Math.max(this.from.row, this.to.row), Math.min(this.from.col, this.to.col)); + } + /** + * Checks if coordinates match to one of the 4th corners of this range. + * + * @param {CellCoords} coords Cell coordinates to check. + * @param {CellRange} [expandedRange] The cells range to compare with. + * @returns {boolean} + */ + + }, { + key: "isCorner", + value: function isCorner(coords, expandedRange) { + if (expandedRange && expandedRange.includes(coords) && (this.getOuterTopLeftCorner().isEqual(new CellCoords(expandedRange.from.row, expandedRange.from.col)) || this.getOuterTopRightCorner().isEqual(new CellCoords(expandedRange.from.row, expandedRange.to.col)) || this.getOuterBottomLeftCorner().isEqual(new CellCoords(expandedRange.to.row, expandedRange.from.col)) || this.getOuterBottomRightCorner().isEqual(new CellCoords(expandedRange.to.row, expandedRange.to.col)))) { + return true; + } + + return coords.isEqual(this.getOuterTopLeftCorner()) || coords.isEqual(this.getOuterTopRightCorner()) || coords.isEqual(this.getOuterBottomLeftCorner()) || coords.isEqual(this.getOuterBottomRightCorner()); + } + /** + * Gets coordinates of the corner which is opposite to the matched. When the passed coordinates matched to the + * bottom-right corner of this range then the coordinates for top-left will be returned. + * + * @param {CellCoords} coords Cell coordinates to check. + * @param {CellRange} [expandedRange] The cells range to compare with. + * @returns {CellCoords} + */ + + }, { + key: "getOppositeCorner", + value: function getOppositeCorner(coords, expandedRange) { + if (!(coords instanceof CellCoords)) { + return false; + } + + if (expandedRange) { + if (expandedRange.includes(coords)) { + if (this.getOuterTopLeftCorner().isEqual(new CellCoords(expandedRange.from.row, expandedRange.from.col))) { + return this.getOuterBottomRightCorner(); + } + + if (this.getOuterTopRightCorner().isEqual(new CellCoords(expandedRange.from.row, expandedRange.to.col))) { + return this.getOuterBottomLeftCorner(); + } + + if (this.getOuterBottomLeftCorner().isEqual(new CellCoords(expandedRange.to.row, expandedRange.from.col))) { + return this.getOuterTopRightCorner(); + } + + if (this.getOuterBottomRightCorner().isEqual(new CellCoords(expandedRange.to.row, expandedRange.to.col))) { + return this.getOuterTopLeftCorner(); + } + } + } + + if (coords.isEqual(this.getOuterBottomRightCorner())) { + return this.getOuterTopLeftCorner(); + } else if (coords.isEqual(this.getOuterTopLeftCorner())) { + return this.getOuterBottomRightCorner(); + } else if (coords.isEqual(this.getOuterTopRightCorner())) { + return this.getOuterBottomLeftCorner(); + } else if (coords.isEqual(this.getOuterBottomLeftCorner())) { + return this.getOuterTopRightCorner(); + } + } + /** + * @param {CellRange} range The cells range to compare with. + * @returns {Array} + */ + + }, { + key: "getBordersSharedWith", + value: function getBordersSharedWith(range) { + if (!this.includesRange(range)) { + return []; + } + + var thisBorders = { + top: Math.min(this.from.row, this.to.row), + bottom: Math.max(this.from.row, this.to.row), + left: Math.min(this.from.col, this.to.col), + right: Math.max(this.from.col, this.to.col) + }; + var rangeBorders = { + top: Math.min(range.from.row, range.to.row), + bottom: Math.max(range.from.row, range.to.row), + left: Math.min(range.from.col, range.to.col), + right: Math.max(range.from.col, range.to.col) + }; + var result = []; + + if (thisBorders.top === rangeBorders.top) { + result.push('top'); + } + + if (thisBorders.right === rangeBorders.right) { + result.push('right'); + } + + if (thisBorders.bottom === rangeBorders.bottom) { + result.push('bottom'); + } + + if (thisBorders.left === rangeBorders.left) { + result.push('left'); + } + + return result; + } + /** + * Get inner selected cell coords defined by this range. + * + * @returns {Array} + */ + + }, { + key: "getInner", + value: function getInner() { + var topLeft = this.getOuterTopLeftCorner(); + var bottomRight = this.getOuterBottomRightCorner(); + var out = []; + + for (var r = topLeft.row; r <= bottomRight.row; r++) { + for (var c = topLeft.col; c <= bottomRight.col; c++) { + if (!(this.from.row === r && this.from.col === c) && !(this.to.row === r && this.to.col === c)) { + out.push(new CellCoords(r, c)); + } + } + } + + return out; + } + /** + * Get all selected cell coords defined by this range. + * + * @returns {Array} + */ + + }, { + key: "getAll", + value: function getAll() { + var topLeft = this.getOuterTopLeftCorner(); + var bottomRight = this.getOuterBottomRightCorner(); + var out = []; + + for (var r = topLeft.row; r <= bottomRight.row; r++) { + for (var c = topLeft.col; c <= bottomRight.col; c++) { + if (topLeft.row === r && topLeft.col === c) { + out.push(topLeft); + } else if (bottomRight.row === r && bottomRight.col === c) { + out.push(bottomRight); + } else { + out.push(new CellCoords(r, c)); + } + } + } + + return out; + } + /** + * Runs a callback function against all cells in the range. You can break the iteration by returning + * `false` in the callback function. + * + * @param {Function} callback The callback function. + */ + + }, { + key: "forAll", + value: function forAll(callback) { + var topLeft = this.getOuterTopLeftCorner(); + var bottomRight = this.getOuterBottomRightCorner(); + + for (var r = topLeft.row; r <= bottomRight.row; r++) { + for (var c = topLeft.col; c <= bottomRight.col; c++) { + var breakIteration = callback(r, c); + + if (breakIteration === false) { + return; + } + } + } + } + /** + * Clones the range coordinates. + * + * @returns {CellRange} + */ + + }, { + key: "clone", + value: function clone() { + return new CellRange(this.highlight, this.from, this.to); + } + /** + * Convert CellRange to literal object. + * + * @returns {object} Returns a literal object with `from` and `to` properties which each of that object + * contains `row` and `col` keys. + */ + + }, { + key: "toObject", + value: function toObject() { + return { + from: this.from.toObject(), + to: this.to.toObject() + }; + } + }]); + + return CellRange; +}(); + +function _classCallCheck$4(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$4(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); } } + +function _createClass$4(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$4(Constructor.prototype, protoProps); if (staticProps) _defineProperties$4(Constructor, staticProps); return Constructor; } + +/** + * @class ColumnFilter + */ +var ColumnFilter = /*#__PURE__*/function () { + /** + * @param {number} offset The scroll horizontal offset. + * @param {number} total The total width of the table. + * @param {number} countTH The number of rendered row headers. + */ + function ColumnFilter(offset, total, countTH) { + _classCallCheck$4(this, ColumnFilter); + + this.offset = offset; + this.total = total; + this.countTH = countTH; + } + /** + * @param {number} index The visual column index. + * @returns {number} + */ + + + _createClass$4(ColumnFilter, [{ + key: "offsetted", + value: function offsetted(index) { + return index + this.offset; + } + /** + * @param {number} index The visual column index. + * @returns {number} + */ + + }, { + key: "unOffsetted", + value: function unOffsetted(index) { + return index - this.offset; + } + /** + * @param {number} index The visual column index. + * @returns {number} + */ + + }, { + key: "renderedToSource", + value: function renderedToSource(index) { + return this.offsetted(index); + } + /** + * @param {number} index The visual column index. + * @returns {number} + */ + + }, { + key: "sourceToRendered", + value: function sourceToRendered(index) { + return this.unOffsetted(index); + } + /** + * @param {number} index The visual column index. + * @returns {number} + */ + + }, { + key: "offsettedTH", + value: function offsettedTH(index) { + return index - this.countTH; + } + /** + * @param {number} index The visual column index. + * @returns {number} + */ + + }, { + key: "unOffsettedTH", + value: function unOffsettedTH(index) { + return index + this.countTH; + } + /** + * @param {number} index The visual column index. + * @returns {number} + */ + + }, { + key: "visibleRowHeadedColumnToSourceColumn", + value: function visibleRowHeadedColumnToSourceColumn(index) { + return this.renderedToSource(this.offsettedTH(index)); + } + /** + * @param {number} index The visual column index. + * @returns {number} + */ + + }, { + key: "sourceColumnToVisibleRowHeadedColumn", + value: function sourceColumnToVisibleRowHeadedColumn(index) { + return this.unOffsettedTH(this.sourceToRendered(index)); + } + }]); + + return ColumnFilter; +}(); + +function _classCallCheck$5(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$5(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); } } + +function _createClass$5(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$5(Constructor.prototype, protoProps); if (staticProps) _defineProperties$5(Constructor, staticProps); return Constructor; } + +/** + * @class RowFilter + */ +var RowFilter = /*#__PURE__*/function () { + /** + * @param {number} offset The scroll vertical offset. + * @param {number} total The total height of the table. + * @param {number} countTH The number of rendered column headers. + */ + function RowFilter(offset, total, countTH) { + _classCallCheck$5(this, RowFilter); + + this.offset = offset; + this.total = total; + this.countTH = countTH; + } + /** + * @param {number} index The visual row index. + * @returns {number} + */ + + + _createClass$5(RowFilter, [{ + key: "offsetted", + value: function offsetted(index) { + return index + this.offset; + } + /** + * @param {number} index The visual row index. + * @returns {number} + */ + + }, { + key: "unOffsetted", + value: function unOffsetted(index) { + return index - this.offset; + } + /** + * @param {number} index The visual row index. + * @returns {number} + */ + + }, { + key: "renderedToSource", + value: function renderedToSource(index) { + return this.offsetted(index); + } + /** + * @param {number} index The visual row index. + * @returns {number} + */ + + }, { + key: "sourceToRendered", + value: function sourceToRendered(index) { + return this.unOffsetted(index); + } + /** + * @param {number} index The visual row index. + * @returns {number} + */ + + }, { + key: "offsettedTH", + value: function offsettedTH(index) { + return index - this.countTH; + } + /** + * @param {number} index The visual row index. + * @returns {number} + */ + + }, { + key: "unOffsettedTH", + value: function unOffsettedTH(index) { + return index + this.countTH; + } + /** + * @param {number} index The visual row index. + * @returns {number} + */ + + }, { + key: "visibleColHeadedRowToSourceRow", + value: function visibleColHeadedRowToSourceRow(index) { + return this.renderedToSource(this.offsettedTH(index)); + } + /** + * @param {number} index The visual row index. + * @returns {number} + */ + + }, { + key: "sourceRowToVisibleColHeadedRow", + value: function sourceRowToVisibleColHeadedRow(index) { + return this.unOffsettedTH(this.sourceToRendered(index)); + } + }]); + + return RowFilter; +}(); + +/** + * Describes that ViewSizeSet instance doesn't share sizes with another + * instance (root node can contain only one type of children nodes). + * + * @type {number} + */ +var WORKING_SPACE_ALL = 0; +/** + * Describes that ViewSizeSet instance share sizes with another instance and + * set working space for this instance to 'top' (root node can contain multiple + * types of children and this instance will be occupied top space of the root node). + * + * @type {number} + */ + +var WORKING_SPACE_TOP = 1; +/** + * Describes that ViewSizeSet instance share sizes with another instance and + * set working space for this instance to 'bottom' (root node can contain multiple + * types of children and this instance will be occupied bottom space of the root node). + * + * @type {number} + */ + +var WORKING_SPACE_BOTTOM = 2; + +function _classCallCheck$6(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$6(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); } } + +function _createClass$6(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$6(Constructor.prototype, protoProps); if (staticProps) _defineProperties$6(Constructor, staticProps); return Constructor; } + +/** + * Holder for current and next size (count of rendered and to render DOM elements) and offset. + * + * @class {ViewSize} + */ +var ViewSize = /*#__PURE__*/function () { + function ViewSize() { + _classCallCheck$6(this, ViewSize); + + /** + * Current size of the rendered DOM elements. + * + * @type {number} + */ + this.currentSize = 0; + /** + * Next size of the rendered DOM elements which should be fulfilled. + * + * @type {number} + */ + + this.nextSize = 0; + /** + * Current offset. + * + * @type {number} + */ + + this.currentOffset = 0; + /** + * Next ofset. + * + * @type {number} + */ + + this.nextOffset = 0; + } + /** + * Sets new size of the rendered DOM elements. + * + * @param {number} size The size. + */ + + + _createClass$6(ViewSize, [{ + key: "setSize", + value: function setSize(size) { + this.currentSize = this.nextSize; + this.nextSize = size; + } + /** + * Sets new offset. + * + * @param {number} offset The offset. + */ + + }, { + key: "setOffset", + value: function setOffset(offset) { + this.currentOffset = this.nextOffset; + this.nextOffset = offset; + } + }]); + + return ViewSize; +}(); + +function _classCallCheck$7(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$7(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); } } + +function _createClass$7(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$7(Constructor.prototype, protoProps); if (staticProps) _defineProperties$7(Constructor, staticProps); return Constructor; } +/** + * The class is a source of the truth of information about the current and + * next size of the rendered DOM elements and current and next offset of + * the view. That information allows us to calculate diff between current + * DOM order and this which should be rendered without touching the DOM API at all. + * + * Mostly the ViewSizeSet is created for each individual renderer. But in + * the table, there is one case where this size information should be shared + * between two different instances (different table renderers). This is a TR + * element which can contain TH elements - managed by own renderer and + * TD elements - managed by another renderer. To generate correct DOM order + * for them it is required to connect these two instances by reference + * through `sharedSize`. + * + * @class {ViewSizeSet} + */ + +var ViewSizeSet = /*#__PURE__*/function () { + function ViewSizeSet() { + _classCallCheck$7(this, ViewSizeSet); + + /** + * Holder for current and next view size and offset. + * + * @type {ViewSize} + */ + this.size = new ViewSize(); + /** + * Defines if this instance shares its size with another instance. If it's in the shared + * mode it defines what space it occupies ('top' or 'bottom'). + * + * @type {number} + */ + + this.workingSpace = WORKING_SPACE_ALL; + /** + * Shared Size instance. + * + * @type {ViewSize} + */ + + this.sharedSize = null; + } + /** + * Sets the size for rendered elements. It can be a size for rows, cells or size for row + * headers etc. + * + * @param {number} size The size. + */ + + + _createClass$7(ViewSizeSet, [{ + key: "setSize", + value: function setSize(size) { + this.size.setSize(size); + } + /** + * Sets the offset for rendered elements. The offset describes the shift between 0 and + * the first rendered element according to the scroll position. + * + * @param {number} offset The offset. + */ + + }, { + key: "setOffset", + value: function setOffset(offset) { + this.size.setOffset(offset); + } + /** + * Returns ViewSize instance. + * + * @returns {ViewSize} + */ + + }, { + key: "getViewSize", + value: function getViewSize() { + return this.size; + } + /** + * Checks if this ViewSizeSet is sharing the size with another instance. + * + * @returns {boolean} + */ + + }, { + key: "isShared", + value: function isShared() { + return this.sharedSize instanceof ViewSize; + } + /** + * Checks what working space describes this size instance. + * + * @param {number} workingSpace The number which describes the type of the working space (see constants.js). + * @returns {boolean} + */ + + }, { + key: "isPlaceOn", + value: function isPlaceOn(workingSpace) { + return this.workingSpace === workingSpace; + } + /** + * Appends the ViewSizeSet instance to this instance that turns it into a shared mode. + * + * @param {ViewSizeSet} viewSize The instance of the ViewSizeSet class. + */ + + }, { + key: "append", + value: function append(viewSize) { + this.workingSpace = WORKING_SPACE_TOP; + viewSize.workingSpace = WORKING_SPACE_BOTTOM; + this.sharedSize = viewSize.getViewSize(); + } + /** + * Prepends the ViewSize instance to this instance that turns it into a shared mode. + * + * @param {ViewSizeSet} viewSize The instance of the ViewSizeSet class. + */ + + }, { + key: "prepend", + value: function prepend(viewSize) { + this.workingSpace = WORKING_SPACE_BOTTOM; + viewSize.workingSpace = WORKING_SPACE_TOP; + this.sharedSize = viewSize.getViewSize(); + } + }]); + + return ViewSizeSet; +}(); + +function _classCallCheck$8(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$8(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); } } + +function _createClass$8(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$8(Constructor.prototype, protoProps); if (staticProps) _defineProperties$8(Constructor, staticProps); return Constructor; } +/** + * Executive model for each table renderer. It's responsible for injecting DOM nodes in a + * specified order and adjusting the number of elements in the root node. + * + * Only this class have rights to juggling DOM elements within the root node (see render method). + * + * @class {OrderView} + */ + +var OrderView = /*#__PURE__*/function () { + function OrderView(rootNode, nodesPool, childNodeType) { + _classCallCheck$8(this, OrderView); + + /** + * The root node to manage with. + * + * @type {HTMLElement} + */ + this.rootNode = rootNode; + /** + * Factory for newly created DOM elements. + * + * @type {Function} + */ + + this.nodesPool = nodesPool; + /** + * Holder for sizing and positioning of the view. + * + * @type {ViewSizeSet} + */ + + this.sizeSet = new ViewSizeSet(); + /** + * Node type which the order view will manage while rendering the DOM elements. + * + * @type {string} + */ + + this.childNodeType = childNodeType.toUpperCase(); + /** + * The visual index of currently processed row. + * + * @type {number} + */ + + this.visualIndex = 0; + /** + * The list of DOM elements which are rendered for this render cycle. + * + * @type {HTMLElement[]} + */ + + this.collectedNodes = []; + } + /** + * Sets the size for rendered elements. It can be a size for rows, cells or size for row + * headers etc. It depends for what table renderer this instance was created. + * + * @param {number} size The size. + * @returns {OrderView} + */ + + + _createClass$8(OrderView, [{ + key: "setSize", + value: function setSize(size) { + this.sizeSet.setSize(size); + return this; + } + /** + * Sets the offset for rendered elements. The offset describes the shift between 0 and + * the first rendered element according to the scroll position. + * + * @param {number} offset The offset. + * @returns {OrderView} + */ + + }, { + key: "setOffset", + value: function setOffset(offset) { + this.sizeSet.setOffset(offset); + return this; + } + /** + * Checks if this instance of the view shares the root node with another instance. This happens only once when + * a row (TR) as a root node is managed by two OrderView instances. If this happens another DOM injection + * algorithm is performed to achieve consistent order. + * + * @returns {boolean} + */ + + }, { + key: "isSharedViewSet", + value: function isSharedViewSet() { + return this.sizeSet.isShared(); + } + /** + * Returns rendered DOM element based on visual index. + * + * @param {number} visualIndex The visual index. + * @returns {HTMLElement} + */ + + }, { + key: "getNode", + value: function getNode(visualIndex) { + return visualIndex < this.collectedNodes.length ? this.collectedNodes[visualIndex] : null; + } + /** + * Returns currently processed DOM element. + * + * @returns {HTMLElement} + */ + + }, { + key: "getCurrentNode", + value: function getCurrentNode() { + var length = this.collectedNodes.length; + return length > 0 ? this.collectedNodes[length - 1] : null; + } + /** + * Returns rendered child count for this instance. + * + * @returns {number} + */ + + }, { + key: "getRenderedChildCount", + value: function getRenderedChildCount() { + var rootNode = this.rootNode, + sizeSet = this.sizeSet; + var childElementCount = 0; + + if (this.isSharedViewSet()) { + var element = rootNode.firstElementChild; + + while (element) { + if (element.tagName === this.childNodeType) { + childElementCount += 1; + } else if (sizeSet.isPlaceOn(WORKING_SPACE_TOP)) { + break; + } + + element = element.nextElementSibling; + } + } else { + childElementCount = rootNode.childElementCount; + } + + return childElementCount; + } + /** + * Setups and prepares all necessary properties and start the rendering process. + * This method has to be called only once (at the start) for the render cycle. + */ + + }, { + key: "start", + value: function start() { + this.collectedNodes.length = 0; + this.visualIndex = 0; + var rootNode = this.rootNode, + sizeSet = this.sizeSet; + var isShared = this.isSharedViewSet(); + + var _sizeSet$getViewSize = sizeSet.getViewSize(), + nextSize = _sizeSet$getViewSize.nextSize; + + var childElementCount = this.getRenderedChildCount(); + + while (childElementCount < nextSize) { + var newNode = this.nodesPool(); + + if (!isShared || isShared && sizeSet.isPlaceOn(WORKING_SPACE_BOTTOM)) { + rootNode.appendChild(newNode); + } else { + rootNode.insertBefore(newNode, rootNode.firstChild); + } + + childElementCount += 1; + } + + var isSharedPlacedOnTop = isShared && sizeSet.isPlaceOn(WORKING_SPACE_TOP); + + while (childElementCount > nextSize) { + rootNode.removeChild(isSharedPlacedOnTop ? rootNode.firstChild : rootNode.lastChild); + childElementCount -= 1; + } + } + /** + * Renders the DOM element based on visual index (which is calculated internally). + * This method has to be called as many times as the size count is met (to cover all previously rendered DOM elements). + */ + + }, { + key: "render", + value: function render() { + var rootNode = this.rootNode, + sizeSet = this.sizeSet; + var visualIndex = this.visualIndex; + + if (this.isSharedViewSet() && sizeSet.isPlaceOn(WORKING_SPACE_BOTTOM)) { + visualIndex += sizeSet.sharedSize.nextSize; + } + + var node = rootNode.childNodes[visualIndex]; + + if (node.tagName !== this.childNodeType) { + var newNode = this.nodesPool(); + rootNode.replaceChild(newNode, node); + node = newNode; + } + + this.collectedNodes.push(node); + this.visualIndex += 1; + } + /** + * Ends the render process. + * This method has to be called only once (at the end) for the render cycle. + */ + + }, { + key: "end", + value: function end() {} + }]); + + return OrderView; +}(); + +function _typeof$4(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$4 = function _typeof(obj) { return typeof obj; }; } else { _typeof$4 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$4(obj); } + +function _classCallCheck$9(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$9(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); } } + +function _createClass$9(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$9(Constructor.prototype, protoProps); if (staticProps) _defineProperties$9(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof$4(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } +/** + * Executive model for TR root nodes. + * + * @class {SharedOrderView} + */ + +var SharedOrderView = /*#__PURE__*/function (_OrderView) { + _inherits(SharedOrderView, _OrderView); + + var _super = _createSuper(SharedOrderView); + + function SharedOrderView() { + _classCallCheck$9(this, SharedOrderView); + + return _super.apply(this, arguments); + } + + _createClass$9(SharedOrderView, [{ + key: "prependView", + value: + /** + * The method results in merging external order view into the current order. This happens only for order views which + * operate on the same root node. + * + * In the table, there is only one scenario when this happens. TR root element + * has a common root node with cells order view and row headers order view. Both classes have to share + * information about their order sizes to make proper diff calculations. + * + * @param {OrderView} orderView The order view to merging with. The view will be added at the beginning of the list. + * @returns {SharedOrderView} + */ + function prependView(orderView) { + this.sizeSet.prepend(orderView.sizeSet); + orderView.sizeSet.append(this.sizeSet); + return this; + } + /** + * The method results in merging external order view into the current order. This happens only for order views which + * operate on the same root node. + * + * In the table, there is only one scenario when this happens. TR root element + * has a common root node with cells order view and row headers order view. Both classes have to share + * information about their order sizes to make proper diff calculations. + * + * @param {OrderView} orderView The order view to merging with. The view will be added at the end of the list. + * @returns {SharedOrderView} + */ + + }, { + key: "appendView", + value: function appendView(orderView) { + this.sizeSet.append(orderView.sizeSet); + orderView.sizeSet.prepend(this.sizeSet); + return this; + } + }]); + + return SharedOrderView; +}(OrderView); + +function _classCallCheck$a(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$a(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); } } + +function _createClass$a(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$a(Constructor.prototype, protoProps); if (staticProps) _defineProperties$a(Constructor, staticProps); return Constructor; } + +/** + * Factory for newly created DOM elements. + * + * @class {NodesPool} + */ +var NodesPool = /*#__PURE__*/function () { + function NodesPool(nodeType) { + _classCallCheck$a(this, NodesPool); + + /** + * Node type to generate (ew 'th', 'td'). + * + * @type {string} + */ + this.nodeType = nodeType.toUpperCase(); + } + /** + * Set document owner for this instance. + * + * @param {HTMLDocument} rootDocument The document window owner. + */ + + + _createClass$a(NodesPool, [{ + key: "setRootDocument", + value: function setRootDocument(rootDocument) { + this.rootDocument = rootDocument; + } + /** + * Obtains an element. The returned elements in the feature can be cached. + * + * @returns {HTMLElement} + */ + + }, { + key: "obtain", + value: function obtain() { + return this.rootDocument.createElement(this.nodeType); + } + }]); + + return NodesPool; +}(); + +function _classCallCheck$b(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$b(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); } } + +function _createClass$b(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$b(Constructor.prototype, protoProps); if (staticProps) _defineProperties$b(Constructor, staticProps); return Constructor; } +/** + * Base renderer class, abstract logic for specialized renderers. + * + * @class BaseRenderer + */ + +var BaseRenderer = /*#__PURE__*/function () { + function BaseRenderer(nodeType, rootNode) { + _classCallCheck$b(this, BaseRenderer); + + /** + * Factory for newly created DOM elements. + * + * NodePool should be used for each renderer. For the first stage of the refactoring + * process, only some of the renderers are implemented a new approach. + * + * @type {NodesPool|null} + */ + this.nodesPool = typeof nodeType === 'string' ? new NodesPool(nodeType) : null; + /** + * Node type which the renderer will manage while building the table (eg. 'TD', 'TR', 'TH'). + * + * @type {string} + */ + + this.nodeType = nodeType; + /** + * The root node to which newly created elements will be inserted. + * + * @type {HTMLElement} + */ + + this.rootNode = rootNode; + /** + * The instance of the Table class, a wrapper for all renderers and holder for properties describe table state. + * + * @type {TableRenderer} + */ + + this.table = null; + /** + * Counter of nodes already added. + * + * @type {number} + */ + + this.renderedNodes = 0; + } + /** + * Sets the table renderer instance to the current renderer. + * + * @param {TableRenderer} table The TableRenderer instance. + */ + + + _createClass$b(BaseRenderer, [{ + key: "setTable", + value: function setTable(table) { + if (this.nodesPool) { + this.nodesPool.setRootDocument(table.rootDocument); + } + + this.table = table; + } + /** + * Adjusts the number of rendered nodes. + */ + + }, { + key: "adjust", + value: function adjust() {} + /** + * Renders the contents to the elements. + */ + + }, { + key: "render", + value: function render() {} + }]); + + return BaseRenderer; +}(); + +function _typeof$5(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$5 = function _typeof(obj) { return typeof obj; }; } else { _typeof$5 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$5(obj); } + +function _classCallCheck$c(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$c(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); } } + +function _createClass$c(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$c(Constructor.prototype, protoProps); if (staticProps) _defineProperties$c(Constructor, staticProps); return Constructor; } + +function _inherits$1(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1(subClass, superClass); } + +function _setPrototypeOf$1(o, p) { _setPrototypeOf$1 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1(o, p); } + +function _createSuper$1(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1(); return function _createSuperInternal() { var Super = _getPrototypeOf$1(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1(this, result); }; } + +function _possibleConstructorReturn$1(self, call) { if (call && (_typeof$5(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1(self); } + +function _assertThisInitialized$1(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1(o) { _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1(o); } +/** + * Row headers renderer responsible for managing (inserting, tracking, rendering) TR elements belongs to TR. + * + *
(root node) + * ├ --- RowHeadersRenderer + * ├ \ + * ├ \ + * ├ - CellsRenderer + * ├ / + * └ /. + * + * @class {CellsRenderer} + */ + +var RowHeadersRenderer = /*#__PURE__*/function (_BaseRenderer) { + _inherits$1(RowHeadersRenderer, _BaseRenderer); + + var _super = _createSuper$1(RowHeadersRenderer); + + function RowHeadersRenderer() { + var _this; + + _classCallCheck$c(this, RowHeadersRenderer); + + _this = _super.call(this, 'TH'); + /** + * Cache for OrderView classes connected to specified node. + * + * @type {WeakMap} + */ + + _this.orderViews = new WeakMap(); + /** + * Row index which specifies the row position of the processed row header. + * + * @type {number} + */ + + _this.sourceRowIndex = 0; + return _this; + } + /** + * Obtains the instance of the SharedOrderView class which is responsible for rendering the nodes to the root node. + * + * @param {HTMLTableRowElement} rootNode The TR element, which is root element for row headers (TH). + * @returns {SharedOrderView} + */ + + + _createClass$c(RowHeadersRenderer, [{ + key: "obtainOrderView", + value: function obtainOrderView(rootNode) { + var _this2 = this; + + var orderView; + + if (this.orderViews.has(rootNode)) { + orderView = this.orderViews.get(rootNode); + } else { + orderView = new SharedOrderView(rootNode, function (sourceColumnIndex) { + return _this2.nodesPool.obtain(_this2.sourceRowIndex, sourceColumnIndex); + }, this.nodeType); + this.orderViews.set(rootNode, orderView); + } + + return orderView; + } + /** + * Renders the cells. + */ + + }, { + key: "render", + value: function render() { + var _this$table = this.table, + rowsToRender = _this$table.rowsToRender, + rowHeaderFunctions = _this$table.rowHeaderFunctions, + rowHeadersCount = _this$table.rowHeadersCount, + rows = _this$table.rows, + cells = _this$table.cells; + + for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) { + var sourceRowIndex = this.table.renderedRowToSource(visibleRowIndex); + var TR = rows.getRenderedNode(visibleRowIndex); + this.sourceRowIndex = sourceRowIndex; + var orderView = this.obtainOrderView(TR); + var cellsView = cells.obtainOrderView(TR); + orderView.appendView(cellsView).setSize(rowHeadersCount).setOffset(this.table.renderedColumnToSource(0)).start(); + + for (var visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) { + orderView.render(); + var TH = orderView.getCurrentNode(); + TH.className = ''; + TH.removeAttribute('style'); + rowHeaderFunctions[visibleColumnIndex](sourceRowIndex, TH, visibleColumnIndex); + } + + orderView.end(); + } + } + }]); + + return RowHeadersRenderer; +}(BaseRenderer); + +function _typeof$6(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$6 = function _typeof(obj) { return typeof obj; }; } else { _typeof$6 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$6(obj); } + +function _classCallCheck$d(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$d(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); } } + +function _createClass$d(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$d(Constructor.prototype, protoProps); if (staticProps) _defineProperties$d(Constructor, staticProps); return Constructor; } + +function _inherits$2(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$2(subClass, superClass); } + +function _setPrototypeOf$2(o, p) { _setPrototypeOf$2 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$2(o, p); } + +function _createSuper$2(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$2(); return function _createSuperInternal() { var Super = _getPrototypeOf$2(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$2(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$2(this, result); }; } + +function _possibleConstructorReturn$2(self, call) { if (call && (_typeof$6(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$2(self); } + +function _assertThisInitialized$2(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$2() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$2(o) { _getPrototypeOf$2 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$2(o); } +/** + * Column headers renderer responsible for managing (inserting, tracking, rendering) TR and TH elements. + * + * (root node) + * ├
\ + * ├
\ + * ├
- ColumnHeadersRenderer + * ├
/ + * â””
/. + * + * @class {ColumnHeadersRenderer} + */ + +var ColumnHeadersRenderer = /*#__PURE__*/function (_BaseRenderer) { + _inherits$2(ColumnHeadersRenderer, _BaseRenderer); + + var _super = _createSuper$2(ColumnHeadersRenderer); + + function ColumnHeadersRenderer(rootNode) { + _classCallCheck$d(this, ColumnHeadersRenderer); + + return _super.call(this, null, rootNode); // NodePool is not implemented for this renderer yet + } + /** + * Adjusts the number of the rendered elements. + */ + + + _createClass$d(ColumnHeadersRenderer, [{ + key: "adjust", + value: function adjust() { + var _this$table = this.table, + columnHeadersCount = _this$table.columnHeadersCount, + rowHeadersCount = _this$table.rowHeadersCount; + var TR = this.rootNode.firstChild; + + if (columnHeadersCount) { + var columnsToRender = this.table.columnsToRender; + var allColumnsToRender = columnsToRender + rowHeadersCount; + + for (var i = 0, len = columnHeadersCount; i < len; i++) { + TR = this.rootNode.childNodes[i]; + + if (!TR) { + TR = this.table.rootDocument.createElement('tr'); + this.rootNode.appendChild(TR); + } + + this.renderedNodes = TR.childNodes.length; + + while (this.renderedNodes < allColumnsToRender) { + TR.appendChild(this.table.rootDocument.createElement('th')); + this.renderedNodes += 1; + } + + while (this.renderedNodes > allColumnsToRender) { + TR.removeChild(TR.lastChild); + this.renderedNodes -= 1; + } + } + + var theadChildrenLength = this.rootNode.childNodes.length; + + if (theadChildrenLength > columnHeadersCount) { + for (var _i = columnHeadersCount; _i < theadChildrenLength; _i++) { + this.rootNode.removeChild(this.rootNode.lastChild); + } + } + } else if (TR) { + empty(TR); + } + } + /** + * Renders the TH elements. + */ + + }, { + key: "render", + value: function render() { + var columnHeadersCount = this.table.columnHeadersCount; + + for (var rowHeaderIndex = 0; rowHeaderIndex < columnHeadersCount; rowHeaderIndex += 1) { + var _this$table2 = this.table, + columnHeaderFunctions = _this$table2.columnHeaderFunctions, + columnsToRender = _this$table2.columnsToRender, + rowHeadersCount = _this$table2.rowHeadersCount; + var TR = this.rootNode.childNodes[rowHeaderIndex]; + + for (var renderedColumnIndex = -1 * rowHeadersCount; renderedColumnIndex < columnsToRender; renderedColumnIndex += 1) { + // eslint-disable-line max-len + var sourceColumnIndex = this.table.renderedColumnToSource(renderedColumnIndex); + var TH = TR.childNodes[renderedColumnIndex + rowHeadersCount]; + TH.className = ''; + TH.removeAttribute('style'); + columnHeaderFunctions[rowHeaderIndex](sourceColumnIndex, TH, rowHeaderIndex); + } + } + } + }]); + + return ColumnHeadersRenderer; +}(BaseRenderer); + +function _typeof$7(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$7 = function _typeof(obj) { return typeof obj; }; } else { _typeof$7 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$7(obj); } + +function _classCallCheck$e(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$e(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); } } + +function _createClass$e(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$e(Constructor.prototype, protoProps); if (staticProps) _defineProperties$e(Constructor, staticProps); return Constructor; } + +function _inherits$3(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$3(subClass, superClass); } + +function _setPrototypeOf$3(o, p) { _setPrototypeOf$3 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$3(o, p); } + +function _createSuper$3(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$3(); return function _createSuperInternal() { var Super = _getPrototypeOf$3(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$3(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$3(this, result); }; } + +function _possibleConstructorReturn$3(self, call) { if (call && (_typeof$7(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$3(self); } + +function _assertThisInitialized$3(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$3() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$3(o) { _getPrototypeOf$3 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$3(o); } +/** + * Colgroup renderer responsible for managing (inserting, tracking, rendering) COL elements. + * + * (root node) + * ├ \ + * ├ \ + * ├ - ColGroupRenderer + * ├ / + * └ /. + * + * @class {ColGroupRenderer} + */ + +var ColGroupRenderer = /*#__PURE__*/function (_BaseRenderer) { + _inherits$3(ColGroupRenderer, _BaseRenderer); + + var _super = _createSuper$3(ColGroupRenderer); + + function ColGroupRenderer(rootNode) { + _classCallCheck$e(this, ColGroupRenderer); + + return _super.call(this, null, rootNode); // NodePool is not implemented for this renderer yet + } + /** + * Adjusts the number of the rendered elements. + */ + + + _createClass$e(ColGroupRenderer, [{ + key: "adjust", + value: function adjust() { + var _this$table = this.table, + columnsToRender = _this$table.columnsToRender, + rowHeadersCount = _this$table.rowHeadersCount; + var allColumnsToRender = columnsToRender + rowHeadersCount; + + while (this.renderedNodes < allColumnsToRender) { + this.rootNode.appendChild(this.table.rootDocument.createElement('col')); + this.renderedNodes += 1; + } + + while (this.renderedNodes > allColumnsToRender) { + this.rootNode.removeChild(this.rootNode.lastChild); + this.renderedNodes -= 1; + } + } + /** + * Renders the col group elements. + */ + + }, { + key: "render", + value: function render() { + this.adjust(); + var _this$table2 = this.table, + columnsToRender = _this$table2.columnsToRender, + rowHeadersCount = _this$table2.rowHeadersCount; // Render column nodes for row headers + + for (var visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) { + var sourceColumnIndex = this.table.renderedColumnToSource(visibleColumnIndex); + var width = this.table.columnUtils.getHeaderWidth(sourceColumnIndex); + this.rootNode.childNodes[visibleColumnIndex].style.width = "".concat(width, "px"); + } // Render column nodes for cells + + + for (var _visibleColumnIndex = 0; _visibleColumnIndex < columnsToRender; _visibleColumnIndex++) { + var _sourceColumnIndex = this.table.renderedColumnToSource(_visibleColumnIndex); + + var _width = this.table.columnUtils.getStretchedColumnWidth(_sourceColumnIndex); + + this.rootNode.childNodes[_visibleColumnIndex + rowHeadersCount].style.width = "".concat(_width, "px"); + } + + var firstChild = this.rootNode.firstChild; + + if (firstChild) { + addClass(firstChild, 'rowHeader'); + } + } + }]); + + return ColGroupRenderer; +}(BaseRenderer); + +/* eslint-disable no-console */ +/** + * Logs warn to the console if the `console` object is exposed. + * + * @param {...*} args Values which will be logged. + */ + +function warn() { + if (isDefined(console)) { + var _console2; + + (_console2 = console).warn.apply(_console2, arguments); + } +} +/** + * Logs error to the console if the `console` object is exposed. + * + * @param {...*} args Values which will be logged. + */ + +function error() { + if (isDefined(console)) { + var _console4; + + (_console4 = console).error.apply(_console4, arguments); + } +} + +function _typeof$8(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$8 = function _typeof(obj) { return typeof obj; }; } else { _typeof$8 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$8(obj); } + +var _templateObject$1; + +function _taggedTemplateLiteral$1(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _classCallCheck$f(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$f(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); } } + +function _createClass$f(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$f(Constructor.prototype, protoProps); if (staticProps) _defineProperties$f(Constructor, staticProps); return Constructor; } + +function _inherits$4(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$4(subClass, superClass); } + +function _setPrototypeOf$4(o, p) { _setPrototypeOf$4 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$4(o, p); } + +function _createSuper$4(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$4(); return function _createSuperInternal() { var Super = _getPrototypeOf$4(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$4(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$4(this, result); }; } + +function _possibleConstructorReturn$4(self, call) { if (call && (_typeof$8(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$4(self); } + +function _assertThisInitialized$4(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$4() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$4(o) { _getPrototypeOf$4 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$4(o); } +var performanceWarningAppeared = false; +/** + * Rows renderer responsible for managing (inserting, tracking, rendering) TR elements belongs to TBODY. + * + * (root node) + * ├
\ + * ├
\ + * ├
- RowsRenderer + * ├
/ + * â””
/. + * + * @class {RowsRenderer} + */ + +var RowsRenderer = /*#__PURE__*/function (_BaseRenderer) { + _inherits$4(RowsRenderer, _BaseRenderer); + + var _super = _createSuper$4(RowsRenderer); + + function RowsRenderer(rootNode) { + var _this; + + _classCallCheck$f(this, RowsRenderer); + + _this = _super.call(this, 'TR', rootNode); + /** + * Cache for OrderView classes connected to specified node. + * + * @type {WeakMap} + */ + + _this.orderView = new OrderView(rootNode, function (sourceRowIndex) { + return _this.nodesPool.obtain(sourceRowIndex); + }, _this.nodeType); + return _this; + } + /** + * Returns currently rendered node. + * + * @param {string} visualIndex Visual index of the rendered node (it always goeas from 0 to N). + * @returns {HTMLTableRowElement} + */ + + + _createClass$f(RowsRenderer, [{ + key: "getRenderedNode", + value: function getRenderedNode(visualIndex) { + return this.orderView.getNode(visualIndex); + } + /** + * Renders the cells. + */ + + }, { + key: "render", + value: function render() { + var rowsToRender = this.table.rowsToRender; + + if (!performanceWarningAppeared && rowsToRender > 1000) { + performanceWarningAppeared = true; + warn(toSingleLine(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral$1(["Performance tip: Handsontable rendered more than 1000 visible rows. Consider limiting \n the number of rendered rows by specifying the table height and/or turning off the \"renderAllRows\" option."], ["Performance tip: Handsontable rendered more than 1000 visible rows. Consider limiting\\x20\n the number of rendered rows by specifying the table height and/or turning off the \"renderAllRows\" option."])))); + } + + this.orderView.setSize(rowsToRender).setOffset(this.table.renderedRowToSource(0)).start(); + + for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) { + this.orderView.render(); + } + + this.orderView.end(); + } + }]); + + return RowsRenderer; +}(BaseRenderer); + +function _typeof$9(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$9 = function _typeof(obj) { return typeof obj; }; } else { _typeof$9 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$9(obj); } + +function _classCallCheck$g(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$g(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); } } + +function _createClass$g(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$g(Constructor.prototype, protoProps); if (staticProps) _defineProperties$g(Constructor, staticProps); return Constructor; } + +function _inherits$5(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$5(subClass, superClass); } + +function _setPrototypeOf$5(o, p) { _setPrototypeOf$5 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$5(o, p); } + +function _createSuper$5(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$5(); return function _createSuperInternal() { var Super = _getPrototypeOf$5(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$5(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$5(this, result); }; } + +function _possibleConstructorReturn$5(self, call) { if (call && (_typeof$9(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$5(self); } + +function _assertThisInitialized$5(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$5() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$5(o) { _getPrototypeOf$5 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$5(o); } +/** + * Cell renderer responsible for managing (inserting, tracking, rendering) TD elements. + * + *
(root node) + * ├ --- RowHeadersRenderer + * ├ \ + * ├ \ + * ├ - CellsRenderer + * ├ / + * └ /. + * + * @class {CellsRenderer} + */ + +var CellsRenderer = /*#__PURE__*/function (_BaseRenderer) { + _inherits$5(CellsRenderer, _BaseRenderer); + + var _super = _createSuper$5(CellsRenderer); + + function CellsRenderer() { + var _this; + + _classCallCheck$g(this, CellsRenderer); + + _this = _super.call(this, 'TD'); + /** + * Cache for OrderView classes connected to specified node. + * + * @type {WeakMap} + */ + + _this.orderViews = new WeakMap(); + /** + * Row index which specifies the row position of the processed cell. + * + * @type {number} + */ + + _this.sourceRowIndex = 0; + return _this; + } + /** + * Obtains the instance of the SharedOrderView class which is responsible for rendering the nodes to the root node. + * + * @param {HTMLTableRowElement} rootNode The TR element, which is root element for cells (TD). + * @returns {SharedOrderView} + */ + + + _createClass$g(CellsRenderer, [{ + key: "obtainOrderView", + value: function obtainOrderView(rootNode) { + var _this2 = this; + + var orderView; + + if (this.orderViews.has(rootNode)) { + orderView = this.orderViews.get(rootNode); + } else { + orderView = new SharedOrderView(rootNode, function (sourceColumnIndex) { + return _this2.nodesPool.obtain(_this2.sourceRowIndex, sourceColumnIndex); + }, this.nodeType); + this.orderViews.set(rootNode, orderView); + } + + return orderView; + } + /** + * Renders the cells. + */ + + }, { + key: "render", + value: function render() { + var _this$table = this.table, + rowsToRender = _this$table.rowsToRender, + columnsToRender = _this$table.columnsToRender, + rows = _this$table.rows, + rowHeaders = _this$table.rowHeaders; + + for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) { + var sourceRowIndex = this.table.renderedRowToSource(visibleRowIndex); + var TR = rows.getRenderedNode(visibleRowIndex); + this.sourceRowIndex = sourceRowIndex; + var orderView = this.obtainOrderView(TR); + var rowHeadersView = rowHeaders.obtainOrderView(TR); // @TODO(perf-tip): For cells other than "visual 0" generating diff leads/commands can be skipped. New order view + // shoule share state between next orderViews. + + orderView.prependView(rowHeadersView).setSize(columnsToRender).setOffset(this.table.renderedColumnToSource(0)).start(); + + for (var visibleColumnIndex = 0; visibleColumnIndex < columnsToRender; visibleColumnIndex++) { + orderView.render(); + var TD = orderView.getCurrentNode(); + var sourceColumnIndex = this.table.renderedColumnToSource(visibleColumnIndex); + + if (!hasClass(TD, 'hide')) { + // Workaround for hidden columns plugin + TD.className = ''; + } + + TD.removeAttribute('style'); + this.table.cellRenderer(sourceRowIndex, sourceColumnIndex, TD); + } + + orderView.end(); + } + } + }]); + + return CellsRenderer; +}(BaseRenderer); + +function _classCallCheck$h(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$h(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); } } + +function _createClass$h(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$h(Constructor.prototype, protoProps); if (staticProps) _defineProperties$h(Constructor, staticProps); return Constructor; } + +/** + * TableRenderer class collects all renderers and properties necessary for table creation. It's + * responsible for adjusting and rendering each renderer. + * + * Below is a diagram of the renderers together with an indication of what they are responisble for. + *
+ * \ (root node) + * \ + * \___ ColGroupRenderer + * / + * / + * / + * \ (root node) + * \ + * / + * / + * ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\ (root node) + * (root node) \ + * \ + * (root node) \ + * / + * (root node) / + * / + * ___________________/ + *
\ + * \____ ColumnHeadersRenderer + * / + * / + *
--- RowHeadersRenderer + * \ \ + * -- CellsRenderer \ + * / \ + *
--- RowHeadersRenderer \ + * \ \___ RowsRenderer + * -- CellsRenderer / + * / / + *
--- RowHeadersRenderer / + * \ / + * -- CellsRenderer / + * / / + *
. + * + * @class {RowsRenderer} + */ +var TableRenderer = /*#__PURE__*/function () { + function TableRenderer(rootNode) { + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + cellRenderer = _ref.cellRenderer; + + _classCallCheck$h(this, TableRenderer); + + /** + * Table element which will be used to render the children element. + * + * @type {HTMLTableElement} + */ + this.rootNode = rootNode; + /** + * Document owner of the root node. + * + * @type {HTMLDocument} + */ + + this.rootDocument = this.rootNode.ownerDocument; + /** + * Renderer class responsible for rendering row headers. + * + * @type {RowsRenderer} + */ + + this.rowHeaders = null; + /** + * Renderer class responsible for rendering column headers. + * + * @type {ColumnHeadersRenderer} + */ + + this.columnHeaders = null; + /** + * Renderer class responsible for rendering col in colgroup. + * + * @type {ColGroupRenderer} + */ + + this.colGroup = null; + /** + * Renderer class responsible for rendering rows in tbody. + * + * @type {RowsRenderer} + */ + + this.rows = null; + /** + * Renderer class responsible for rendering cells. + * + * @type {CellsRenderer} + */ + + this.cells = null; + /** + * Row filter which contains all necessary information about row index transformation. + * + * @type {RowFilter} + */ + + this.rowFilter = null; + /** + * Column filter which contains all necessary information about column index transformation. + * + * @type {ColumnFilter} + */ + + this.columnFilter = null; + /** + * Row utils class which contains all necessary information about sizes of the rows. + * + * @type {RowUtils} + */ + + this.rowUtils = null; + /** + * Column utils class which contains all necessary information about sizes of the columns. + * + * @type {ColumnUtils} + */ + + this.columnUtils = null; + /** + * Indicates how much rows should be rendered to fill whole table viewport. + * + * @type {number} + */ + + this.rowsToRender = 0; + /** + * Indicates how much columns should be rendered to fill whole table viewport. + * + * @type {number} + */ + + this.columnsToRender = 0; + /** + * An array of functions to be used as a content factory to row headers. + * + * @type {Function[]} + */ + + this.rowHeaderFunctions = []; + /** + * Count of the function used to render row headers. + * + * @type {number} + */ + + this.rowHeadersCount = 0; + /** + * An array of functions to be used as a content factory to column headers. + * + * @type {Function[]} + */ + + this.columnHeaderFunctions = []; + /** + * Count of the function used to render column headers. + * + * @type {number} + */ + + this.columnHeadersCount = 0; + /** + * Cell renderer used to render cells content. + * + * @type {Function} + */ + + this.cellRenderer = cellRenderer; + } + /** + * Set row and column util classes. + * + * @param {RowUtils} rowUtils RowUtils instance which provides useful methods related to row sizes. + * @param {ColumnUtils} columnUtils ColumnUtils instance which provides useful methods related to row sizes. + */ + + + _createClass$h(TableRenderer, [{ + key: "setAxisUtils", + value: function setAxisUtils(rowUtils, columnUtils) { + this.rowUtils = rowUtils; + this.columnUtils = columnUtils; + } + /** + * Sets viewport size of the table. + * + * @param {number} rowsCount An amount of rows to render. + * @param {number} columnsCount An amount of columns to render. + */ + + }, { + key: "setViewportSize", + value: function setViewportSize(rowsCount, columnsCount) { + this.rowsToRender = rowsCount; + this.columnsToRender = columnsCount; + } + /** + * Sets row and column filter instances. + * + * @param {RowFilter} rowFilter Row filter instance which contains all necessary information about row index transformation. + * @param {ColumnFilter} columnFilter Cokumn filter instance which contains all necessary information about row index transformation. + */ + + }, { + key: "setFilters", + value: function setFilters(rowFilter, columnFilter) { + this.rowFilter = rowFilter; + this.columnFilter = columnFilter; + } + /** + * Sets row and column header functions. + * + * @param {Function[]} rowHeaders Row header functions. Factories for creating content for row headers. + * @param {Function[]} columnHeaders Column header functions. Factories for creating content for column headers. + */ + + }, { + key: "setHeaderContentRenderers", + value: function setHeaderContentRenderers(rowHeaders, columnHeaders) { + this.rowHeaderFunctions = rowHeaders; + this.rowHeadersCount = rowHeaders.length; + this.columnHeaderFunctions = columnHeaders; + this.columnHeadersCount = columnHeaders.length; + } + /** + * Sets table renderers. + * + * @param {renderers} renderers The renderer units. + * @param {RowHeadersRenderer} renderers.rowHeaders Row headers renderer. + * @param {ColumnHeadersRenderer} renderers.columnHeaders Column headers renderer. + * @param {ColGroupRenderer} renderers.colGroup Col group renderer. + * @param {RowsRenderer} renderers.rows Rows renderer. + * @param {CellsRenderer} renderers.cells Cells renderer. + */ + + }, { + key: "setRenderers", + value: function setRenderers() { + var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + rowHeaders = _ref2.rowHeaders, + columnHeaders = _ref2.columnHeaders, + colGroup = _ref2.colGroup, + rows = _ref2.rows, + cells = _ref2.cells; + + rowHeaders.setTable(this); + columnHeaders.setTable(this); + colGroup.setTable(this); + rows.setTable(this); + cells.setTable(this); + this.rowHeaders = rowHeaders; + this.columnHeaders = columnHeaders; + this.colGroup = colGroup; + this.rows = rows; + this.cells = cells; + } + /** + * Transforms visual/rendered row index to source index. + * + * @param {number} rowIndex Rendered index. + * @returns {number} + */ + + }, { + key: "renderedRowToSource", + value: function renderedRowToSource(rowIndex) { + return this.rowFilter.renderedToSource(rowIndex); + } + /** + * Transforms visual/rendered column index to source index. + * + * @param {number} columnIndex Rendered index. + * @returns {number} + */ + + }, { + key: "renderedColumnToSource", + value: function renderedColumnToSource(columnIndex) { + return this.columnFilter.renderedToSource(columnIndex); + } + /** + * Renders the table. + */ + + }, { + key: "render", + value: function render() { + this.colGroup.adjust(); + this.columnHeaders.adjust(); + this.rows.adjust(); + this.rowHeaders.adjust(); + this.columnHeaders.render(); + this.rows.render(); + this.rowHeaders.render(); + this.cells.render(); // After the cells are rendered calculate columns width (or columns stretch width) to prepare proper values + // for colGroup renderer (which renders COL elements). + + this.columnUtils.calculateWidths(); + this.colGroup.render(); + var rowsToRender = this.rowsToRender, + rows = this.rows; // Fix for multi-line content and for supporting `rowHeights` option. + + for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) { + var TR = rows.getRenderedNode(visibleRowIndex); + + if (TR.firstChild) { + var sourceRowIndex = this.renderedRowToSource(visibleRowIndex); + var rowHeight = this.rowUtils.getHeight(sourceRowIndex); + + if (rowHeight) { + // Decrease height. 1 pixel will be "replaced" by 1px border top + TR.firstChild.style.height = "".concat(rowHeight - 1, "px"); + } else { + TR.firstChild.style.height = ''; + } + } + } + } + }]); + + return TableRenderer; +}(); + +function _classCallCheck$i(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$i(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); } } + +function _createClass$i(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$i(Constructor.prototype, protoProps); if (staticProps) _defineProperties$i(Constructor, staticProps); return Constructor; } +/** + * Content renderer. + * + * @class Renderer + */ + +var Renderer = /*#__PURE__*/function () { + function Renderer() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + TABLE = _ref.TABLE, + THEAD = _ref.THEAD, + COLGROUP = _ref.COLGROUP, + TBODY = _ref.TBODY, + rowUtils = _ref.rowUtils, + columnUtils = _ref.columnUtils, + cellRenderer = _ref.cellRenderer; + + _classCallCheck$i(this, Renderer); + + /** + * General renderer class used to render Walkontable content on screen. + * + * @type {TableRenderer} + */ + this.renderer = new TableRenderer(TABLE, { + cellRenderer: cellRenderer + }); + this.renderer.setRenderers({ + rowHeaders: new RowHeadersRenderer(), + columnHeaders: new ColumnHeadersRenderer(THEAD), + colGroup: new ColGroupRenderer(COLGROUP), + rows: new RowsRenderer(TBODY), + cells: new CellsRenderer() + }); + this.renderer.setAxisUtils(rowUtils, columnUtils); + } + /** + * Sets filter calculators for newly calculated row and column position. The filters are used to transform visual + * indexes (0 to N) to source indexes provided by Handsontable. + * + * @param {RowFilter} rowFilter The row filter instance. + * @param {ColumnFilter} columnFilter The column filter instance. + * @returns {Renderer} + */ + + + _createClass$i(Renderer, [{ + key: "setFilters", + value: function setFilters(rowFilter, columnFilter) { + this.renderer.setFilters(rowFilter, columnFilter); + return this; + } + /** + * Sets the viewport size of the rendered table. + * + * @param {number} rowsCount An amount of rows to render. + * @param {number} columnsCount An amount of columns to render. + * @returns {Renderer} + */ + + }, { + key: "setViewportSize", + value: function setViewportSize(rowsCount, columnsCount) { + this.renderer.setViewportSize(rowsCount, columnsCount); + return this; + } + /** + * Sets row and column header functions. + * + * @param {Function[]} rowHeaders Row header functions. Factories for creating content for row headers. + * @param {Function[]} columnHeaders Column header functions. Factories for creating content for column headers. + * @returns {Renderer} + */ + + }, { + key: "setHeaderContentRenderers", + value: function setHeaderContentRenderers(rowHeaders, columnHeaders) { + this.renderer.setHeaderContentRenderers(rowHeaders, columnHeaders); + return this; + } + /** + * Adjusts the table (preparing for render). + */ + + }, { + key: "adjust", + value: function adjust() { + this.renderer.adjust(); + } + /** + * Renders the table. + */ + + }, { + key: "render", + value: function render() { + this.renderer.render(); + } + }]); + + return Renderer; +}(); + +// `Map` constructor +// https://tc39.es/ecma262/#sec-map-objects +collection('Map', function (init) { + return function Map() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionStrong); + +function _typeof$a(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$a = function _typeof(obj) { return typeof obj; }; } else { _typeof$a = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$a(obj); } + +function _classCallCheck$j(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$j(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); } } + +function _createClass$j(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$j(Constructor.prototype, protoProps); if (staticProps) _defineProperties$j(Constructor, staticProps); return Constructor; } +/** + * Column utils class contains all necessary information about sizes of the columns. + * + * @class {ColumnUtils} + */ + +var ColumnUtils = /*#__PURE__*/function () { + function ColumnUtils(wot) { + _classCallCheck$j(this, ColumnUtils); + + this.wot = wot; + this.headerWidths = new Map(); + } + /** + * Returns column width based on passed source index. + * + * @param {number} sourceIndex Column source index. + * @returns {number} + */ + + + _createClass$j(ColumnUtils, [{ + key: "getWidth", + value: function getWidth(sourceIndex) { + var width = this.wot.wtSettings.settings.columnWidth; + + if (typeof width === 'function') { + width = width(sourceIndex); + } else if (_typeof$a(width) === 'object') { + width = width[sourceIndex]; + } + + return width || this.wot.wtSettings.settings.defaultColumnWidth; + } + /** + * Returns stretched column width based on passed source index. + * + * @param {number} sourceIndex Column source index. + * @returns {number} + */ + + }, { + key: "getStretchedColumnWidth", + value: function getStretchedColumnWidth(sourceIndex) { + var columnWidth = this.getWidth(sourceIndex); + var calculator = this.wot.wtViewport.columnsRenderCalculator; + var width = columnWidth !== null && columnWidth !== void 0 ? columnWidth : this.wot.wtSettings.settings.defaultColumnWidth; + + if (calculator) { + var stretchedWidth = calculator.getStretchedColumnWidth(sourceIndex, width); + + if (stretchedWidth) { + width = stretchedWidth; + } + } + + return width; + } + /** + * Returns column header height based on passed header level. + * + * @param {number} level Column header level. + * @returns {number} + */ + + }, { + key: "getHeaderHeight", + value: function getHeaderHeight(level) { + var height = this.wot.wtSettings.settings.defaultRowHeight; + var oversizedHeight = this.wot.wtViewport.oversizedColumnHeaders[level]; + + if (oversizedHeight !== void 0) { + height = height ? Math.max(height, oversizedHeight) : oversizedHeight; + } + + return height; + } + /** + * Returns column header width based on passed source index. + * + * @param {number} sourceIndex Column source index. + * @returns {number} + */ + + }, { + key: "getHeaderWidth", + value: function getHeaderWidth(sourceIndex) { + return this.headerWidths.get(this.wot.wtTable.columnFilter.sourceToRendered(sourceIndex)); + } + /** + * Calculates column header widths that can be retrieved from the cache. + */ + + }, { + key: "calculateWidths", + value: function calculateWidths() { + var wot = this.wot; + var wtTable = wot.wtTable, + wtViewport = wot.wtViewport, + cloneSource = wot.cloneSource; + var mainHolder = cloneSource ? cloneSource.wtTable.holder : wtTable.holder; + var scrollbarCompensation = mainHolder.offsetHeight < mainHolder.scrollHeight ? getScrollbarWidth() : 0; + var rowHeaderWidthSetting = wot.getSetting('rowHeaderWidth'); + wtViewport.columnsRenderCalculator.refreshStretching(wtViewport.getViewportWidth() - scrollbarCompensation); + rowHeaderWidthSetting = wot.getSetting('onModifyRowHeaderWidth', rowHeaderWidthSetting); + + if (rowHeaderWidthSetting !== null && rowHeaderWidthSetting !== void 0) { + var rowHeadersCount = wot.getSetting('rowHeaders').length; + var defaultColumnWidth = wot.getSetting('defaultColumnWidth'); + + for (var visibleColumnIndex = 0; visibleColumnIndex < rowHeadersCount; visibleColumnIndex++) { + var width = Array.isArray(rowHeaderWidthSetting) ? rowHeaderWidthSetting[visibleColumnIndex] : rowHeaderWidthSetting; + width = width === null || width === void 0 ? defaultColumnWidth : width; + this.headerWidths.set(visibleColumnIndex, width); + } + } + } + }]); + + return ColumnUtils; +}(); + +function _classCallCheck$k(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$k(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); } } + +function _createClass$k(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$k(Constructor.prototype, protoProps); if (staticProps) _defineProperties$k(Constructor, staticProps); return Constructor; } + +/** + * Row utils class contains all necessary information about sizes of the rows. + * + * @class {RowUtils} + */ +var RowUtils = /*#__PURE__*/function () { + function RowUtils(wot) { + _classCallCheck$k(this, RowUtils); + + this.wot = wot; + } + /** + * Returns row height based on passed source index. + * + * @param {number} sourceIndex Row source index. + * @returns {number} + */ + + + _createClass$k(RowUtils, [{ + key: "getHeight", + value: function getHeight(sourceIndex) { + var height = this.wot.wtSettings.settings.rowHeight(sourceIndex); + var oversizedHeight = this.wot.wtViewport.oversizedRows[sourceIndex]; + + if (oversizedHeight !== void 0) { + height = height === void 0 ? oversizedHeight : Math.max(height, oversizedHeight); + } + + return height; + } + }]); + + return RowUtils; +}(); + +var CLONE_TOP = 'top'; +var CLONE_BOTTOM = 'bottom'; +var CLONE_LEFT = 'left'; +var CLONE_TOP_LEFT_CORNER = 'top_left_corner'; +var CLONE_BOTTOM_LEFT_CORNER = 'bottom_left_corner'; +var CLONE_TYPES = [CLONE_TOP, CLONE_BOTTOM, CLONE_LEFT, CLONE_TOP_LEFT_CORNER, CLONE_BOTTOM_LEFT_CORNER]; + +var registeredOverlays = {}; +/** + * Register overlay class. If the Overlay under the same name is already registered + * the class won't be registered. + * + * @param {Overlay} overlayClass Overlay class extended from base overlay class {@link Overlay}. + */ + +function registerOverlayOnce(overlayClass) { + var overlayName = overlayClass.OVERLAY_NAME; + + if (CLONE_TYPES.indexOf(overlayName) === -1) { + throw new Error("Unsupported overlay (".concat(overlayName, ").")); + } + + if (!hasOverlay(overlayName)) { + registeredOverlays[overlayName] = overlayClass; + } +} +/** + * Create new instance of overlay type. + * + * @param {string} type Overlay type, one of the CLONE_TYPES value. + * @param {Walkontable} wot The Walkontable instance. + * @returns {Overlay} + */ + +function createOverlay(type, wot) { + return new registeredOverlays[type](wot); +} +/** + * Check if specified overlay was registered. + * + * @param {string} type Overlay type, one of the CLONE_TYPES value. + * @returns {boolean} + */ + +function hasOverlay(type) { + return registeredOverlays[type] !== void 0; +} +/** + * Checks if overlay object (`overlay`) is instance of overlay type (`type`). + * + * @param {Overlay} overlay Overlay object. + * @param {string} type Overlay type, one of the CLONE_TYPES value. + * @returns {boolean} + */ + +function isOverlayTypeOf(overlay, type) { + if (!overlay || !registeredOverlays[type]) { + return false; + } + + return overlay instanceof registeredOverlays[type]; +} + +function _toConsumableArray$3(arr) { return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread$1(); } + +function _nonIterableSpread$1() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArray$1(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$1(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$1(arr); } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); } + +function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$l(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$l(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); } } + +function _createClass$l(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$l(Constructor.prototype, protoProps); if (staticProps) _defineProperties$l(Constructor, staticProps); return Constructor; } +/** + * + */ + +var Table = /*#__PURE__*/function () { + /** + * @param {Walkontable} wotInstance The Walkontable instance. + * @param {HTMLTableElement} table An element to the Walkontable generated table is injected. + */ + function Table(wotInstance, table) { + var _this = this; + + _classCallCheck$l(this, Table); + + /** + * Indicates if this instance is of type `MasterTable` (i.e. It is NOT an overlay). + * + * @type {boolean} + */ + this.isMaster = !wotInstance.cloneOverlay; // "instanceof" operator isn't used, because it caused a circular reference in Webpack + + this.wot = wotInstance; // legacy support + + this.instance = this.wot; + this.TABLE = table; + this.TBODY = null; + this.THEAD = null; + this.COLGROUP = null; + this.tableOffset = 0; + this.holderOffset = 0; + /** + * Indicates if the table has height bigger than 0px. + * + * @type {boolean} + */ + + this.hasTableHeight = true; + /** + * Indicates if the table has width bigger than 0px. + * + * @type {boolean} + */ + + this.hasTableWidth = true; + /** + * Indicates if the table is visible. By visible, it means that the holder + * element has CSS 'display' property different than 'none'. + * + * @type {boolean} + */ + + this.isTableVisible = false; + removeTextNodes(this.TABLE); + this.spreader = this.createSpreader(this.TABLE); + this.hider = this.createHider(this.spreader); + this.holder = this.createHolder(this.hider); + this.wtRootElement = this.holder.parentNode; + + if (this.isMaster) { + this.alignOverlaysWithTrimmingContainer(); + } + + this.fixTableDomTree(); + this.rowFilter = null; + this.columnFilter = null; + this.correctHeaderWidth = false; + var origRowHeaderWidth = this.wot.wtSettings.settings.rowHeaderWidth; // Fix for jumping row headers (https://github.com/handsontable/handsontable/issues/3850) + + this.wot.wtSettings.settings.rowHeaderWidth = function () { + return _this._modifyRowHeaderWidth(origRowHeaderWidth); + }; + + this.rowUtils = new RowUtils(this.wot); + this.columnUtils = new ColumnUtils(this.wot); + this.tableRenderer = new Renderer({ + TABLE: this.TABLE, + THEAD: this.THEAD, + COLGROUP: this.COLGROUP, + TBODY: this.TBODY, + rowUtils: this.rowUtils, + columnUtils: this.columnUtils, + cellRenderer: this.wot.wtSettings.settings.cellRenderer + }); + } + /** + * Returns a boolean that is true if this intance of Table represents a specific overlay, identified by the overlay name. + * For MasterTable, it returns false. + * + * @param {string} overlayTypeName The overlay type. + * @returns {boolean} + */ + + + _createClass$l(Table, [{ + key: "is", + value: function is(overlayTypeName) { + return isOverlayTypeOf(this.wot.cloneOverlay, overlayTypeName); + } + /** + * + */ + + }, { + key: "fixTableDomTree", + value: function fixTableDomTree() { + var rootDocument = this.wot.rootDocument; + this.TBODY = this.TABLE.querySelector('tbody'); + + if (!this.TBODY) { + this.TBODY = rootDocument.createElement('tbody'); + this.TABLE.appendChild(this.TBODY); + } + + this.THEAD = this.TABLE.querySelector('thead'); + + if (!this.THEAD) { + this.THEAD = rootDocument.createElement('thead'); + this.TABLE.insertBefore(this.THEAD, this.TBODY); + } + + this.COLGROUP = this.TABLE.querySelector('colgroup'); + + if (!this.COLGROUP) { + this.COLGROUP = rootDocument.createElement('colgroup'); + this.TABLE.insertBefore(this.COLGROUP, this.THEAD); + } + + if (this.wot.getSetting('columnHeaders').length && !this.THEAD.childNodes.length) { + this.THEAD.appendChild(rootDocument.createElement('TR')); + } + } + /** + * @param {HTMLTableElement} table An element to process. + * @returns {HTMLElement} + */ + + }, { + key: "createSpreader", + value: function createSpreader(table) { + var parent = table.parentNode; + var spreader; + + if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !hasClass(parent, 'wtHolder')) { + spreader = this.wot.rootDocument.createElement('div'); + spreader.className = 'wtSpreader'; + + if (parent) { + // if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it + parent.insertBefore(spreader, table); + } + + spreader.appendChild(table); + } + + spreader.style.position = 'relative'; + return spreader; + } + /** + * @param {HTMLElement} spreader An element to the hider element is injected. + * @returns {HTMLElement} + */ + + }, { + key: "createHider", + value: function createHider(spreader) { + var parent = spreader.parentNode; + var hider; + + if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !hasClass(parent, 'wtHolder')) { + hider = this.wot.rootDocument.createElement('div'); + hider.className = 'wtHider'; + + if (parent) { + // if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it + parent.insertBefore(hider, spreader); + } + + hider.appendChild(spreader); + } + + return hider; + } + /** + * + * @param {HTMLElement} hider An element to the holder element is injected. + * @returns {HTMLElement} + */ + + }, { + key: "createHolder", + value: function createHolder(hider) { + var parent = hider.parentNode; + var holder; + + if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !hasClass(parent, 'wtHolder')) { + holder = this.wot.rootDocument.createElement('div'); + holder.style.position = 'relative'; + holder.className = 'wtHolder'; + + if (parent) { + // if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it + parent.insertBefore(holder, hider); + } + + if (this.isMaster) { + holder.parentNode.className += 'ht_master handsontable'; + } + + holder.appendChild(hider); + } + + return holder; + } + /** + * Redraws the table. + * + * @param {boolean} [fastDraw=false] If TRUE, will try to avoid full redraw and only update the border positions. + * If FALSE or UNDEFINED, will perform a full redraw. + * @returns {Table} + */ + + }, { + key: "draw", + value: function draw() { + var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var wot = this.wot; + var wtOverlays = wot.wtOverlays, + wtViewport = wot.wtViewport; + var totalRows = wot.getSetting('totalRows'); + var totalColumns = wot.getSetting('totalColumns'); + var rowHeaders = wot.getSetting('rowHeaders'); + var rowHeadersCount = rowHeaders.length; + var columnHeaders = wot.getSetting('columnHeaders'); + var columnHeadersCount = columnHeaders.length; + var syncScroll = false; + var runFastDraw = fastDraw; + + if (this.isMaster) { + this.holderOffset = offset(this.holder); + runFastDraw = wtViewport.createRenderCalculators(runFastDraw); + + if (rowHeadersCount && !wot.getSetting('fixedColumnsLeft')) { + var leftScrollPos = wtOverlays.leftOverlay.getScrollPosition(); + var previousState = this.correctHeaderWidth; + this.correctHeaderWidth = leftScrollPos > 0; + + if (previousState !== this.correctHeaderWidth) { + runFastDraw = false; + } + } + } + + if (this.isMaster) { + syncScroll = wtOverlays.prepareOverlays(); + } + + if (runFastDraw) { + if (this.isMaster) { + // in case we only scrolled without redraw, update visible rows information in oldRowsCalculator + wtViewport.createVisibleCalculators(); + } + + if (wtOverlays) { + wtOverlays.refresh(true); + } + } else { + if (this.isMaster) { + this.tableOffset = offset(this.TABLE); + } else { + this.tableOffset = this.wot.cloneSource.wtTable.tableOffset; + } + + var startRow = totalRows > 0 ? this.getFirstRenderedRow() : 0; + var startColumn = totalColumns > 0 ? this.getFirstRenderedColumn() : 0; + this.rowFilter = new RowFilter(startRow, totalRows, columnHeadersCount); + this.columnFilter = new ColumnFilter(startColumn, totalColumns, rowHeadersCount); + var performRedraw = true; // Only master table rendering can be skipped + + if (this.isMaster) { + this.alignOverlaysWithTrimmingContainer(); + var skipRender = {}; + this.wot.getSetting('beforeDraw', true, skipRender); + performRedraw = skipRender.skipRender !== true; + } + + if (performRedraw) { + this.tableRenderer.setHeaderContentRenderers(rowHeaders, columnHeaders); + + if (this.is(CLONE_BOTTOM) || this.is(CLONE_BOTTOM_LEFT_CORNER)) { + // do NOT render headers on the bottom or bottom-left corner overlay + this.tableRenderer.setHeaderContentRenderers(rowHeaders, []); + } + + this.resetOversizedRows(); + this.tableRenderer.setViewportSize(this.getRenderedRowsCount(), this.getRenderedColumnsCount()).setFilters(this.rowFilter, this.columnFilter).render(); + var workspaceWidth; + + if (this.isMaster) { + workspaceWidth = this.wot.wtViewport.getWorkspaceWidth(); + this.wot.wtViewport.containerWidth = null; + this.markOversizedColumnHeaders(); + } + + this.adjustColumnHeaderHeights(); + + if (this.isMaster || this.is(CLONE_BOTTOM)) { + this.markOversizedRows(); + } + + if (this.isMaster) { + this.wot.wtViewport.createVisibleCalculators(); + this.wot.wtOverlays.refresh(false); + this.wot.wtOverlays.applyToDOM(); + var hiderWidth = outerWidth(this.hider); + var tableWidth = outerWidth(this.TABLE); + + if (hiderWidth !== 0 && tableWidth !== hiderWidth) { + // Recalculate the column widths, if width changes made in the overlays removed the scrollbar, thus changing the viewport width. + this.columnUtils.calculateWidths(); + this.tableRenderer.renderer.colGroup.render(); + } + + if (workspaceWidth !== this.wot.wtViewport.getWorkspaceWidth()) { + // workspace width changed though to shown/hidden vertical scrollbar. Let's reapply stretching + this.wot.wtViewport.containerWidth = null; + this.columnUtils.calculateWidths(); + this.tableRenderer.renderer.colGroup.render(); + } + + this.wot.getSetting('onDraw', true); + } else if (this.is(CLONE_BOTTOM)) { + this.wot.cloneSource.wtOverlays.adjustElementsSize(); + } + } + } + + if (this.isMaster) { + var positionChanged = wtOverlays.topOverlay.resetFixedPosition(); + + if (wtOverlays.bottomOverlay.clone) { + positionChanged = wtOverlays.bottomOverlay.resetFixedPosition() || positionChanged; + } + + positionChanged = wtOverlays.leftOverlay.resetFixedPosition() || positionChanged; + + if (wtOverlays.topLeftCornerOverlay) { + wtOverlays.topLeftCornerOverlay.resetFixedPosition(); + } + + if (wtOverlays.bottomLeftCornerOverlay && wtOverlays.bottomLeftCornerOverlay.clone) { + wtOverlays.bottomLeftCornerOverlay.resetFixedPosition(); + } + + if (positionChanged) { + // It refreshes the cells borders caused by a 1px shift (introduced by overlays which add or + // remove `innerBorderTop` and `innerBorderLeft` CSS classes to the DOM element. This happens + // when there is a switch between rendering from 0 to N rows/columns and vice versa). + wtOverlays.refreshAll(); + wtOverlays.adjustElementsSize(); + } + } + + this.refreshSelections(runFastDraw); + + if (syncScroll) { + wtOverlays.syncScrollWithMaster(); + } + + wot.drawn = true; + return this; + } + /** + * @param {number} col The visual column index. + */ + + }, { + key: "markIfOversizedColumnHeader", + value: function markIfOversizedColumnHeader(col) { + var sourceColIndex = this.wot.wtTable.columnFilter.renderedToSource(col); + var level = this.wot.getSetting('columnHeaders').length; + var defaultRowHeight = this.wot.wtSettings.settings.defaultRowHeight; + var previousColHeaderHeight; + var currentHeader; + var currentHeaderHeight; + var columnHeaderHeightSetting = this.wot.getSetting('columnHeaderHeight') || []; + + while (level) { + level -= 1; + previousColHeaderHeight = this.wot.wtTable.getColumnHeaderHeight(level); + currentHeader = this.wot.wtTable.getColumnHeader(sourceColIndex, level); + + if (!currentHeader) { + /* eslint-disable no-continue */ + continue; + } + + currentHeaderHeight = innerHeight(currentHeader); + + if (!previousColHeaderHeight && defaultRowHeight < currentHeaderHeight || previousColHeaderHeight < currentHeaderHeight) { + this.wot.wtViewport.oversizedColumnHeaders[level] = currentHeaderHeight; + } + + if (Array.isArray(columnHeaderHeightSetting)) { + if (columnHeaderHeightSetting[level] !== null && columnHeaderHeightSetting[level] !== void 0) { + this.wot.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level]; + } + } else if (!isNaN(columnHeaderHeightSetting)) { + this.wot.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting; + } + + if (this.wot.wtViewport.oversizedColumnHeaders[level] < (columnHeaderHeightSetting[level] || columnHeaderHeightSetting)) { + this.wot.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level] || columnHeaderHeightSetting; // eslint-disable-line max-len + } + } + } + /** + * + */ + + }, { + key: "adjustColumnHeaderHeights", + value: function adjustColumnHeaderHeights() { + var wot = this.wot; + var children = wot.wtTable.THEAD.childNodes; + var oversizedColumnHeaders = wot.wtViewport.oversizedColumnHeaders; + var columnHeaders = wot.getSetting('columnHeaders'); + + for (var i = 0, len = columnHeaders.length; i < len; i++) { + if (oversizedColumnHeaders[i]) { + if (!children[i] || children[i].childNodes.length === 0) { + return; + } + + children[i].childNodes[0].style.height = "".concat(oversizedColumnHeaders[i], "px"); + } + } + } + /** + * Resets cache of row heights. The cache should be cached for each render cycle in a case + * when new cell values have content which increases/decreases cell height. + */ + + }, { + key: "resetOversizedRows", + value: function resetOversizedRows() { + var wot = this.wot; + + if (!this.isMaster && !this.is(CLONE_BOTTOM)) { + return; + } + + if (!wot.getSetting('externalRowCalculator')) { + var rowsToRender = this.getRenderedRowsCount(); // Reset the oversized row cache for rendered rows + + for (var visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) { + var sourceRow = this.rowFilter.renderedToSource(visibleRowIndex); + + if (wot.wtViewport.oversizedRows && wot.wtViewport.oversizedRows[sourceRow]) { + wot.wtViewport.oversizedRows[sourceRow] = void 0; + } + } + } + } + /** + * @param {string} className The CSS class name to remove from the table cells. + */ + + }, { + key: "removeClassFromCells", + value: function removeClassFromCells(className) { + var nodes = this.TABLE.querySelectorAll(".".concat(className)); + + for (var i = 0, len = nodes.length; i < len; i++) { + removeClass(nodes[i], className); + } + } + /** + * Refresh the table selection by re-rendering Selection instances connected with that instance. + * + * @param {boolean} fastDraw If fast drawing is enabled than additionally className clearing is applied. + */ + + }, { + key: "refreshSelections", + value: function refreshSelections(fastDraw) { + var wot = this.wot; + + if (!wot.selections) { + return; + } + + var highlights = Array.from(wot.selections); + var len = highlights.length; + + if (fastDraw) { + var classesToRemove = []; + + for (var i = 0; i < len; i++) { + var _highlights$i$setting = highlights[i].settings, + highlightHeaderClassName = _highlights$i$setting.highlightHeaderClassName, + highlightRowClassName = _highlights$i$setting.highlightRowClassName, + highlightColumnClassName = _highlights$i$setting.highlightColumnClassName; + var classNames = highlights[i].classNames; + var classNamesLength = classNames.length; + + for (var j = 0; j < classNamesLength; j++) { + if (!classesToRemove.includes(classNames[j])) { + classesToRemove.push(classNames[j]); + } + } + + if (highlightHeaderClassName && !classesToRemove.includes(highlightHeaderClassName)) { + classesToRemove.push(highlightHeaderClassName); + } + + if (highlightRowClassName && !classesToRemove.includes(highlightRowClassName)) { + classesToRemove.push(highlightRowClassName); + } + + if (highlightColumnClassName && !classesToRemove.includes(highlightColumnClassName)) { + classesToRemove.push(highlightColumnClassName); + } + } + + var additionalClassesToRemove = wot.getSetting('onBeforeRemoveCellClassNames'); + + if (Array.isArray(additionalClassesToRemove)) { + for (var _i = 0; _i < additionalClassesToRemove.length; _i++) { + classesToRemove.push(additionalClassesToRemove[_i]); + } + } + + var classesToRemoveLength = classesToRemove.length; + + for (var _i2 = 0; _i2 < classesToRemoveLength; _i2++) { + // there was no rerender, so we need to remove classNames by ourselves + this.removeClassFromCells(classesToRemove[_i2]); + } + } + + for (var _i3 = 0; _i3 < len; _i3++) { + highlights[_i3].draw(wot, fastDraw); + } + } + /** + * Get cell element at coords. + * Negative coords.row or coords.col are used to retrieve header cells. If there are multiple header levels, the + * negative value corresponds to the distance from the working area. For example, when there are 3 levels of column + * headers, coords.col=-1 corresponds to the most inner header element, while coords.col=-3 corresponds to the + * outmost header element. + * + * In case an element for the coords is not rendered, the method returns an error code. + * To produce the error code, the input parameters are validated in the order in which they + * are given. Thus, if both the row and the column coords are out of the rendered bounds, + * the method returns the error code for the row. + * + * @param {CellCoords} coords The cell coordinates. + * @returns {HTMLElement|number} HTMLElement on success or Number one of the exit codes on error: + * -1 row before viewport + * -2 row after viewport + * -3 column before viewport + * -4 column after viewport. + */ + + }, { + key: "getCell", + value: function getCell(coords) { + var row = coords.row; + var column = coords.col; + var hookResult = this.wot.getSetting('onModifyGetCellCoords', row, column); + + if (hookResult && Array.isArray(hookResult)) { + var _hookResult = _slicedToArray(hookResult, 2); + + row = _hookResult[0]; + column = _hookResult[1]; + } + + if (this.isRowBeforeRenderedRows(row)) { + // row before rendered rows + return -1; + } else if (this.isRowAfterRenderedRows(row)) { + // row after rendered rows + return -2; + } else if (this.isColumnBeforeRenderedColumns(column)) { + // column before rendered columns + return -3; + } else if (this.isColumnAfterRenderedColumns(column)) { + // column after rendered columns + return -4; + } + + var TR; + + if (row < 0) { + TR = this.THEAD.childNodes[this.rowFilter.sourceRowToVisibleColHeadedRow(row)]; + } else { + TR = this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)]; + } + + if (!TR && row >= 0) { + throw new Error('TR was expected to be rendered but is not'); + } + + var TD = TR.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(column)]; + + if (!TD && column >= 0) { + throw new Error('TD or TH was expected to be rendered but is not'); + } + + return TD; + } + /** + * GetColumnHeader. + * + * @param {number} col Column index. + * @param {number} [level=0] Header level (0 = most distant to the table). + * @returns {object} HTMLElement on success or undefined on error. + */ + + }, { + key: "getColumnHeader", + value: function getColumnHeader(col) { + var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + var TR = this.THEAD.childNodes[level]; + + if (TR) { + return TR.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(col)]; + } + } + /** + * GetRowHeader. + * + * @param {number} row Row index. + * @returns {HTMLElement} HTMLElement on success or Number one of the exit codes on error: `null table doesn't have row headers`. + */ + + }, { + key: "getRowHeader", + value: function getRowHeader(row) { + if (this.columnFilter.sourceColumnToVisibleRowHeadedColumn(0) === 0) { + return null; + } + + var TR = this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)]; + + if (TR) { + return TR.childNodes[0]; + } + } + /** + * Returns cell coords object for a given TD (or a child element of a TD element). + * + * @param {HTMLTableCellElement} TD A cell DOM element (or a child of one). + * @returns {CellCoords|null} The coordinates of the provided TD element (or the closest TD element) or null, if the provided element is not applicable. + */ + + }, { + key: "getCoords", + value: function getCoords(TD) { + var cellElement = TD; + + if (cellElement.nodeName !== 'TD' && cellElement.nodeName !== 'TH') { + cellElement = closest(cellElement, ['TD', 'TH']); + } + + if (cellElement === null) { + return null; + } + + var TR = cellElement.parentNode; + var CONTAINER = TR.parentNode; + var row = index$1(TR); + var col = cellElement.cellIndex; + + if (overlayContainsElement(CLONE_TOP_LEFT_CORNER, cellElement, this.wtRootElement) || overlayContainsElement(CLONE_TOP, cellElement, this.wtRootElement)) { + if (CONTAINER.nodeName === 'THEAD') { + row -= CONTAINER.childNodes.length; + } + } else if (overlayContainsElement(CLONE_BOTTOM_LEFT_CORNER, cellElement, this.wtRootElement) || overlayContainsElement(CLONE_BOTTOM, cellElement, this.wtRootElement)) { + var totalRows = this.wot.getSetting('totalRows'); + row = totalRows - CONTAINER.childNodes.length + row; + } else if (CONTAINER === this.THEAD) { + row = this.rowFilter.visibleColHeadedRowToSourceRow(row); + } else { + row = this.rowFilter.renderedToSource(row); + } + + if (overlayContainsElement(CLONE_TOP_LEFT_CORNER, cellElement, this.wtRootElement) || overlayContainsElement(CLONE_LEFT, cellElement, this.wtRootElement) || overlayContainsElement(CLONE_BOTTOM_LEFT_CORNER, cellElement, this.wtRootElement)) { + col = this.columnFilter.offsettedTH(col); + } else { + col = this.columnFilter.visibleRowHeadedColumnToSourceColumn(col); + } + + return new CellCoords(row, col); + } + /** + * Check if any of the rendered rows is higher than expected, and if so, cache them. + */ + + }, { + key: "markOversizedRows", + value: function markOversizedRows() { + if (this.wot.getSetting('externalRowCalculator')) { + return; + } + + var rowCount = this.TBODY.childNodes.length; + var expectedTableHeight = rowCount * this.wot.wtSettings.settings.defaultRowHeight; + var actualTableHeight = innerHeight(this.TBODY) - 1; + var previousRowHeight; + var rowInnerHeight; + var sourceRowIndex; + var currentTr; + var rowHeader; + + if (expectedTableHeight === actualTableHeight && !this.wot.getSetting('fixedRowsBottom')) { + // If the actual table height equals rowCount * default single row height, no row is oversized -> no need to iterate over them + return; + } + + while (rowCount) { + rowCount -= 1; + sourceRowIndex = this.rowFilter.renderedToSource(rowCount); + previousRowHeight = this.getRowHeight(sourceRowIndex); + currentTr = this.getTrForRow(sourceRowIndex); + rowHeader = currentTr.querySelector('th'); + + if (rowHeader) { + rowInnerHeight = innerHeight(rowHeader); + } else { + rowInnerHeight = innerHeight(currentTr) - 1; + } + + if (!previousRowHeight && this.wot.wtSettings.settings.defaultRowHeight < rowInnerHeight || previousRowHeight < rowInnerHeight) { + rowInnerHeight += 1; + this.wot.wtViewport.oversizedRows[sourceRowIndex] = rowInnerHeight; + } + } + } + /** + * @param {number} row The visual row index. + * @returns {HTMLTableElement} + */ + + }, { + key: "getTrForRow", + value: function getTrForRow(row) { + return this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)]; + } + /** + * Checks if the column index (negative value from -1 to N) is rendered. + * + * @param {number} column The column index (negative value from -1 to N). + * @returns {boolean} + */ + + }, { + key: "isColumnHeaderRendered", + value: function isColumnHeaderRendered(column) { + if (column >= 0) { + return false; + } + + var rowHeaders = this.wot.getSetting('rowHeaders'); + var rowHeadersCount = rowHeaders.length; + return Math.abs(column) <= rowHeadersCount; + } + /** + * Checks if the row index (negative value from -1 to N) is rendered. + * + * @param {number} row The row index (negative value from -1 to N). + * @returns {boolean} + */ + + }, { + key: "isRowHeaderRendered", + value: function isRowHeaderRendered(row) { + if (row >= 0) { + return false; + } + + var columnHeaders = this.wot.getSetting('columnHeaders'); + var columnHeadersCount = columnHeaders.length; + return Math.abs(row) <= columnHeadersCount; + } + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * Check if the given row index is lower than the index of the first row that + * is currently rendered and return TRUE in that case, or FALSE otherwise. + * + * Negative row index is used to check the columns' headers. + * + * Headers + * +--------------+ │ + * -3 │ │ │ │ │ + * +--------------+ │ + * -2 │ │ │ │ │ TRUE + * +--------------+ │ + * -1 │ │ │ │ │ + * Cells +==================+ │ + * 0 ┇ ┇ ┇ ┇ <--- For fixedRowsTop: 1 │ + * +--------------+ the master overlay do ---+ first rendered row (index 1) + * 1 │ A2 │ B2 │ C2 │ not render the first row. │ + * +--------------+ │ FALSE + * 2 │ A3 │ B3 │ C3 │ │ + * +--------------+ ---+ last rendered row + * │ + * │ FALSE + * + * @param {number} row The visual row index. + * @memberof Table# + * @function isRowBeforeRenderedRows + * @returns {boolean} + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + }, { + key: "isRowBeforeRenderedRows", + value: function isRowBeforeRenderedRows(row) { + var first = this.getFirstRenderedRow(); // Check the headers only in case when the first rendered row is -1 or 0. + // This is an indication that the overlay is placed on the most top position. + + if (row < 0 && first <= 0) { + return !this.isRowHeaderRendered(row); + } + + return row < first; + } + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * Check if the given column index is greater than the index of the last column that + * is currently rendered and return TRUE in that case, or FALSE otherwise. + * + * The negative row index is used to check the columns' headers. However, + * keep in mind that for negative indexes, the method always returns FALSE as + * it is not possible to render headers partially. The "after" index can not be + * lower than -1. + * + * Headers + * +--------------+ │ + * -3 │ │ │ │ │ + * +--------------+ │ + * -2 │ │ │ │ │ FALSE + * +--------------+ │ + * -1 │ │ │ │ │ + * Cells +==================+ │ + * 0 ┇ ┇ ┇ ┇ <--- For fixedRowsTop: 1 │ + * +--------------+ the master overlay do ---+ first rendered row (index 1) + * 1 │ A2 │ B2 │ C2 │ not render the first rows │ + * +--------------+ │ FALSE + * 2 │ A3 │ B3 │ C3 │ │ + * +--------------+ ---+ last rendered row + * │ + * │ TRUE + * + * @param {number} row The visual row index. + * @memberof Table# + * @function isRowAfterRenderedRows + * @returns {boolean} + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + }, { + key: "isRowAfterRenderedRows", + value: function isRowAfterRenderedRows(row) { + return row > this.getLastRenderedRow(); + } + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * Check if the given column index is lower than the index of the first column that + * is currently rendered and return TRUE in that case, or FALSE otherwise. + * + * Negative column index is used to check the rows' headers. + * + * For fixedColumnsLeft: 1 the master overlay + * do not render this first columns. + * Headers -3 -2 -1 | + * +----+----+----║┄ ┄ +------+------+ + * │ │ │ â•‘ │ B1 │ C1 │ + * +--------------║┄ ┄ --------------│ + * │ │ │ â•‘ │ B2 │ C2 │ + * +--------------║┄ ┄ --------------│ + * │ │ │ â•‘ │ B3 │ C3 │ + * +----+----+----║┄ ┄ +------+------+ + * â•· â•· + * -------------------------+-------------+----------------> + * TRUE first FALSE last FALSE + * rendered rendered + * column column + * + * @param {number} column The visual column index. + * @memberof Table# + * @function isColumnBeforeRenderedColumns + * @returns {boolean} + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + }, { + key: "isColumnBeforeRenderedColumns", + value: function isColumnBeforeRenderedColumns(column) { + var first = this.getFirstRenderedColumn(); // Check the headers only in case when the first rendered column is -1 or 0. + // This is an indication that the overlay is placed on the most left position. + + if (column < 0 && first <= 0) { + return !this.isColumnHeaderRendered(column); + } + + return column < first; + } + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * Check if the given column index is greater than the index of the last column that + * is currently rendered and return TRUE in that case, or FALSE otherwise. + * + * The negative column index is used to check the rows' headers. However, + * keep in mind that for negative indexes, the method always returns FALSE as + * it is not possible to render headers partially. The "after" index can not be + * lower than -1. + * + * For fixedColumnsLeft: 1 the master overlay + * do not render this first columns. + * Headers -3 -2 -1 | + * +----+----+----║┄ ┄ +------+------+ + * │ │ │ â•‘ │ B1 │ C1 │ + * +--------------║┄ ┄ --------------│ + * │ │ │ â•‘ │ B2 │ C2 │ + * +--------------║┄ ┄ --------------│ + * │ │ │ â•‘ │ B3 │ C3 │ + * +----+----+----║┄ ┄ +------+------+ + * â•· â•· + * -------------------------+-------------+----------------> + * FALSE first FALSE last TRUE + * rendered rendered + * column column + * + * @param {number} column The visual column index. + * @memberof Table# + * @function isColumnAfterRenderedColumns + * @returns {boolean} + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + }, { + key: "isColumnAfterRenderedColumns", + value: function isColumnAfterRenderedColumns(column) { + return this.columnFilter && column > this.getLastRenderedColumn(); + } + }, { + key: "isColumnAfterViewport", + value: function isColumnAfterViewport(column) { + return this.columnFilter && column > this.getLastVisibleColumn(); + } + }, { + key: "isRowAfterViewport", + value: function isRowAfterViewport(row) { + return this.rowFilter && row > this.getLastVisibleRow(); + } + }, { + key: "isColumnBeforeViewport", + value: function isColumnBeforeViewport(column) { + return this.columnFilter && this.columnFilter.sourceToRendered(column) < 0 && column >= 0; + } + }, { + key: "isLastRowFullyVisible", + value: function isLastRowFullyVisible() { + return this.getLastVisibleRow() === this.getLastRenderedRow(); + } + }, { + key: "isLastColumnFullyVisible", + value: function isLastColumnFullyVisible() { + return this.getLastVisibleColumn() === this.getLastRenderedColumn(); + } + }, { + key: "allRowsInViewport", + value: function allRowsInViewport() { + return this.wot.getSetting('totalRows') === this.getVisibleRowsCount(); + } + }, { + key: "allColumnsInViewport", + value: function allColumnsInViewport() { + return this.wot.getSetting('totalColumns') === this.getVisibleColumnsCount(); + } + /** + * Checks if any of the row's cells content exceeds its initial height, and if so, returns the oversized height. + * + * @param {number} sourceRow The physical row index. + * @returns {number} + */ + + }, { + key: "getRowHeight", + value: function getRowHeight(sourceRow) { + return this.rowUtils.getHeight(sourceRow); + } + /** + * @param {number} level The column level. + * @returns {number} + */ + + }, { + key: "getColumnHeaderHeight", + value: function getColumnHeaderHeight(level) { + return this.columnUtils.getHeaderHeight(level); + } + /** + * @param {number} sourceColumn The physical column index. + * @returns {number} + */ + + }, { + key: "getColumnWidth", + value: function getColumnWidth(sourceColumn) { + return this.columnUtils.getWidth(sourceColumn); + } + /** + * @param {number} sourceColumn The physical column index. + * @returns {number} + */ + + }, { + key: "getStretchedColumnWidth", + value: function getStretchedColumnWidth(sourceColumn) { + return this.columnUtils.getStretchedColumnWidth(sourceColumn); + } + /** + * Checks if the table has defined size. It returns `true` when the table has width and height + * set bigger than `0px`. + * + * @returns {boolean} + */ + + }, { + key: "hasDefinedSize", + value: function hasDefinedSize() { + return this.hasTableHeight && this.hasTableWidth; + } + /** + * Checks if the table is visible. It returns `true` when the holder element (or its parents) + * has CSS 'display' property different than 'none'. + * + * @returns {boolean} + */ + + }, { + key: "isVisible", + value: function isVisible$1() { + return isVisible(this.TABLE); + } + /** + * Modify row header widths provided by user in class contructor. + * + * @private + * @param {Function} rowHeaderWidthFactory The function which can provide default width values for rows.. + * @returns {number} + */ + + }, { + key: "_modifyRowHeaderWidth", + value: function _modifyRowHeaderWidth(rowHeaderWidthFactory) { + var widths = isFunction(rowHeaderWidthFactory) ? rowHeaderWidthFactory() : null; + + if (Array.isArray(widths)) { + widths = _toConsumableArray$3(widths); + widths[widths.length - 1] = this._correctRowHeaderWidth(widths[widths.length - 1]); + } else { + widths = this._correctRowHeaderWidth(widths); + } + + return widths; + } + /** + * Correct row header width if necessary. + * + * @private + * @param {number} width The width to process. + * @returns {number} + */ + + }, { + key: "_correctRowHeaderWidth", + value: function _correctRowHeaderWidth(width) { + var rowHeaderWidth = width; + + if (typeof width !== 'number') { + rowHeaderWidth = this.wot.getSetting('defaultColumnWidth'); + } + + if (this.correctHeaderWidth) { + rowHeaderWidth += 1; + } + + return rowHeaderWidth; + } + }]); + + return Table; +}(); + +var MIXIN_NAME = 'calculatedRows'; +/** + * Mixin for the subclasses of `Table` with implementations of + * helper methods that are related to rows. + * This mixin is meant to be applied in the subclasses of `Table` + * that use virtual rendering in the vertical axis. + * + * @type {object} + */ + +var calculatedRows = { + /** + * Get the source index of the first rendered row. If no rows are rendered, returns an error code: -1. + * + * @returns {number} + */ + getFirstRenderedRow: function getFirstRenderedRow() { + var startRow = this.wot.wtViewport.rowsRenderCalculator.startRow; + + if (startRow === null) { + return -1; + } + + return startRow; + }, + + /** + * Get the source index of the first row fully visible in the viewport. If no rows are fully visible, returns an error code: -1. + * + * @returns {number} + */ + getFirstVisibleRow: function getFirstVisibleRow() { + var startRow = this.wot.wtViewport.rowsVisibleCalculator.startRow; + + if (startRow === null) { + return -1; + } + + return startRow; + }, + + /** + * Get the source index of the last rendered row. If no rows are rendered, returns an error code: -1. + * + * @returns {number} + */ + getLastRenderedRow: function getLastRenderedRow() { + var endRow = this.wot.wtViewport.rowsRenderCalculator.endRow; + + if (endRow === null) { + return -1; + } + + return endRow; + }, + + /** + * Get the source index of the last row fully visible in the viewport. If no rows are fully visible, returns an error code: -1. + * + * @returns {number} + */ + getLastVisibleRow: function getLastVisibleRow() { + var endRow = this.wot.wtViewport.rowsVisibleCalculator.endRow; + + if (endRow === null) { + return -1; + } + + return endRow; + }, + + /** + * Get the number of rendered rows. + * + * @returns {number} + */ + getRenderedRowsCount: function getRenderedRowsCount() { + return this.wot.wtViewport.rowsRenderCalculator.count; + }, + + /** + * Get the number of fully visible rows in the viewport. + * + * @returns {number} + */ + getVisibleRowsCount: function getVisibleRowsCount() { + return this.wot.wtViewport.rowsVisibleCalculator.count; + } +}; +defineGetter(calculatedRows, 'MIXIN_NAME', MIXIN_NAME, { + writable: false, + enumerable: false +}); + +var MIXIN_NAME$1 = 'calculatedColumns'; +/** + * Mixin for the subclasses of `Table` with implementations of + * helper methods that are related to columns. + * This mixin is meant to be applied in the subclasses of `Table` + * that use virtual rendering in the horizontal axis. + * + * @type {object} + */ + +var calculatedColumns = { + /** + * Get the source index of the first rendered column. If no columns are rendered, returns an error code: -1. + * + * @returns {number} + */ + getFirstRenderedColumn: function getFirstRenderedColumn() { + var startColumn = this.wot.wtViewport.columnsRenderCalculator.startColumn; + + if (startColumn === null) { + return -1; + } + + return startColumn; + }, + + /** + * Get the source index of the first column fully visible in the viewport. If no columns are fully visible, returns an error code: -1. + * + * @returns {number} + */ + getFirstVisibleColumn: function getFirstVisibleColumn() { + var startColumn = this.wot.wtViewport.columnsVisibleCalculator.startColumn; + + if (startColumn === null) { + return -1; + } + + return startColumn; + }, + + /** + * Get the source index of the last rendered column. If no columns are rendered, returns an error code: -1. + * + * @returns {number} + */ + getLastRenderedColumn: function getLastRenderedColumn() { + var endColumn = this.wot.wtViewport.columnsRenderCalculator.endColumn; + + if (endColumn === null) { + return -1; + } + + return endColumn; + }, + + /** + * Get the source index of the last column fully visible in the viewport. If no columns are fully visible, returns an error code: -1. + * + * @returns {number} + */ + getLastVisibleColumn: function getLastVisibleColumn() { + var endColumn = this.wot.wtViewport.columnsVisibleCalculator.endColumn; + + if (endColumn === null) { + return -1; + } + + return endColumn; + }, + + /** + * Get the number of rendered columns. + * + * @returns {number} + */ + getRenderedColumnsCount: function getRenderedColumnsCount() { + return this.wot.wtViewport.columnsRenderCalculator.count; + }, + + /** + * Get the number of fully visible columns in the viewport. + * + * @returns {number} + */ + getVisibleColumnsCount: function getVisibleColumnsCount() { + return this.wot.wtViewport.columnsVisibleCalculator.count; + } +}; +defineGetter(calculatedColumns, 'MIXIN_NAME', MIXIN_NAME$1, { + writable: false, + enumerable: false +}); + +function _typeof$b(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$b = function _typeof(obj) { return typeof obj; }; } else { _typeof$b = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$b(obj); } + +function _classCallCheck$m(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$m(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); } } + +function _createClass$m(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$m(Constructor.prototype, protoProps); if (staticProps) _defineProperties$m(Constructor, staticProps); return Constructor; } + +function _inherits$6(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$6(subClass, superClass); } + +function _setPrototypeOf$6(o, p) { _setPrototypeOf$6 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$6(o, p); } + +function _createSuper$6(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$6(); return function _createSuperInternal() { var Super = _getPrototypeOf$6(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$6(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$6(this, result); }; } + +function _possibleConstructorReturn$6(self, call) { if (call && (_typeof$b(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$6(self); } + +function _assertThisInitialized$6(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$6() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$6(o) { _getPrototypeOf$6 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$6(o); } +/** + * Subclass of `Table` that provides the helper methods relevant to the master table (not overlays), implemented through mixins. + */ + +var MasterTable = /*#__PURE__*/function (_Table) { + _inherits$6(MasterTable, _Table); + + var _super = _createSuper$6(MasterTable); + + function MasterTable() { + _classCallCheck$m(this, MasterTable); + + return _super.apply(this, arguments); + } + + _createClass$m(MasterTable, [{ + key: "alignOverlaysWithTrimmingContainer", + value: function alignOverlaysWithTrimmingContainer() { + var trimmingElement = getTrimmingContainer(this.wtRootElement); + var rootWindow = this.wot.rootWindow; + + if (trimmingElement === rootWindow) { + var preventOverflow = this.wot.getSetting('preventOverflow'); + + if (!preventOverflow) { + this.holder.style.overflow = 'visible'; + this.wtRootElement.style.overflow = 'visible'; + } + } else { + var trimmingElementParent = trimmingElement.parentElement; + var trimmingHeight = getStyle(trimmingElement, 'height', rootWindow); + var trimmingOverflow = getStyle(trimmingElement, 'overflow', rootWindow); + var holderStyle = this.holder.style; + var scrollWidth = trimmingElement.scrollWidth, + scrollHeight = trimmingElement.scrollHeight; + + var _trimmingElement$getB = trimmingElement.getBoundingClientRect(), + width = _trimmingElement$getB.width, + height = _trimmingElement$getB.height; + + var overflow = ['auto', 'hidden', 'scroll']; + + if (trimmingElementParent && overflow.includes(trimmingOverflow)) { + var cloneNode = trimmingElement.cloneNode(false); // Before calculating the height of the trimming element, set overflow: auto to hide scrollbars. + // An issue occurred on Firefox, where an empty element with overflow: scroll returns an element height higher than 0px + // despite an empty content within. + + cloneNode.style.overflow = 'auto'; + + if (trimmingElement.nextElementSibling) { + trimmingElementParent.insertBefore(cloneNode, trimmingElement.nextElementSibling); + } else { + trimmingElementParent.appendChild(cloneNode); + } + + var cloneHeight = parseInt(getComputedStyle(cloneNode, rootWindow).height, 10); + trimmingElementParent.removeChild(cloneNode); + + if (cloneHeight === 0) { + height = 0; + } + } + + height = Math.min(height, scrollHeight); + holderStyle.height = trimmingHeight === 'auto' ? 'auto' : "".concat(height, "px"); + width = Math.min(width, scrollWidth); + holderStyle.width = "".concat(width, "px"); + holderStyle.overflow = ''; + this.hasTableHeight = holderStyle.height === 'auto' ? true : height > 0; + this.hasTableWidth = width > 0; + } + + this.isTableVisible = isVisible(this.TABLE); + } + }, { + key: "markOversizedColumnHeaders", + value: function markOversizedColumnHeaders() { + var wot = this.wot; + var overlayName = wot.getOverlayName(); + var columnHeaders = wot.getSetting('columnHeaders'); + var columnHeadersCount = columnHeaders.length; + + if (columnHeadersCount && !wot.wtViewport.hasOversizedColumnHeadersMarked[overlayName]) { + var rowHeaders = wot.getSetting('rowHeaders'); + var rowHeaderCount = rowHeaders.length; + var columnCount = this.getRenderedColumnsCount(); + + for (var i = 0; i < columnHeadersCount; i++) { + for (var renderedColumnIndex = -1 * rowHeaderCount; renderedColumnIndex < columnCount; renderedColumnIndex++) { + // eslint-disable-line max-len + this.markIfOversizedColumnHeader(renderedColumnIndex); + } + } + + wot.wtViewport.hasOversizedColumnHeadersMarked[overlayName] = true; + } + } + }]); + + return MasterTable; +}(Table); + +mixin(MasterTable, calculatedRows); +mixin(MasterTable, calculatedColumns); + +var MIXIN_NAME$2 = 'stickyRowsBottom'; +/** + * Mixin for the subclasses of `Table` with implementations of + * helper methods that are related to rows. + * This mixin is meant to be applied in the subclasses of `Table` + * that use sticky rendering of the bottom rows in the vertical axis. + * + * @type {object} + */ + +var stickyRowsBottom = { + /** + * Get the source index of the first rendered row. If no rows are rendered, returns an error code: -1. + * + * @returns {number} + */ + getFirstRenderedRow: function getFirstRenderedRow() { + var totalRows = this.wot.getSetting('totalRows'); + var fixedRowsBottom = this.wot.getSetting('fixedRowsBottom'); + var index = totalRows - fixedRowsBottom; + + if (totalRows === 0 || fixedRowsBottom === 0) { + return -1; + } + + if (index < 0) { + return 0; + } + + return index; + }, + + /** + * Get the source index of the first row fully visible in the viewport. If no rows are fully visible, returns an error code: -1. + * Assumes that all rendered rows are fully visible. + * + * @returns {number} + */ + getFirstVisibleRow: function getFirstVisibleRow() { + return this.getFirstRenderedRow(); + }, + + /** + * Get the source index of the last rendered row. If no rows are rendered, returns an error code: -1. + * + * @returns {number} + */ + getLastRenderedRow: function getLastRenderedRow() { + return this.wot.getSetting('totalRows') - 1; + }, + + /** + * Get the source index of the last row fully visible in the viewport. If no rows are fully visible, returns an error code: -1. + * Assumes that all rendered rows are fully visible. + * + * @returns {number} + */ + getLastVisibleRow: function getLastVisibleRow() { + return this.getLastRenderedRow(); + }, + + /** + * Get the number of rendered rows. + * + * @returns {number} + */ + getRenderedRowsCount: function getRenderedRowsCount() { + var totalRows = this.wot.getSetting('totalRows'); + return Math.min(this.wot.getSetting('fixedRowsBottom'), totalRows); + }, + + /** + * Get the number of fully visible rows in the viewport. + * Assumes that all rendered rows are fully visible. + * + * @returns {number} + */ + getVisibleRowsCount: function getVisibleRowsCount() { + return this.getRenderedRowsCount(); + } +}; +defineGetter(stickyRowsBottom, 'MIXIN_NAME', MIXIN_NAME$2, { + writable: false, + enumerable: false +}); + +var MIXIN_NAME$3 = 'stickyColumnsLeft'; +/** + * Mixin for the subclasses of `Table` with implementations of + * helper methods that are related to columns. + * This mixin is meant to be applied in the subclasses of `Table` + * that use sticky rendering of the first columns in the horizontal axis. + * + * @type {object} + */ + +var stickyColumnsLeft = { + /** + * Get the source index of the first rendered column. If no columns are rendered, returns an error code: -1. + * + * @returns {number} + */ + getFirstRenderedColumn: function getFirstRenderedColumn() { + var totalColumns = this.wot.getSetting('totalColumns'); + + if (totalColumns === 0) { + return -1; + } + + return 0; + }, + + /** + * Get the source index of the first column fully visible in the viewport. If no columns are fully visible, returns an error code: -1. + * Assumes that all rendered columns are fully visible. + * + * @returns {number} + */ + getFirstVisibleColumn: function getFirstVisibleColumn() { + return this.getFirstRenderedColumn(); + }, + + /** + * Get the source index of the last rendered column. If no columns are rendered, returns an error code: -1. + * + * @returns {number} + */ + getLastRenderedColumn: function getLastRenderedColumn() { + return this.getRenderedColumnsCount() - 1; + }, + + /** + * Get the source index of the last column fully visible in the viewport. If no columns are fully visible, returns an error code: -1. + * Assumes that all rendered columns are fully visible. + * + * @returns {number} + */ + getLastVisibleColumn: function getLastVisibleColumn() { + return this.getLastRenderedColumn(); + }, + + /** + * Get the number of rendered columns. + * + * @returns {number} + */ + getRenderedColumnsCount: function getRenderedColumnsCount() { + var totalColumns = this.wot.getSetting('totalColumns'); + return Math.min(this.wot.getSetting('fixedColumnsLeft'), totalColumns); + }, + + /** + * Get the number of fully visible columns in the viewport. + * Assumes that all rendered columns are fully visible. + * + * @returns {number} + */ + getVisibleColumnsCount: function getVisibleColumnsCount() { + return this.getRenderedColumnsCount(); + } +}; +defineGetter(stickyColumnsLeft, 'MIXIN_NAME', MIXIN_NAME$3, { + writable: false, + enumerable: false +}); + +function _typeof$c(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$c = function _typeof(obj) { return typeof obj; }; } else { _typeof$c = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$c(obj); } + +function _classCallCheck$n(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits$7(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$7(subClass, superClass); } + +function _setPrototypeOf$7(o, p) { _setPrototypeOf$7 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$7(o, p); } + +function _createSuper$7(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$7(); return function _createSuperInternal() { var Super = _getPrototypeOf$7(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$7(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$7(this, result); }; } + +function _possibleConstructorReturn$7(self, call) { if (call && (_typeof$c(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$7(self); } + +function _assertThisInitialized$7(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$7() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$7(o) { _getPrototypeOf$7 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$7(o); } +/** + * Subclass of `Table` that provides the helper methods relevant to BottomLeftCornerOverlay, implemented through mixins. + */ + +var BottomLeftCornerOverlayTable = /*#__PURE__*/function (_Table) { + _inherits$7(BottomLeftCornerOverlayTable, _Table); + + var _super = _createSuper$7(BottomLeftCornerOverlayTable); + + function BottomLeftCornerOverlayTable() { + _classCallCheck$n(this, BottomLeftCornerOverlayTable); + + return _super.apply(this, arguments); + } + + return BottomLeftCornerOverlayTable; +}(Table); + +mixin(BottomLeftCornerOverlayTable, stickyRowsBottom); +mixin(BottomLeftCornerOverlayTable, stickyColumnsLeft); + +/** + * Prevent other listeners of the same event from being called. + * + * @param {Event} event The mouse event object. + */ +function stopImmediatePropagation(event) { + event.isImmediatePropagationEnabled = false; + event.cancelBubble = true; +} +/** + * Check if event was stopped by `stopImmediatePropagation`. + * + * @param {Event} event The mouse event object. + * @returns {boolean} + */ + +function isImmediatePropagationStopped(event) { + return event.isImmediatePropagationEnabled === false; +} +/** + * Check if provided event was triggered by clicking the right mouse button. + * + * @param {Event} event The mouse event object. + * @returns {boolean} + */ + +function isRightClick(event) { + return event.button === 2; +} +/** + * Check if provided event was triggered by clicking the left mouse button. + * + * @param {Event} event The mouse event object. + * @returns {boolean} + */ + +function isLeftClick(event) { + return event.button === 0; +} + +var domEventHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + stopImmediatePropagation: stopImmediatePropagation, + isImmediatePropagationStopped: isImmediatePropagationStopped, + isRightClick: isRightClick, + isLeftClick: isLeftClick +}); + +function _classCallCheck$o(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$n(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); } } + +function _createClass$n(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$n(Constructor.prototype, protoProps); if (staticProps) _defineProperties$n(Constructor, staticProps); return Constructor; } +/** + * Counter which tracks unregistered listeners (useful for detecting memory leaks). + * + * @type {number} + */ + +var listenersCounter = 0; +/** + * Event DOM manager for internal use in Handsontable. + * + * @class EventManager + * @util + */ + +var EventManager = /*#__PURE__*/function () { + /** + * @param {object} [context=null] An object to which event listeners will be stored. + * @private + */ + function EventManager() { + var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + _classCallCheck$o(this, EventManager); + + this.context = context || this; + + if (!this.context.eventListeners) { + this.context.eventListeners = []; // TODO perf It would be more performant if every instance of EventManager tracked its own listeners only + } + } + /** + * Register specified listener (`eventName`) to the element. + * + * @param {Element} element Target element. + * @param {string} eventName Event name. + * @param {Function} callback Function which will be called after event occur. + * @param {AddEventListenerOptions|boolean} [options] Listener options if object or useCapture if boolean. + * @returns {Function} Returns function which you can easily call to remove that event. + */ + + + _createClass$n(EventManager, [{ + key: "addEventListener", + value: function addEventListener(element, eventName, callback) { + var _this = this; + + var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + + /** + * @param {Event} event The event object. + */ + function callbackProxy(event) { + callback.call(this, extendEvent(event)); + } + + if (typeof options !== 'boolean' && !isPassiveEventSupported()) { + options = false; + } + + this.context.eventListeners.push({ + element: element, + event: eventName, + callback: callback, + callbackProxy: callbackProxy, + options: options, + eventManager: this + }); + element.addEventListener(eventName, callbackProxy, options); + listenersCounter += 1; + return function () { + _this.removeEventListener(element, eventName, callback); + }; + } + /** + * Remove the event listener previously registered. + * + * @param {Element} element Target element. + * @param {string} eventName Event name. + * @param {Function} callback Function to remove from the event target. It must be the same as during registration listener. + * @param {boolean} [onlyOwnEvents] Whether whould remove only events registered using this instance of EventManager. + */ + + }, { + key: "removeEventListener", + value: function removeEventListener(element, eventName, callback) { + var onlyOwnEvents = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + var len = this.context.eventListeners.length; + var tmpEvent; + + while (len) { + len -= 1; + tmpEvent = this.context.eventListeners[len]; + + if (tmpEvent.event === eventName && tmpEvent.element === element) { + if (callback && callback !== tmpEvent.callback) { + /* eslint-disable no-continue */ + continue; + } + + if (onlyOwnEvents && tmpEvent.eventManager !== this) { + continue; + } + + this.context.eventListeners.splice(len, 1); + tmpEvent.element.removeEventListener(tmpEvent.event, tmpEvent.callbackProxy, tmpEvent.options); + listenersCounter -= 1; + } + } + } + /** + * Clear all previously registered events. + * + * @private + * @since 0.15.0-beta3 + * @param {boolean} [onlyOwnEvents] Whether whould remove only events registered using this instance of EventManager. + */ + + }, { + key: "clearEvents", + value: function clearEvents() { + var onlyOwnEvents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + if (!this.context) { + return; + } + + var len = this.context.eventListeners.length; + + while (len) { + len -= 1; + var event = this.context.eventListeners[len]; + + if (event) { + this.removeEventListener(event.element, event.event, event.callback, onlyOwnEvents); + } + } + } + /** + * Clear all previously registered events. + */ + + }, { + key: "clear", + value: function clear() { + this.clearEvents(); + } + /** + * Destroy instance of EventManager, clearing all events of the context. + */ + + }, { + key: "destroy", + value: function destroy() { + this.clearEvents(); + this.context = null; + } + /** + * Destroy instance of EventManager, clearing only the own events. + */ + + }, { + key: "destroyWithOwnEventsOnly", + value: function destroyWithOwnEventsOnly() { + this.clearEvents(true); + this.context = null; + } + /** + * Trigger event at the specified target element. + * + * @param {Element} element Target element. + * @param {string} eventName Event name. + */ + + }, { + key: "fireEvent", + value: function fireEvent(element, eventName) { + var rootDocument = element.document; + var rootWindow = element; + + if (!rootDocument) { + rootDocument = element.ownerDocument ? element.ownerDocument : element; + rootWindow = rootDocument.defaultView; + } + + var options = { + bubbles: true, + cancelable: eventName !== 'mousemove', + view: rootWindow, + detail: 0, + screenX: 0, + screenY: 0, + clientX: 1, + clientY: 1, + ctrlKey: false, + altKey: false, + shiftKey: false, + metaKey: false, + button: 0, + relatedTarget: undefined + }; + var event; + + if (rootDocument.createEvent) { + event = rootDocument.createEvent('MouseEvents'); + event.initMouseEvent(eventName, options.bubbles, options.cancelable, options.view, options.detail, options.screenX, options.screenY, options.clientX, options.clientY, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, options.button, rootDocument.body.parentNode); + } else { + event = rootDocument.createEventObject(); + } + + if (element.dispatchEvent) { + element.dispatchEvent(event); + } else { + element.fireEvent("on".concat(eventName), event); + } + } + }]); + + return EventManager; +}(); +/** + * @private + * @param {Event} event The event object. + * @returns {Event} + */ + + +function extendEvent(event) { + var nativeStopImmediatePropagation = event.stopImmediatePropagation; + + event.stopImmediatePropagation = function () { + nativeStopImmediatePropagation.apply(this); + + stopImmediatePropagation(this); + }; + + return event; +} +/** + * @returns {number} + */ + +function getListenersCounter() { + return listenersCounter; +} + +function _classCallCheck$p(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$o(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); } } + +function _createClass$o(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$o(Constructor.prototype, protoProps); if (staticProps) _defineProperties$o(Constructor, staticProps); return Constructor; } +/** + * Creates an overlay over the original Walkontable instance. The overlay renders the clone of the original Walkontable + * and (optionally) implements behavior needed for native horizontal and vertical scrolling. + * + * @class Overlay + */ + +var Overlay = /*#__PURE__*/function () { + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + function Overlay(wotInstance) { + _classCallCheck$p(this, Overlay); + + defineGetter(this, 'wot', wotInstance, { + writable: false + }); + var _this$wot$wtTable = this.wot.wtTable, + TABLE = _this$wot$wtTable.TABLE, + hider = _this$wot$wtTable.hider, + spreader = _this$wot$wtTable.spreader, + holder = _this$wot$wtTable.holder, + wtRootElement = _this$wot$wtTable.wtRootElement; // legacy support, deprecated in the future + + this.instance = this.wot; + this.type = ''; + this.mainTableScrollableElement = null; + this.TABLE = TABLE; + this.hider = hider; + this.spreader = spreader; + this.holder = holder; + this.wtRootElement = wtRootElement; + this.trimmingContainer = getTrimmingContainer(this.hider.parentNode.parentNode); + this.updateStateOfRendering(); + } + /** + * Update internal state of object with an information about the need of full rendering of the overlay. + * + * @returns {boolean} Returns `true` if the state has changed since the last check. + */ + + + _createClass$o(Overlay, [{ + key: "updateStateOfRendering", + value: function updateStateOfRendering() { + var previousState = this.needFullRender; + this.needFullRender = this.shouldBeRendered(); + var changed = previousState !== this.needFullRender; + + if (changed && !this.needFullRender) { + this.reset(); + } + + return changed; + } + /** + * Checks if overlay should be fully rendered. + * + * @returns {boolean} + */ + + }, { + key: "shouldBeRendered", + value: function shouldBeRendered() { + return true; + } + /** + * Update the trimming container. + */ + + }, { + key: "updateTrimmingContainer", + value: function updateTrimmingContainer() { + this.trimmingContainer = getTrimmingContainer(this.hider.parentNode.parentNode); + } + /** + * Update the main scrollable element. + */ + + }, { + key: "updateMainScrollableElement", + value: function updateMainScrollableElement() { + var _this$wot = this.wot, + wtTable = _this$wot.wtTable, + rootWindow = _this$wot.rootWindow; + + if (rootWindow.getComputedStyle(wtTable.wtRootElement.parentNode).getPropertyValue('overflow') === 'hidden') { + this.mainTableScrollableElement = this.wot.wtTable.holder; + } else { + this.mainTableScrollableElement = getScrollableElement(wtTable.TABLE); + } + } + /** + * Calculates coordinates of the provided element, relative to the root Handsontable element. + * NOTE: The element needs to be a child of the overlay in order for the method to work correctly. + * + * @param {HTMLElement} element The cell element to calculate the position for. + * @param {number} rowIndex Visual row index. + * @param {number} columnIndex Visual column index. + * @returns {{top: number, left: number}|undefined} + */ + + }, { + key: "getRelativeCellPosition", + value: function getRelativeCellPosition(element, rowIndex, columnIndex) { + if (this.clone.wtTable.holder.contains(element) === false) { + warn("The provided element is not a child of the ".concat(this.type, " overlay")); + return; + } + + var windowScroll = this.mainTableScrollableElement === this.wot.rootWindow; + var fixedColumn = columnIndex < this.wot.getSetting('fixedColumnsLeft'); + var fixedRowTop = rowIndex < this.wot.getSetting('fixedRowsTop'); + var fixedRowBottom = rowIndex >= this.wot.getSetting('totalRows') - this.wot.getSetting('fixedRowsBottom'); + var spreaderOffset = { + left: this.clone.wtTable.spreader.offsetLeft, + top: this.clone.wtTable.spreader.offsetTop + }; + var elementOffset = { + left: element.offsetLeft, + top: element.offsetTop + }; + var offsetObject = null; + + if (windowScroll) { + offsetObject = this.getRelativeCellPositionWithinWindow(fixedRowTop, fixedColumn, elementOffset, spreaderOffset); + } else { + offsetObject = this.getRelativeCellPositionWithinHolder(fixedRowTop, fixedRowBottom, fixedColumn, elementOffset, spreaderOffset); + } + + return offsetObject; + } + /** + * Calculates coordinates of the provided element, relative to the root Handsontable element within a table with window + * as a scrollable element. + * + * @private + * @param {boolean} onFixedRowTop `true` if the coordinates point to a place within the top fixed rows. + * @param {boolean} onFixedColumn `true` if the coordinates point to a place within the fixed columns. + * @param {number} elementOffset Offset position of the cell element. + * @param {number} spreaderOffset Offset position of the spreader element. + * @returns {{top: number, left: number}} + */ + + }, { + key: "getRelativeCellPositionWithinWindow", + value: function getRelativeCellPositionWithinWindow(onFixedRowTop, onFixedColumn, elementOffset, spreaderOffset) { + var absoluteRootElementPosition = this.wot.wtTable.wtRootElement.getBoundingClientRect(); + var horizontalOffset = 0; + var verticalOffset = 0; + + if (!onFixedColumn) { + horizontalOffset = spreaderOffset.left; + } else { + horizontalOffset = absoluteRootElementPosition.left <= 0 ? -1 * absoluteRootElementPosition.left : 0; + } + + if (onFixedRowTop) { + var absoluteOverlayPosition = this.clone.wtTable.TABLE.getBoundingClientRect(); + verticalOffset = absoluteOverlayPosition.top - absoluteRootElementPosition.top; + } else { + verticalOffset = spreaderOffset.top; + } + + return { + left: elementOffset.left + horizontalOffset, + top: elementOffset.top + verticalOffset + }; + } + /** + * Calculates coordinates of the provided element, relative to the root Handsontable element within a table with window + * as a scrollable element. + * + * @private + * @param {boolean} onFixedRowTop `true` if the coordinates point to a place within the top fixed rows. + * @param {boolean} onFixedRowBottom `true` if the coordinates point to a place within the bottom fixed rows. + * @param {boolean} onFixedColumn `true` if the coordinates point to a place within the fixed columns. + * @param {number} elementOffset Offset position of the cell element. + * @param {number} spreaderOffset Offset position of the spreader element. + * @returns {{top: number, left: number}} + */ + + }, { + key: "getRelativeCellPositionWithinHolder", + value: function getRelativeCellPositionWithinHolder(onFixedRowTop, onFixedRowBottom, onFixedColumn, elementOffset, spreaderOffset) { + var tableScrollPosition = { + horizontal: this.clone.cloneSource.wtOverlays.leftOverlay.getScrollPosition(), + vertical: this.clone.cloneSource.wtOverlays.topOverlay.getScrollPosition() + }; + var horizontalOffset = 0; + var verticalOffset = 0; + + if (!onFixedColumn) { + horizontalOffset = tableScrollPosition.horizontal - spreaderOffset.left; + } + + if (onFixedRowBottom) { + var absoluteRootElementPosition = this.wot.wtTable.wtRootElement.getBoundingClientRect(); + var absoluteOverlayPosition = this.clone.wtTable.TABLE.getBoundingClientRect(); + verticalOffset = absoluteOverlayPosition.top * -1 + absoluteRootElementPosition.top; + } else if (!onFixedRowTop) { + verticalOffset = tableScrollPosition.vertical - spreaderOffset.top; + } + + return { + left: elementOffset.left - horizontalOffset, + top: elementOffset.top - verticalOffset + }; + } + /** + * Make a clone of table for overlay. + * + * @param {string} direction Can be `Overlay.CLONE_TOP`, `Overlay.CLONE_LEFT`, + * `Overlay.CLONE_TOP_LEFT_CORNER`. + * @returns {Walkontable} + */ + + }, { + key: "makeClone", + value: function makeClone(direction) { + if (CLONE_TYPES.indexOf(direction) === -1) { + throw new Error("Clone type \"".concat(direction, "\" is not supported.")); + } + + var _this$wot2 = this.wot, + wtTable = _this$wot2.wtTable, + rootDocument = _this$wot2.rootDocument, + rootWindow = _this$wot2.rootWindow; + var clone = rootDocument.createElement('DIV'); + var clonedTable = rootDocument.createElement('TABLE'); + var tableParent = wtTable.wtRootElement.parentNode; + clone.className = "ht_clone_".concat(direction, " handsontable"); + clone.style.position = 'absolute'; + clone.style.top = 0; + clone.style.left = 0; + clone.style.overflow = 'visible'; + clonedTable.className = wtTable.TABLE.className; + clone.appendChild(clonedTable); + this.type = direction; + tableParent.appendChild(clone); + var preventOverflow = this.wot.getSetting('preventOverflow'); + + if (preventOverflow === true || preventOverflow === 'horizontal' && this.type === CLONE_TOP || preventOverflow === 'vertical' && this.type === CLONE_LEFT) { + this.mainTableScrollableElement = rootWindow; + } else if (rootWindow.getComputedStyle(tableParent).getPropertyValue('overflow') === 'hidden') { + this.mainTableScrollableElement = wtTable.holder; + } else { + this.mainTableScrollableElement = getScrollableElement(wtTable.TABLE); + } // Create a new instance of the Walkontable class + + + return new this.wot.constructor({ + cloneSource: this.wot, + cloneOverlay: this, + table: clonedTable + }); + } + /** + * Refresh/Redraw overlay. + * + * @param {boolean} [fastDraw=false] When `true`, try to refresh only the positions of borders without rerendering + * the data. It will only work if Table.draw() does not force + * rendering anyway. + */ + + }, { + key: "refresh", + value: function refresh() { + var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + // When hot settings are changed we allow to refresh overlay once before blocking + var nextCycleRenderFlag = this.shouldBeRendered(); + + if (this.clone && (this.needFullRender || nextCycleRenderFlag)) { + this.clone.draw(fastDraw); + } + + this.needFullRender = nextCycleRenderFlag; + } + /** + * Reset overlay styles to initial values. + */ + + }, { + key: "reset", + value: function reset() { + if (!this.clone) { + return; + } + + var holder = this.clone.wtTable.holder; + var hider = this.clone.wtTable.hider; + var holderStyle = holder.style; + var hidderStyle = hider.style; + var rootStyle = holder.parentNode.style; + arrayEach([holderStyle, hidderStyle, rootStyle], function (style) { + style.width = ''; + style.height = ''; + }); + } + /** + * Destroy overlay instance. + */ + + }, { + key: "destroy", + value: function destroy() { + new EventManager(this.clone).destroy(); + } + }]); + + return Overlay; +}(); + +function _typeof$d(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$d = function _typeof(obj) { return typeof obj; }; } else { _typeof$d = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$d(obj); } + +function _construct(Parent, args, Class) { if (_isNativeReflectConstruct$8()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf$8(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } + +function _classCallCheck$q(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$p(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); } } + +function _createClass$p(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$p(Constructor.prototype, protoProps); if (staticProps) _defineProperties$p(Constructor, staticProps); return Constructor; } + +function _inherits$8(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$8(subClass, superClass); } + +function _setPrototypeOf$8(o, p) { _setPrototypeOf$8 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$8(o, p); } + +function _createSuper$8(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$8(); return function _createSuperInternal() { var Super = _getPrototypeOf$8(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$8(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$8(this, result); }; } + +function _possibleConstructorReturn$8(self, call) { if (call && (_typeof$d(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$8(self); } + +function _assertThisInitialized$8(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$8() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$8(o) { _getPrototypeOf$8 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$8(o); } +/** + * @class TopLeftCornerOverlay + */ + +var BottomLeftCornerOverlay = /*#__PURE__*/function (_Overlay) { + _inherits$8(BottomLeftCornerOverlay, _Overlay); + + var _super = _createSuper$8(BottomLeftCornerOverlay); + + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + function BottomLeftCornerOverlay(wotInstance) { + var _this; + + _classCallCheck$q(this, BottomLeftCornerOverlay); + + _this = _super.call(this, wotInstance); + _this.clone = _this.makeClone(CLONE_BOTTOM_LEFT_CORNER); + return _this; + } + /** + * Factory method to create a subclass of `Table` that is relevant to this overlay. + * + * @see Table#constructor + * @param {...*} args Parameters that will be forwarded to the `Table` constructor. + * @returns {Table} + */ + + + _createClass$p(BottomLeftCornerOverlay, [{ + key: "createTable", + value: function createTable() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return _construct(BottomLeftCornerOverlayTable, args); + } + /** + * Checks if overlay should be fully rendered. + * + * @returns {boolean} + */ + + }, { + key: "shouldBeRendered", + value: function shouldBeRendered() { + var wot = this.wot; + return wot.getSetting('shouldRenderBottomOverlay') && wot.getSetting('shouldRenderLeftOverlay'); + } + /** + * Updates the corner overlay position. + * + * @returns {boolean} + */ + + }, { + key: "resetFixedPosition", + value: function resetFixedPosition() { + var wot = this.wot; + this.updateTrimmingContainer(); + + if (!wot.wtTable.holder.parentNode) { + // removed from DOM + return; + } + + var overlayRoot = this.clone.wtTable.holder.parentNode; + overlayRoot.style.top = ''; + + if (this.trimmingContainer === wot.rootWindow) { + var _this$wot = this.wot, + rootDocument = _this$wot.rootDocument, + wtTable = _this$wot.wtTable; + var hiderRect = wtTable.hider.getBoundingClientRect(); + var bottom = Math.ceil(hiderRect.bottom); + var left = Math.ceil(hiderRect.left); + var bodyHeight = rootDocument.documentElement.clientHeight; + var finalLeft; + var finalBottom; + + if (left < 0) { + finalLeft = -left; + } else { + finalLeft = 0; + } + + if (bottom > bodyHeight) { + finalBottom = bottom - bodyHeight; + } else { + finalBottom = 0; + } + + finalBottom += 'px'; + finalLeft += 'px'; + overlayRoot.style.left = finalLeft; + overlayRoot.style.bottom = finalBottom; + } else { + resetCssTransform(overlayRoot); + this.repositionOverlay(); + } + + var tableHeight = outerHeight(this.clone.wtTable.TABLE); + var tableWidth = outerWidth(this.clone.wtTable.TABLE); + + if (!this.wot.wtTable.hasDefinedSize()) { + tableHeight = 0; + } + + overlayRoot.style.height = "".concat(tableHeight, "px"); + overlayRoot.style.width = "".concat(tableWidth, "px"); + return false; + } + /** + * Reposition the overlay. + */ + + }, { + key: "repositionOverlay", + value: function repositionOverlay() { + var _this$wot2 = this.wot, + wtTable = _this$wot2.wtTable, + rootDocument = _this$wot2.rootDocument; + var cloneRoot = this.clone.wtTable.holder.parentNode; + var scrollbarWidth = getScrollbarWidth(rootDocument); + + if (wtTable.holder.clientHeight === wtTable.holder.offsetHeight) { + scrollbarWidth = 0; + } + + cloneRoot.style.bottom = "".concat(scrollbarWidth, "px"); + } + }], [{ + key: "OVERLAY_NAME", + get: function get() { + return CLONE_BOTTOM_LEFT_CORNER; + } + }]); + + return BottomLeftCornerOverlay; +}(Overlay); + +function _typeof$e(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$e = function _typeof(obj) { return typeof obj; }; } else { _typeof$e = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$e(obj); } + +function _classCallCheck$r(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits$9(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$9(subClass, superClass); } + +function _setPrototypeOf$9(o, p) { _setPrototypeOf$9 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$9(o, p); } + +function _createSuper$9(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$9(); return function _createSuperInternal() { var Super = _getPrototypeOf$9(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$9(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$9(this, result); }; } + +function _possibleConstructorReturn$9(self, call) { if (call && (_typeof$e(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$9(self); } + +function _assertThisInitialized$9(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$9() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$9(o) { _getPrototypeOf$9 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$9(o); } +/** + * Subclass of `Table` that provides the helper methods relevant to BottomOverlay, implemented through mixins. + */ + +var BottomOverlayTable = /*#__PURE__*/function (_Table) { + _inherits$9(BottomOverlayTable, _Table); + + var _super = _createSuper$9(BottomOverlayTable); + + function BottomOverlayTable() { + _classCallCheck$r(this, BottomOverlayTable); + + return _super.apply(this, arguments); + } + + return BottomOverlayTable; +}(Table); + +mixin(BottomOverlayTable, stickyRowsBottom); +mixin(BottomOverlayTable, calculatedColumns); + +function _typeof$f(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$f = function _typeof(obj) { return typeof obj; }; } else { _typeof$f = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$f(obj); } + +function _construct$1(Parent, args, Class) { if (_isNativeReflectConstruct$a()) { _construct$1 = Reflect.construct; } else { _construct$1 = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf$a(instance, Class.prototype); return instance; }; } return _construct$1.apply(null, arguments); } + +function _classCallCheck$s(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$q(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); } } + +function _createClass$q(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$q(Constructor.prototype, protoProps); if (staticProps) _defineProperties$q(Constructor, staticProps); return Constructor; } + +function _inherits$a(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$a(subClass, superClass); } + +function _setPrototypeOf$a(o, p) { _setPrototypeOf$a = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$a(o, p); } + +function _createSuper$a(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$a(); return function _createSuperInternal() { var Super = _getPrototypeOf$a(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$a(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$a(this, result); }; } + +function _possibleConstructorReturn$a(self, call) { if (call && (_typeof$f(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$a(self); } + +function _assertThisInitialized$a(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$a() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$a(o) { _getPrototypeOf$a = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$a(o); } + +function _defineProperty$1(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +/** + * @class BottomOverlay + */ + +var BottomOverlay = /*#__PURE__*/function (_Overlay) { + _inherits$a(BottomOverlay, _Overlay); + + var _super = _createSuper$a(BottomOverlay); + + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + function BottomOverlay(wotInstance) { + var _this; + + _classCallCheck$s(this, BottomOverlay); + + _this = _super.call(this, wotInstance); + + _defineProperty$1(_assertThisInitialized$a(_this), "cachedFixedRowsBottom", -1); + + _this.clone = _this.makeClone(CLONE_BOTTOM); + return _this; + } + /** + * Factory method to create a subclass of `Table` that is relevant to this overlay. + * + * @see Table#constructor + * @param {...*} args Parameters that will be forwarded to the `Table` constructor. + * @returns {Table} + */ + + + _createClass$q(BottomOverlay, [{ + key: "createTable", + value: function createTable() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return _construct$1(BottomOverlayTable, args); + } + /** + * Checks if overlay should be fully rendered. + * + * @returns {boolean} + */ + + }, { + key: "shouldBeRendered", + value: function shouldBeRendered() { + return this.wot.getSetting('shouldRenderBottomOverlay'); + } + /** + * Updates the top overlay position. + * + * @returns {boolean} + */ + + }, { + key: "resetFixedPosition", + value: function resetFixedPosition() { + if (!this.needFullRender || !this.wot.wtTable.holder.parentNode) { + // removed from DOM + return; + } + + var overlayRoot = this.clone.wtTable.holder.parentNode; + overlayRoot.style.top = ''; + var headerPosition = 0; + var preventOverflow = this.wot.getSetting('preventOverflow'); + + if (this.trimmingContainer === this.wot.rootWindow && (!preventOverflow || preventOverflow !== 'vertical')) { + var _this$wot = this.wot, + rootDocument = _this$wot.rootDocument, + wtTable = _this$wot.wtTable; + var hiderRect = wtTable.hider.getBoundingClientRect(); + var bottom = Math.ceil(hiderRect.bottom); + var bodyHeight = rootDocument.documentElement.clientHeight; + var finalLeft; + var finalBottom; + finalLeft = wtTable.hider.style.left; + finalLeft = finalLeft === '' ? 0 : finalLeft; + + if (bottom > bodyHeight) { + finalBottom = bottom - bodyHeight; + } else { + finalBottom = 0; + } + + headerPosition = finalBottom; + finalBottom += 'px'; + overlayRoot.style.left = finalLeft; + overlayRoot.style.bottom = finalBottom; + } else { + headerPosition = this.getScrollPosition(); + this.repositionOverlay(); + } + + var positionChanged = this.adjustHeaderBordersPosition(headerPosition); + this.adjustElementsSize(); + return positionChanged; + } + /** + * Updates the bottom overlay position. + */ + + }, { + key: "repositionOverlay", + value: function repositionOverlay() { + var _this$wot2 = this.wot, + wtTable = _this$wot2.wtTable, + rootDocument = _this$wot2.rootDocument; + var cloneRoot = this.clone.wtTable.holder.parentNode; + var scrollbarWidth = getScrollbarWidth(rootDocument); + + if (wtTable.holder.clientHeight === wtTable.holder.offsetHeight) { + scrollbarWidth = 0; + } + + cloneRoot.style.bottom = "".concat(scrollbarWidth, "px"); + } + /** + * Sets the main overlay's vertical scroll position. + * + * @param {number} pos The scroll position. + * @returns {boolean} + */ + + }, { + key: "setScrollPosition", + value: function setScrollPosition(pos) { + var rootWindow = this.wot.rootWindow; + var result = false; + + if (this.mainTableScrollableElement === rootWindow) { + rootWindow.scrollTo(getWindowScrollLeft(rootWindow), pos); + result = true; + } else if (this.mainTableScrollableElement.scrollTop !== pos) { + this.mainTableScrollableElement.scrollTop = pos; + result = true; + } + + return result; + } + /** + * Triggers onScroll hook callback. + */ + + }, { + key: "onScroll", + value: function onScroll() { + this.wot.getSetting('onScrollHorizontally'); + } + /** + * Calculates total sum cells height. + * + * @param {number} from Row index which calculates started from. + * @param {number} to Row index where calculation is finished. + * @returns {number} Height sum. + */ + + }, { + key: "sumCellSizes", + value: function sumCellSizes(from, to) { + var _this$wot3 = this.wot, + wtTable = _this$wot3.wtTable, + wtSettings = _this$wot3.wtSettings; + var defaultRowHeight = wtSettings.settings.defaultRowHeight; + var row = from; + var sum = 0; + + while (row < to) { + var height = wtTable.getRowHeight(row); + sum += height === void 0 ? defaultRowHeight : height; + row += 1; + } + + return sum; + } + /** + * Adjust overlay root element, childs and master table element sizes (width, height). + * + * @param {boolean} [force=false] When `true`, it adjusts the DOM nodes sizes for that overlay. + */ + + }, { + key: "adjustElementsSize", + value: function adjustElementsSize() { + var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + this.updateTrimmingContainer(); + + if (this.needFullRender || force) { + this.adjustRootElementSize(); + this.adjustRootChildrenSize(); + } + } + /** + * Adjust overlay root element size (width and height). + */ + + }, { + key: "adjustRootElementSize", + value: function adjustRootElementSize() { + var _this$wot4 = this.wot, + wtTable = _this$wot4.wtTable, + wtViewport = _this$wot4.wtViewport, + rootWindow = _this$wot4.rootWindow; + var scrollbarWidth = getScrollbarWidth(this.wot.rootDocument); + var overlayRoot = this.clone.wtTable.holder.parentNode; + var overlayRootStyle = overlayRoot.style; + var preventOverflow = this.wot.getSetting('preventOverflow'); + + if (this.trimmingContainer !== rootWindow || preventOverflow === 'horizontal') { + var width = wtViewport.getWorkspaceWidth(); + + if (this.wot.wtOverlays.hasScrollbarRight) { + width -= scrollbarWidth; + } + + width = Math.min(width, wtTable.wtRootElement.scrollWidth); + overlayRootStyle.width = "".concat(width, "px"); + } else { + overlayRootStyle.width = ''; + } + + this.clone.wtTable.holder.style.width = overlayRootStyle.width; + var tableHeight = outerHeight(this.clone.wtTable.TABLE); + + if (!this.wot.wtTable.hasDefinedSize()) { + tableHeight = 0; + } + + overlayRootStyle.height = "".concat(tableHeight, "px"); + } + /** + * Adjust overlay root childs size. + */ + + }, { + key: "adjustRootChildrenSize", + value: function adjustRootChildrenSize() { + var holder = this.clone.wtTable.holder; + this.clone.wtTable.hider.style.width = this.hider.style.width; + holder.style.width = holder.parentNode.style.width; + holder.style.height = holder.parentNode.style.height; + } + /** + * Adjust the overlay dimensions and position. + */ + + }, { + key: "applyToDOM", + value: function applyToDOM() { + var total = this.wot.getSetting('totalRows'); + + if (typeof this.wot.wtViewport.rowsRenderCalculator.startPosition === 'number') { + this.spreader.style.top = "".concat(this.wot.wtViewport.rowsRenderCalculator.startPosition, "px"); + } else if (total === 0) { + // can happen if there are 0 rows + this.spreader.style.top = '0'; + } else { + throw new Error('Incorrect value of the rowsRenderCalculator'); + } + + this.spreader.style.bottom = ''; + + if (this.needFullRender) { + this.syncOverlayOffset(); + } + } + /** + * Synchronize calculated left position to an element. + */ + + }, { + key: "syncOverlayOffset", + value: function syncOverlayOffset() { + if (typeof this.wot.wtViewport.columnsRenderCalculator.startPosition === 'number') { + this.clone.wtTable.spreader.style.left = "".concat(this.wot.wtViewport.columnsRenderCalculator.startPosition, "px"); + } else { + this.clone.wtTable.spreader.style.left = ''; + } + } + /** + * Scrolls vertically to a row. + * + * @param {number} sourceRow Row index which you want to scroll to. + * @param {boolean} [bottomEdge=false] If `true`, scrolls according to the bottom edge (top edge is by default). + */ + + }, { + key: "scrollTo", + value: function scrollTo(sourceRow, bottomEdge) { + var newY = this.getTableParentOffset(); + var sourceInstance = this.wot.cloneSource ? this.wot.cloneSource : this.wot; + var mainHolder = sourceInstance.wtTable.holder; + var scrollbarCompensation = 0; + + if (bottomEdge && mainHolder.offsetHeight !== mainHolder.clientHeight) { + scrollbarCompensation = getScrollbarWidth(this.wot.rootDocument); + } + + if (bottomEdge) { + newY += this.sumCellSizes(0, sourceRow + 1); + newY -= this.wot.wtViewport.getViewportHeight(); // Fix 1 pixel offset when cell is selected + + newY += 1; + } else { + newY += this.sumCellSizes(this.wot.getSetting('fixedRowsBottom'), sourceRow); + } + + newY += scrollbarCompensation; + this.setScrollPosition(newY); + } + /** + * Gets table parent top position. + * + * @returns {number} + */ + + }, { + key: "getTableParentOffset", + value: function getTableParentOffset() { + if (this.mainTableScrollableElement === this.wot.rootWindow) { + return this.wot.wtTable.holderOffset.top; + } + + return 0; + } + /** + * Gets the main overlay's vertical scroll position. + * + * @returns {number} Main table's vertical scroll position. + */ + + }, { + key: "getScrollPosition", + value: function getScrollPosition() { + return getScrollTop(this.mainTableScrollableElement, this.wot.rootWindow); + } + /** + * Adds css classes to hide the header border's header (cell-selection border hiding issue). + * + * @param {number} position Header Y position if trimming container is window or scroll top if not. + * @returns {boolean} + */ + + }, { + key: "adjustHeaderBordersPosition", + value: function adjustHeaderBordersPosition(position) { + var fixedRowsBottom = this.wot.getSetting('fixedRowsBottom'); + var areFixedRowsBottomChanged = this.cachedFixedRowsBottom !== fixedRowsBottom; + var columnHeaders = this.wot.getSetting('columnHeaders'); + var positionChanged = false; + + if ((areFixedRowsBottomChanged || fixedRowsBottom === 0) && columnHeaders.length > 0) { + var masterParent = this.wot.wtTable.holder.parentNode; + var previousState = hasClass(masterParent, 'innerBorderBottom'); + this.cachedFixedRowsBottom = this.wot.getSetting('fixedRowsBottom'); + + if (position || this.wot.getSetting('totalRows') === 0) { + addClass(masterParent, 'innerBorderBottom'); + positionChanged = !previousState; + } else { + removeClass(masterParent, 'innerBorderBottom'); + positionChanged = previousState; + } + } + + return positionChanged; + } + }], [{ + key: "OVERLAY_NAME", + get: function get() { + return CLONE_BOTTOM; + } + /** + * Cached value which holds the previous value of the `fixedRowsBottom` option. + * It is used as a comparison value that can be used to detect changes in that value. + * + * @type {number} + */ + + }]); + + return BottomOverlay; +}(Overlay); + +function _typeof$g(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$g = function _typeof(obj) { return typeof obj; }; } else { _typeof$g = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$g(obj); } + +function _classCallCheck$t(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits$b(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$b(subClass, superClass); } + +function _setPrototypeOf$b(o, p) { _setPrototypeOf$b = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$b(o, p); } + +function _createSuper$b(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$b(); return function _createSuperInternal() { var Super = _getPrototypeOf$b(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$b(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$b(this, result); }; } + +function _possibleConstructorReturn$b(self, call) { if (call && (_typeof$g(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$b(self); } + +function _assertThisInitialized$b(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$b() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$b(o) { _getPrototypeOf$b = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$b(o); } +/** + * Subclass of `Table` that provides the helper methods relevant to LeftOverlay, implemented through mixins. + */ + +var LeftOverlayTable = /*#__PURE__*/function (_Table) { + _inherits$b(LeftOverlayTable, _Table); + + var _super = _createSuper$b(LeftOverlayTable); + + function LeftOverlayTable() { + _classCallCheck$t(this, LeftOverlayTable); + + return _super.apply(this, arguments); + } + + return LeftOverlayTable; +}(Table); + +mixin(LeftOverlayTable, calculatedRows); +mixin(LeftOverlayTable, stickyColumnsLeft); + +function _typeof$h(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$h = function _typeof(obj) { return typeof obj; }; } else { _typeof$h = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$h(obj); } + +function _construct$2(Parent, args, Class) { if (_isNativeReflectConstruct$c()) { _construct$2 = Reflect.construct; } else { _construct$2 = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf$c(instance, Class.prototype); return instance; }; } return _construct$2.apply(null, arguments); } + +function _classCallCheck$u(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$r(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); } } + +function _createClass$r(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$r(Constructor.prototype, protoProps); if (staticProps) _defineProperties$r(Constructor, staticProps); return Constructor; } + +function _inherits$c(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$c(subClass, superClass); } + +function _setPrototypeOf$c(o, p) { _setPrototypeOf$c = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$c(o, p); } + +function _createSuper$c(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$c(); return function _createSuperInternal() { var Super = _getPrototypeOf$c(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$c(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$c(this, result); }; } + +function _possibleConstructorReturn$c(self, call) { if (call && (_typeof$h(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$c(self); } + +function _assertThisInitialized$c(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$c() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$c(o) { _getPrototypeOf$c = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$c(o); } +/** + * @class LeftOverlay + */ + +var LeftOverlay = /*#__PURE__*/function (_Overlay) { + _inherits$c(LeftOverlay, _Overlay); + + var _super = _createSuper$c(LeftOverlay); + + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + function LeftOverlay(wotInstance) { + var _this; + + _classCallCheck$u(this, LeftOverlay); + + _this = _super.call(this, wotInstance); + _this.clone = _this.makeClone(CLONE_LEFT); + return _this; + } + /** + * Factory method to create a subclass of `Table` that is relevant to this overlay. + * + * @see Table#constructor + * @param {...*} args Parameters that will be forwarded to the `Table` constructor. + * @returns {Table} + */ + + + _createClass$r(LeftOverlay, [{ + key: "createTable", + value: function createTable() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return _construct$2(LeftOverlayTable, args); + } + /** + * Checks if overlay should be fully rendered. + * + * @returns {boolean} + */ + + }, { + key: "shouldBeRendered", + value: function shouldBeRendered() { + return this.wot.getSetting('shouldRenderLeftOverlay'); + } + /** + * Updates the left overlay position. + * + * @returns {boolean} + */ + + }, { + key: "resetFixedPosition", + value: function resetFixedPosition() { + var wtTable = this.wot.wtTable; + + if (!this.needFullRender || !wtTable.holder.parentNode) { + // removed from DOM + return; + } + + var overlayRoot = this.clone.wtTable.holder.parentNode; + var headerPosition = 0; + var preventOverflow = this.wot.getSetting('preventOverflow'); + + if (this.trimmingContainer === this.wot.rootWindow && (!preventOverflow || preventOverflow !== 'horizontal')) { + var hiderRect = wtTable.hider.getBoundingClientRect(); + var left = Math.ceil(hiderRect.left); + var right = Math.ceil(hiderRect.right); + var finalLeft; + var finalTop; + finalTop = wtTable.hider.style.top; + finalTop = finalTop === '' ? 0 : finalTop; + + if (left < 0 && right - overlayRoot.offsetWidth > 0) { + finalLeft = -left; + } else { + finalLeft = 0; + } + + headerPosition = finalLeft; + finalLeft += 'px'; + setOverlayPosition(overlayRoot, finalLeft, finalTop); + } else { + headerPosition = this.getScrollPosition(); + resetCssTransform(overlayRoot); + } + + var positionChanged = this.adjustHeaderBordersPosition(headerPosition); + this.adjustElementsSize(); + return positionChanged; + } + /** + * Sets the main overlay's horizontal scroll position. + * + * @param {number} pos The scroll position. + * @returns {boolean} + */ + + }, { + key: "setScrollPosition", + value: function setScrollPosition(pos) { + var rootWindow = this.wot.rootWindow; + var result = false; + + if (this.mainTableScrollableElement === rootWindow && rootWindow.scrollX !== pos) { + rootWindow.scrollTo(pos, getWindowScrollTop(rootWindow)); + result = true; + } else if (this.mainTableScrollableElement.scrollLeft !== pos) { + this.mainTableScrollableElement.scrollLeft = pos; + result = true; + } + + return result; + } + /** + * Triggers onScroll hook callback. + */ + + }, { + key: "onScroll", + value: function onScroll() { + this.wot.getSetting('onScrollVertically'); + } + /** + * Calculates total sum cells width. + * + * @param {number} from Column index which calculates started from. + * @param {number} to Column index where calculation is finished. + * @returns {number} Width sum. + */ + + }, { + key: "sumCellSizes", + value: function sumCellSizes(from, to) { + var defaultColumnWidth = this.wot.wtSettings.defaultColumnWidth; + var column = from; + var sum = 0; + + while (column < to) { + sum += this.wot.wtTable.getStretchedColumnWidth(column) || defaultColumnWidth; + column += 1; + } + + return sum; + } + /** + * Adjust overlay root element, childs and master table element sizes (width, height). + * + * @param {boolean} [force=false] When `true`, it adjusts the DOM nodes sizes for that overlay. + */ + + }, { + key: "adjustElementsSize", + value: function adjustElementsSize() { + var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + this.updateTrimmingContainer(); + + if (this.needFullRender || force) { + this.adjustRootElementSize(); + this.adjustRootChildrenSize(); + } + } + /** + * Adjust overlay root element size (width and height). + */ + + }, { + key: "adjustRootElementSize", + value: function adjustRootElementSize() { + var _this$wot = this.wot, + wtTable = _this$wot.wtTable, + rootDocument = _this$wot.rootDocument, + rootWindow = _this$wot.rootWindow; + var scrollbarHeight = getScrollbarWidth(rootDocument); + var overlayRoot = this.clone.wtTable.holder.parentNode; + var overlayRootStyle = overlayRoot.style; + var preventOverflow = this.wot.getSetting('preventOverflow'); + + if (this.trimmingContainer !== rootWindow || preventOverflow === 'vertical') { + var height = this.wot.wtViewport.getWorkspaceHeight(); + + if (this.wot.wtOverlays.hasScrollbarBottom) { + height -= scrollbarHeight; + } + + height = Math.min(height, wtTable.wtRootElement.scrollHeight); + overlayRootStyle.height = "".concat(height, "px"); + } else { + overlayRootStyle.height = ''; + } + + this.clone.wtTable.holder.style.height = overlayRootStyle.height; + var tableWidth = outerWidth(this.clone.wtTable.TABLE); + overlayRootStyle.width = "".concat(tableWidth, "px"); + } + /** + * Adjust overlay root childs size. + */ + + }, { + key: "adjustRootChildrenSize", + value: function adjustRootChildrenSize() { + var _selections$getCell$g; + + var holder = this.clone.wtTable.holder; + var selections = this.wot.selections; + var selectionCornerOffset = Math.abs((_selections$getCell$g = selections === null || selections === void 0 ? void 0 : selections.getCell().getBorder(this.wot).cornerCenterPointOffset) !== null && _selections$getCell$g !== void 0 ? _selections$getCell$g : 0); + this.clone.wtTable.hider.style.height = this.hider.style.height; + holder.style.height = holder.parentNode.style.height; // Add selection corner protruding part to the holder total width to make sure that + // borders' corner won't be cut after horizontal scroll (#6937). + + holder.style.width = "".concat(parseInt(holder.parentNode.style.width, 10) + selectionCornerOffset, "px"); + } + /** + * Adjust the overlay dimensions and position. + */ + + }, { + key: "applyToDOM", + value: function applyToDOM() { + var total = this.wot.getSetting('totalColumns'); + + if (typeof this.wot.wtViewport.columnsRenderCalculator.startPosition === 'number') { + this.spreader.style.left = "".concat(this.wot.wtViewport.columnsRenderCalculator.startPosition, "px"); + } else if (total === 0) { + this.spreader.style.left = '0'; + } else { + throw new Error('Incorrect value of the columnsRenderCalculator'); + } + + this.spreader.style.right = ''; + + if (this.needFullRender) { + this.syncOverlayOffset(); + } + } + /** + * Synchronize calculated top position to an element. + */ + + }, { + key: "syncOverlayOffset", + value: function syncOverlayOffset() { + if (typeof this.wot.wtViewport.rowsRenderCalculator.startPosition === 'number') { + this.clone.wtTable.spreader.style.top = "".concat(this.wot.wtViewport.rowsRenderCalculator.startPosition, "px"); + } else { + this.clone.wtTable.spreader.style.top = ''; + } + } + /** + * Scrolls horizontally to a column at the left edge of the viewport. + * + * @param {number} sourceCol Column index which you want to scroll to. + * @param {boolean} [beyondRendered] If `true`, scrolls according to the bottom + * edge (top edge is by default). + * @returns {boolean} + */ + + }, { + key: "scrollTo", + value: function scrollTo(sourceCol, beyondRendered) { + var newX = this.getTableParentOffset(); + var sourceInstance = this.wot.cloneSource ? this.wot.cloneSource : this.wot; + var mainHolder = sourceInstance.wtTable.holder; + var scrollbarCompensation = 0; + + if (beyondRendered && mainHolder.offsetWidth !== mainHolder.clientWidth) { + scrollbarCompensation = getScrollbarWidth(this.wot.rootDocument); + } + + if (beyondRendered) { + newX += this.sumCellSizes(0, sourceCol + 1); + newX -= this.wot.wtViewport.getViewportWidth(); + } else { + newX += this.sumCellSizes(this.wot.getSetting('fixedColumnsLeft'), sourceCol); + } + + newX += scrollbarCompensation; + return this.setScrollPosition(newX); + } + /** + * Gets table parent left position. + * + * @returns {number} + */ + + }, { + key: "getTableParentOffset", + value: function getTableParentOffset() { + var preventOverflow = this.wot.getSetting('preventOverflow'); + var offset = 0; + + if (!preventOverflow && this.trimmingContainer === this.wot.rootWindow) { + offset = this.wot.wtTable.holderOffset.left; + } + + return offset; + } + /** + * Gets the main overlay's horizontal scroll position. + * + * @returns {number} Main table's vertical scroll position. + */ + + }, { + key: "getScrollPosition", + value: function getScrollPosition() { + return getScrollLeft(this.mainTableScrollableElement, this.wot.rootWindow); + } + /** + * Adds css classes to hide the header border's header (cell-selection border hiding issue). + * + * @param {number} position Header X position if trimming container is window or scroll top if not. + * @returns {boolean} + */ + + }, { + key: "adjustHeaderBordersPosition", + value: function adjustHeaderBordersPosition(position) { + var masterParent = this.wot.wtTable.holder.parentNode; + var rowHeaders = this.wot.getSetting('rowHeaders'); + var fixedColumnsLeft = this.wot.getSetting('fixedColumnsLeft'); + var totalRows = this.wot.getSetting('totalRows'); + + if (totalRows) { + removeClass(masterParent, 'emptyRows'); + } else { + addClass(masterParent, 'emptyRows'); + } + + var positionChanged = false; + + if (fixedColumnsLeft && !rowHeaders.length) { + addClass(masterParent, 'innerBorderLeft'); + } else if (!fixedColumnsLeft && rowHeaders.length) { + var previousState = hasClass(masterParent, 'innerBorderLeft'); + + if (position) { + addClass(masterParent, 'innerBorderLeft'); + positionChanged = !previousState; + } else { + removeClass(masterParent, 'innerBorderLeft'); + positionChanged = previousState; + } + } + + return positionChanged; + } + }], [{ + key: "OVERLAY_NAME", + get: function get() { + return CLONE_LEFT; + } + }]); + + return LeftOverlay; +}(Overlay); + +var MIXIN_NAME$4 = 'stickyRowsTop'; +/** + * Mixin for the subclasses of `Table` with implementations of + * helper methods that are related to rows. + * This mixin is meant to be applied in the subclasses of `Table` + * that use sticky rendering of the top rows in the vertical axis. + * + * @type {object} + */ + +var stickyRowsTop = { + /** + * Get the source index of the first rendered row. If no rows are rendered, returns an error code: -1. + * + * @returns {number} + */ + getFirstRenderedRow: function getFirstRenderedRow() { + var totalRows = this.wot.getSetting('totalRows'); + + if (totalRows === 0) { + return -1; + } + + return 0; + }, + + /** + * Get the source index of the first row fully visible in the viewport. If no rows are fully visible, returns an error code: -1. + * Assumes that all rendered rows are fully visible. + * + * @returns {number} + */ + getFirstVisibleRow: function getFirstVisibleRow() { + return this.getFirstRenderedRow(); + }, + + /** + * Get the source index of the last rendered row. If no rows are rendered, returns an error code: -1. + * + * @returns {number} + */ + getLastRenderedRow: function getLastRenderedRow() { + return this.getRenderedRowsCount() - 1; + }, + + /** + * Get the source index of the last row fully visible in the viewport. If no rows are fully visible, returns an error code: -1. + * Assumes that all rendered rows are fully visible. + * + * @returns {number} + */ + getLastVisibleRow: function getLastVisibleRow() { + return this.getLastRenderedRow(); + }, + + /** + * Get the number of rendered rows. + * + * @returns {number} + */ + getRenderedRowsCount: function getRenderedRowsCount() { + var totalRows = this.wot.getSetting('totalRows'); + return Math.min(this.wot.getSetting('fixedRowsTop'), totalRows); + }, + + /** + * Get the number of fully visible rows in the viewport. + * Assumes that all rendered rows are fully visible. + * + * @returns {number} + */ + getVisibleRowsCount: function getVisibleRowsCount() { + return this.getRenderedRowsCount(); + } +}; +defineGetter(stickyRowsTop, 'MIXIN_NAME', MIXIN_NAME$4, { + writable: false, + enumerable: false +}); + +function _typeof$i(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$i = function _typeof(obj) { return typeof obj; }; } else { _typeof$i = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$i(obj); } + +function _classCallCheck$v(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits$d(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$d(subClass, superClass); } + +function _setPrototypeOf$d(o, p) { _setPrototypeOf$d = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$d(o, p); } + +function _createSuper$d(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$d(); return function _createSuperInternal() { var Super = _getPrototypeOf$d(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$d(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$d(this, result); }; } + +function _possibleConstructorReturn$d(self, call) { if (call && (_typeof$i(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$d(self); } + +function _assertThisInitialized$d(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$d() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$d(o) { _getPrototypeOf$d = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$d(o); } +/** + * Subclass of `Table` that provides the helper methods relevant to TopLeftCornerOverlay, implemented through mixins. + */ + +var TopLeftCornerOverlayTable = /*#__PURE__*/function (_Table) { + _inherits$d(TopLeftCornerOverlayTable, _Table); + + var _super = _createSuper$d(TopLeftCornerOverlayTable); + + function TopLeftCornerOverlayTable() { + _classCallCheck$v(this, TopLeftCornerOverlayTable); + + return _super.apply(this, arguments); + } + + return TopLeftCornerOverlayTable; +}(Table); + +mixin(TopLeftCornerOverlayTable, stickyRowsTop); +mixin(TopLeftCornerOverlayTable, stickyColumnsLeft); + +function _typeof$j(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$j = function _typeof(obj) { return typeof obj; }; } else { _typeof$j = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$j(obj); } + +function _construct$3(Parent, args, Class) { if (_isNativeReflectConstruct$e()) { _construct$3 = Reflect.construct; } else { _construct$3 = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf$e(instance, Class.prototype); return instance; }; } return _construct$3.apply(null, arguments); } + +function _classCallCheck$w(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$s(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); } } + +function _createClass$s(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$s(Constructor.prototype, protoProps); if (staticProps) _defineProperties$s(Constructor, staticProps); return Constructor; } + +function _inherits$e(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$e(subClass, superClass); } + +function _setPrototypeOf$e(o, p) { _setPrototypeOf$e = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$e(o, p); } + +function _createSuper$e(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$e(); return function _createSuperInternal() { var Super = _getPrototypeOf$e(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$e(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$e(this, result); }; } + +function _possibleConstructorReturn$e(self, call) { if (call && (_typeof$j(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$e(self); } + +function _assertThisInitialized$e(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$e() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$e(o) { _getPrototypeOf$e = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$e(o); } +/** + * @class TopLeftCornerOverlay + */ + +var TopLeftCornerOverlay = /*#__PURE__*/function (_Overlay) { + _inherits$e(TopLeftCornerOverlay, _Overlay); + + var _super = _createSuper$e(TopLeftCornerOverlay); + + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + function TopLeftCornerOverlay(wotInstance) { + var _this; + + _classCallCheck$w(this, TopLeftCornerOverlay); + + _this = _super.call(this, wotInstance); + _this.clone = _this.makeClone(CLONE_TOP_LEFT_CORNER); + return _this; + } + /** + * Factory method to create a subclass of `Table` that is relevant to this overlay. + * + * @see Table#constructor + * @param {...*} args Parameters that will be forwarded to the `Table` constructor. + * @returns {Table} + */ + + + _createClass$s(TopLeftCornerOverlay, [{ + key: "createTable", + value: function createTable() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return _construct$3(TopLeftCornerOverlayTable, args); + } + /** + * Checks if overlay should be fully rendered. + * + * @returns {boolean} + */ + + }, { + key: "shouldBeRendered", + value: function shouldBeRendered() { + var wot = this.wot; + return wot.getSetting('shouldRenderTopOverlay') && wot.getSetting('shouldRenderLeftOverlay'); + } + /** + * Updates the corner overlay position. + * + * @returns {boolean} + */ + + }, { + key: "resetFixedPosition", + value: function resetFixedPosition() { + this.updateTrimmingContainer(); + + if (!this.wot.wtTable.holder.parentNode) { + // removed from DOM + return; + } + + var overlayRoot = this.clone.wtTable.holder.parentNode; + var preventOverflow = this.wot.getSetting('preventOverflow'); + + if (this.trimmingContainer === this.wot.rootWindow) { + var wtTable = this.wot.wtTable; + var hiderRect = wtTable.hider.getBoundingClientRect(); + var top = Math.ceil(hiderRect.top); + var left = Math.ceil(hiderRect.left); + var bottom = Math.ceil(hiderRect.bottom); + var right = Math.ceil(hiderRect.right); + var finalLeft = '0'; + var finalTop = '0'; + + if (!preventOverflow || preventOverflow === 'vertical') { + if (left < 0 && right - overlayRoot.offsetWidth > 0) { + finalLeft = "".concat(-left, "px"); + } + } + + if (!preventOverflow || preventOverflow === 'horizontal') { + if (top < 0 && bottom - overlayRoot.offsetHeight > 0) { + finalTop = "".concat(-top, "px"); + } + } + + setOverlayPosition(overlayRoot, finalLeft, finalTop); + } else { + resetCssTransform(overlayRoot); + } + + var tableHeight = outerHeight(this.clone.wtTable.TABLE); + var tableWidth = outerWidth(this.clone.wtTable.TABLE); + + if (!this.wot.wtTable.hasDefinedSize()) { + tableHeight = 0; + } + + overlayRoot.style.height = "".concat(tableHeight, "px"); + overlayRoot.style.width = "".concat(tableWidth, "px"); + return false; + } + }], [{ + key: "OVERLAY_NAME", + get: function get() { + return CLONE_TOP_LEFT_CORNER; + } + }]); + + return TopLeftCornerOverlay; +}(Overlay); + +function _typeof$k(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$k = function _typeof(obj) { return typeof obj; }; } else { _typeof$k = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$k(obj); } + +function _classCallCheck$x(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits$f(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$f(subClass, superClass); } + +function _setPrototypeOf$f(o, p) { _setPrototypeOf$f = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$f(o, p); } + +function _createSuper$f(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$f(); return function _createSuperInternal() { var Super = _getPrototypeOf$f(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$f(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$f(this, result); }; } + +function _possibleConstructorReturn$f(self, call) { if (call && (_typeof$k(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$f(self); } + +function _assertThisInitialized$f(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$f() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$f(o) { _getPrototypeOf$f = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$f(o); } +/** + * Subclass of `Table` that provides the helper methods relevant to TopOverlay, implemented through mixins. + */ + +var TopOverlayTable = /*#__PURE__*/function (_Table) { + _inherits$f(TopOverlayTable, _Table); + + var _super = _createSuper$f(TopOverlayTable); + + function TopOverlayTable() { + _classCallCheck$x(this, TopOverlayTable); + + return _super.apply(this, arguments); + } + + return TopOverlayTable; +}(Table); + +mixin(TopOverlayTable, stickyRowsTop); +mixin(TopOverlayTable, calculatedColumns); + +function _typeof$l(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$l = function _typeof(obj) { return typeof obj; }; } else { _typeof$l = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$l(obj); } + +function _construct$4(Parent, args, Class) { if (_isNativeReflectConstruct$g()) { _construct$4 = Reflect.construct; } else { _construct$4 = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf$g(instance, Class.prototype); return instance; }; } return _construct$4.apply(null, arguments); } + +function _classCallCheck$y(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$t(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); } } + +function _createClass$t(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$t(Constructor.prototype, protoProps); if (staticProps) _defineProperties$t(Constructor, staticProps); return Constructor; } + +function _inherits$g(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$g(subClass, superClass); } + +function _setPrototypeOf$g(o, p) { _setPrototypeOf$g = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$g(o, p); } + +function _createSuper$g(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$g(); return function _createSuperInternal() { var Super = _getPrototypeOf$g(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$g(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$g(this, result); }; } + +function _possibleConstructorReturn$g(self, call) { if (call && (_typeof$l(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$g(self); } + +function _assertThisInitialized$g(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$g() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$g(o) { _getPrototypeOf$g = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$g(o); } + +function _defineProperty$2(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +/** + * @class TopOverlay + */ + +var TopOverlay = /*#__PURE__*/function (_Overlay) { + _inherits$g(TopOverlay, _Overlay); + + var _super = _createSuper$g(TopOverlay); + + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + function TopOverlay(wotInstance) { + var _this; + + _classCallCheck$y(this, TopOverlay); + + _this = _super.call(this, wotInstance); + + _defineProperty$2(_assertThisInitialized$g(_this), "cachedFixedRowsTop", -1); + + _this.clone = _this.makeClone(CLONE_TOP); + return _this; + } + /** + * Factory method to create a subclass of `Table` that is relevant to this overlay. + * + * @see Table#constructor + * @param {...*} args Parameters that will be forwarded to the `Table` constructor. + * @returns {Table} + */ + + + _createClass$t(TopOverlay, [{ + key: "createTable", + value: function createTable() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return _construct$4(TopOverlayTable, args); + } + /** + * Checks if overlay should be fully rendered. + * + * @returns {boolean} + */ + + }, { + key: "shouldBeRendered", + value: function shouldBeRendered() { + return this.wot.getSetting('shouldRenderTopOverlay'); + } + /** + * Updates the top overlay position. + * + * @returns {boolean} + */ + + }, { + key: "resetFixedPosition", + value: function resetFixedPosition() { + if (!this.needFullRender || !this.wot.wtTable.holder.parentNode) { + // removed from DOM + return; + } + + var overlayRoot = this.clone.wtTable.holder.parentNode; + var preventOverflow = this.wot.getSetting('preventOverflow'); + var headerPosition = 0; + var skipInnerBorderAdjusting = false; + + if (this.trimmingContainer === this.wot.rootWindow && (!preventOverflow || preventOverflow !== 'vertical')) { + var wtTable = this.wot.wtTable; + var hiderRect = wtTable.hider.getBoundingClientRect(); + var top = Math.ceil(hiderRect.top); + var bottom = Math.ceil(hiderRect.bottom); + var rootHeight = overlayRoot.offsetHeight; // This checks if the overlay is going to an infinite loop caused by added (or removed) + // `innerBorderTop` class name. Toggling the class name shifts the viewport by 1px and + // triggers the `scroll` event. It causes the table to render. The new render cycle takes into, + // account the shift and toggles the class name again. This causes the next loops. This + // happens only on Chrome (#7256). + // + // When we detect that the table bottom position is the same as the overlay bottom, + // do not toggle the class name. + // + // This workaround will be able to be cleared after merging the SVG borders, which introduces + // frozen lines (no more `innerBorderTop` workaround). + + skipInnerBorderAdjusting = bottom === rootHeight; + var finalLeft; + var finalTop; + finalLeft = wtTable.hider.style.left; + finalLeft = finalLeft === '' ? 0 : finalLeft; + + if (top < 0 && bottom - rootHeight > 0) { + finalTop = -top; + } else { + finalTop = 0; + } + + headerPosition = finalTop; + finalTop += 'px'; + setOverlayPosition(overlayRoot, finalLeft, finalTop); + } else { + headerPosition = this.getScrollPosition(); + resetCssTransform(overlayRoot); + } + + var positionChanged = this.adjustHeaderBordersPosition(headerPosition, skipInnerBorderAdjusting); + this.adjustElementsSize(); + return positionChanged; + } + /** + * Sets the main overlay's vertical scroll position. + * + * @param {number} pos The scroll position. + * @returns {boolean} + */ + + }, { + key: "setScrollPosition", + value: function setScrollPosition(pos) { + var rootWindow = this.wot.rootWindow; + var result = false; + + if (this.mainTableScrollableElement === rootWindow && rootWindow.scrollY !== pos) { + rootWindow.scrollTo(getWindowScrollLeft(rootWindow), pos); + result = true; + } else if (this.mainTableScrollableElement.scrollTop !== pos) { + this.mainTableScrollableElement.scrollTop = pos; + result = true; + } + + return result; + } + /** + * Triggers onScroll hook callback. + */ + + }, { + key: "onScroll", + value: function onScroll() { + this.wot.getSetting('onScrollHorizontally'); + } + /** + * Calculates total sum cells height. + * + * @param {number} from Row index which calculates started from. + * @param {number} to Row index where calculation is finished. + * @returns {number} Height sum. + */ + + }, { + key: "sumCellSizes", + value: function sumCellSizes(from, to) { + var defaultRowHeight = this.wot.wtSettings.settings.defaultRowHeight; + var row = from; + var sum = 0; + + while (row < to) { + var height = this.wot.wtTable.getRowHeight(row); + sum += height === void 0 ? defaultRowHeight : height; + row += 1; + } + + return sum; + } + /** + * Adjust overlay root element, childs and master table element sizes (width, height). + * + * @param {boolean} [force=false] When `true`, it adjusts the DOM nodes sizes for that overlay. + */ + + }, { + key: "adjustElementsSize", + value: function adjustElementsSize() { + var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + this.updateTrimmingContainer(); + + if (this.needFullRender || force) { + this.adjustRootElementSize(); + this.adjustRootChildrenSize(); + } + } + /** + * Adjust overlay root element size (width and height). + */ + + }, { + key: "adjustRootElementSize", + value: function adjustRootElementSize() { + var _this$wot = this.wot, + wtTable = _this$wot.wtTable, + rootDocument = _this$wot.rootDocument, + rootWindow = _this$wot.rootWindow; + var scrollbarWidth = getScrollbarWidth(rootDocument); + var overlayRoot = this.clone.wtTable.holder.parentNode; + var overlayRootStyle = overlayRoot.style; + var preventOverflow = this.wot.getSetting('preventOverflow'); + + if (this.trimmingContainer !== rootWindow || preventOverflow === 'horizontal') { + var width = this.wot.wtViewport.getWorkspaceWidth(); + + if (this.wot.wtOverlays.hasScrollbarRight) { + width -= scrollbarWidth; + } + + width = Math.min(width, wtTable.wtRootElement.scrollWidth); + overlayRootStyle.width = "".concat(width, "px"); + } else { + overlayRootStyle.width = ''; + } + + this.clone.wtTable.holder.style.width = overlayRootStyle.width; + var tableHeight = outerHeight(this.clone.wtTable.TABLE); + + if (!this.wot.wtTable.hasDefinedSize()) { + tableHeight = 0; + } + + overlayRootStyle.height = "".concat(tableHeight, "px"); + } + /** + * Adjust overlay root childs size. + */ + + }, { + key: "adjustRootChildrenSize", + value: function adjustRootChildrenSize() { + var _selections$getCell$g; + + var holder = this.clone.wtTable.holder; + var selections = this.wot.selections; + var selectionCornerOffset = Math.abs((_selections$getCell$g = selections === null || selections === void 0 ? void 0 : selections.getCell().getBorder(this.wot).cornerCenterPointOffset) !== null && _selections$getCell$g !== void 0 ? _selections$getCell$g : 0); + this.clone.wtTable.hider.style.width = this.hider.style.width; + holder.style.width = holder.parentNode.style.width; // Add selection corner protruding part to the holder total height to make sure that + // borders' corner won't be cut after vertical scroll (#6937). + + holder.style.height = "".concat(parseInt(holder.parentNode.style.height, 10) + selectionCornerOffset, "px"); + } + /** + * Adjust the overlay dimensions and position. + */ + + }, { + key: "applyToDOM", + value: function applyToDOM() { + var total = this.wot.getSetting('totalRows'); + + if (typeof this.wot.wtViewport.rowsRenderCalculator.startPosition === 'number') { + this.spreader.style.top = "".concat(this.wot.wtViewport.rowsRenderCalculator.startPosition, "px"); + } else if (total === 0) { + // can happen if there are 0 rows + this.spreader.style.top = '0'; + } else { + throw new Error('Incorrect value of the rowsRenderCalculator'); + } + + this.spreader.style.bottom = ''; + + if (this.needFullRender) { + this.syncOverlayOffset(); + } + } + /** + * Synchronize calculated left position to an element. + */ + + }, { + key: "syncOverlayOffset", + value: function syncOverlayOffset() { + if (typeof this.wot.wtViewport.columnsRenderCalculator.startPosition === 'number') { + this.clone.wtTable.spreader.style.left = "".concat(this.wot.wtViewport.columnsRenderCalculator.startPosition, "px"); + } else { + this.clone.wtTable.spreader.style.left = ''; + } + } + /** + * Scrolls vertically to a row. + * + * @param {number} sourceRow Row index which you want to scroll to. + * @param {boolean} [bottomEdge] If `true`, scrolls according to the bottom edge (top edge is by default). + * @returns {boolean} + */ + + }, { + key: "scrollTo", + value: function scrollTo(sourceRow, bottomEdge) { + var wot = this.wot; + var sourceInstance = wot.cloneSource ? wot.cloneSource : wot; + var mainHolder = sourceInstance.wtTable.holder; + var newY = this.getTableParentOffset(); + var scrollbarCompensation = 0; + + if (bottomEdge && mainHolder.offsetHeight !== mainHolder.clientHeight) { + scrollbarCompensation = getScrollbarWidth(wot.rootDocument); + } + + if (bottomEdge) { + var fixedRowsBottom = wot.getSetting('fixedRowsBottom'); + var totalRows = wot.getSetting('totalRows'); + newY += this.sumCellSizes(0, sourceRow + 1); + newY -= wot.wtViewport.getViewportHeight() - this.sumCellSizes(totalRows - fixedRowsBottom, totalRows); // Fix 1 pixel offset when cell is selected + + newY += 1; + } else { + newY += this.sumCellSizes(wot.getSetting('fixedRowsTop'), sourceRow); + } + + newY += scrollbarCompensation; + return this.setScrollPosition(newY); + } + /** + * Gets table parent top position. + * + * @returns {number} + */ + + }, { + key: "getTableParentOffset", + value: function getTableParentOffset() { + if (this.mainTableScrollableElement === this.wot.rootWindow) { + return this.wot.wtTable.holderOffset.top; + } + + return 0; + } + /** + * Gets the main overlay's vertical scroll position. + * + * @returns {number} Main table's vertical scroll position. + */ + + }, { + key: "getScrollPosition", + value: function getScrollPosition() { + return getScrollTop(this.mainTableScrollableElement, this.wot.rootWindow); + } + /** + * Adds css classes to hide the header border's header (cell-selection border hiding issue). + * + * @param {number} position Header Y position if trimming container is window or scroll top if not. + * @param {boolean} [skipInnerBorderAdjusting=false] If `true` the inner border adjusting will be skipped. + * @returns {boolean} + */ + + }, { + key: "adjustHeaderBordersPosition", + value: function adjustHeaderBordersPosition(position) { + var skipInnerBorderAdjusting = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var masterParent = this.wot.wtTable.holder.parentNode; + var totalColumns = this.wot.getSetting('totalColumns'); + + if (totalColumns) { + removeClass(masterParent, 'emptyColumns'); + } else { + addClass(masterParent, 'emptyColumns'); + } + + var positionChanged = false; + + if (!skipInnerBorderAdjusting) { + var fixedRowsTop = this.wot.getSetting('fixedRowsTop'); + var areFixedRowsTopChanged = this.cachedFixedRowsTop !== fixedRowsTop; + var columnHeaders = this.wot.getSetting('columnHeaders'); + + if ((areFixedRowsTopChanged || fixedRowsTop === 0) && columnHeaders.length > 0) { + var previousState = hasClass(masterParent, 'innerBorderTop'); + this.cachedFixedRowsTop = this.wot.getSetting('fixedRowsTop'); + + if (position || this.wot.getSetting('totalRows') === 0) { + addClass(masterParent, 'innerBorderTop'); + positionChanged = !previousState; + } else { + removeClass(masterParent, 'innerBorderTop'); + positionChanged = previousState; + } + } + } // nasty workaround for double border in the header, TODO: find a pure-css solution + + + if (this.wot.getSetting('rowHeaders').length === 0) { + var secondHeaderCell = this.clone.wtTable.THEAD.querySelectorAll('th:nth-of-type(2)'); + + if (secondHeaderCell) { + for (var i = 0; i < secondHeaderCell.length; i++) { + secondHeaderCell[i].style['border-left-width'] = 0; + } + } + } + + return positionChanged; + } + }], [{ + key: "OVERLAY_NAME", + get: function get() { + return CLONE_TOP; + } + /** + * Cached value which holds the previous value of the `fixedRowsTop` option. + * It is used as a comparison value that can be used to detect changes in this value. + * + * @type {number} + */ + + }]); + + return TopOverlay; +}(Overlay); + +function _slicedToArray$1(arr, i) { return _arrayWithHoles$1(arr) || _iterableToArrayLimit$1(arr, i) || _unsupportedIterableToArray$2(arr, i) || _nonIterableRest$1(); } + +function _nonIterableRest$1() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$2(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$2(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$2(o, minLen); } + +function _arrayLikeToArray$2(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$1(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$1(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$z(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$u(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); } } + +function _createClass$u(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$u(Constructor.prototype, protoProps); if (staticProps) _defineProperties$u(Constructor, staticProps); return Constructor; } +/** + * + */ + +var Border = /*#__PURE__*/function () { + /** + * @param {Walkontable} wotInstance The Walkontable instance. + * @param {object} settings The border settings. + */ + function Border(wotInstance, settings) { + _classCallCheck$z(this, Border); + + if (!settings) { + return; + } + + this.eventManager = new EventManager(wotInstance); + this.instance = wotInstance; + this.wot = wotInstance; + this.settings = settings; + this.mouseDown = false; + this.main = null; + this.top = null; + this.left = null; + this.bottom = null; + this.right = null; + this.topStyle = null; + this.leftStyle = null; + this.bottomStyle = null; + this.rightStyle = null; + this.cornerDefaultStyle = { + width: '6px', + height: '6px', + borderWidth: '1px', + borderStyle: 'solid', + borderColor: '#FFF' + }; // Offset to moving the corner to be centered relative to the grid. + + this.cornerCenterPointOffset = -(parseInt(this.cornerDefaultStyle.width, 10) / 2); + this.corner = null; + this.cornerStyle = null; + this.createBorders(settings); + this.registerListeners(); + } + /** + * Register all necessary events. + */ + + + _createClass$u(Border, [{ + key: "registerListeners", + value: function registerListeners() { + var _this2 = this; + + var documentBody = this.wot.rootDocument.body; + this.eventManager.addEventListener(documentBody, 'mousedown', function () { + return _this2.onMouseDown(); + }); + this.eventManager.addEventListener(documentBody, 'mouseup', function () { + return _this2.onMouseUp(); + }); + + var _loop = function _loop(c, len) { + var element = _this2.main.childNodes[c]; + + _this2.eventManager.addEventListener(element, 'mouseenter', function (event) { + return _this2.onMouseEnter(event, _this2.main.childNodes[c]); + }); + }; + + for (var c = 0, len = this.main.childNodes.length; c < len; c++) { + _loop(c); + } + } + /** + * Mouse down listener. + * + * @private + */ + + }, { + key: "onMouseDown", + value: function onMouseDown() { + this.mouseDown = true; + } + /** + * Mouse up listener. + * + * @private + */ + + }, { + key: "onMouseUp", + value: function onMouseUp() { + this.mouseDown = false; + } + /** + * Mouse enter listener for fragment selection functionality. + * + * @private + * @param {Event} event Dom event. + * @param {HTMLElement} parentElement Part of border element. + */ + + }, { + key: "onMouseEnter", + value: function onMouseEnter(event, parentElement) { + if (!this.mouseDown || !this.wot.getSetting('hideBorderOnMouseDownOver')) { + return; + } + + event.preventDefault(); + stopImmediatePropagation(event); + + var _this = this; + + var documentBody = this.wot.rootDocument.body; + var bounds = parentElement.getBoundingClientRect(); // Hide border to prevents selection jumping when fragmentSelection is enabled. + + parentElement.style.display = 'none'; + /** + * @param {Event} mouseEvent The mouse event object. + * @returns {boolean} + */ + + function isOutside(mouseEvent) { + if (mouseEvent.clientY < Math.floor(bounds.top)) { + return true; + } + + if (mouseEvent.clientY > Math.ceil(bounds.top + bounds.height)) { + return true; + } + + if (mouseEvent.clientX < Math.floor(bounds.left)) { + return true; + } + + if (mouseEvent.clientX > Math.ceil(bounds.left + bounds.width)) { + return true; + } + } + /** + * @param {Event} handlerEvent The mouse event object. + */ + + + function handler(handlerEvent) { + if (isOutside(handlerEvent)) { + _this.eventManager.removeEventListener(documentBody, 'mousemove', handler); + + parentElement.style.display = 'block'; + } + } + + this.eventManager.addEventListener(documentBody, 'mousemove', handler); + } + /** + * Create border elements. + * + * @param {object} settings The border settings. + */ + + }, { + key: "createBorders", + value: function createBorders(settings) { + var rootDocument = this.wot.rootDocument; + this.main = rootDocument.createElement('div'); + var borderDivs = ['top', 'left', 'bottom', 'right', 'corner']; + var style = this.main.style; + style.position = 'absolute'; + style.top = 0; + style.left = 0; + + for (var i = 0; i < 5; i++) { + var position = borderDivs[i]; + var div = rootDocument.createElement('div'); + div.className = "wtBorder ".concat(this.settings.className || ''); // + borderDivs[i]; + + if (this.settings[position] && this.settings[position].hide) { + div.className += ' hidden'; + } + + style = div.style; + style.backgroundColor = this.settings[position] && this.settings[position].color ? this.settings[position].color : settings.border.color; + style.height = this.settings[position] && this.settings[position].width ? "".concat(this.settings[position].width, "px") : "".concat(settings.border.width, "px"); + style.width = this.settings[position] && this.settings[position].width ? "".concat(this.settings[position].width, "px") : "".concat(settings.border.width, "px"); + this.main.appendChild(div); + } + + this.top = this.main.childNodes[0]; + this.left = this.main.childNodes[1]; + this.bottom = this.main.childNodes[2]; + this.right = this.main.childNodes[3]; + this.topStyle = this.top.style; + this.leftStyle = this.left.style; + this.bottomStyle = this.bottom.style; + this.rightStyle = this.right.style; + this.corner = this.main.childNodes[4]; + this.corner.className += ' corner'; + this.cornerStyle = this.corner.style; + this.cornerStyle.width = this.cornerDefaultStyle.width; + this.cornerStyle.height = this.cornerDefaultStyle.height; + this.cornerStyle.border = [this.cornerDefaultStyle.borderWidth, this.cornerDefaultStyle.borderStyle, this.cornerDefaultStyle.borderColor].join(' '); + + if (isMobileBrowser()) { + this.createMultipleSelectorHandles(); + } + + this.disappear(); + var wtTable = this.wot.wtTable; + var bordersHolder = wtTable.bordersHolder; + + if (!bordersHolder) { + bordersHolder = rootDocument.createElement('div'); + bordersHolder.className = 'htBorders'; + wtTable.bordersHolder = bordersHolder; + wtTable.spreader.appendChild(bordersHolder); + } + + bordersHolder.appendChild(this.main); + } + /** + * Create multiple selector handler for mobile devices. + */ + + }, { + key: "createMultipleSelectorHandles", + value: function createMultipleSelectorHandles() { + var _this3 = this; + + var rootDocument = this.wot.rootDocument; + this.selectionHandles = { + topLeft: rootDocument.createElement('DIV'), + topLeftHitArea: rootDocument.createElement('DIV'), + bottomRight: rootDocument.createElement('DIV'), + bottomRightHitArea: rootDocument.createElement('DIV') + }; + var width = 10; + var hitAreaWidth = 40; + this.selectionHandles.topLeft.className = 'topLeftSelectionHandle'; + this.selectionHandles.topLeftHitArea.className = 'topLeftSelectionHandle-HitArea'; + this.selectionHandles.bottomRight.className = 'bottomRightSelectionHandle'; + this.selectionHandles.bottomRightHitArea.className = 'bottomRightSelectionHandle-HitArea'; + this.selectionHandles.styles = { + topLeft: this.selectionHandles.topLeft.style, + topLeftHitArea: this.selectionHandles.topLeftHitArea.style, + bottomRight: this.selectionHandles.bottomRight.style, + bottomRightHitArea: this.selectionHandles.bottomRightHitArea.style + }; + var hitAreaStyle = { + position: 'absolute', + height: "".concat(hitAreaWidth, "px"), + width: "".concat(hitAreaWidth, "px"), + 'border-radius': "".concat(parseInt(hitAreaWidth / 1.5, 10), "px") + }; + objectEach(hitAreaStyle, function (value, key) { + _this3.selectionHandles.styles.bottomRightHitArea[key] = value; + _this3.selectionHandles.styles.topLeftHitArea[key] = value; + }); + var handleStyle = { + position: 'absolute', + height: "".concat(width, "px"), + width: "".concat(width, "px"), + 'border-radius': "".concat(parseInt(width / 1.5, 10), "px"), + background: '#F5F5FF', + border: '1px solid #4285c8' + }; + objectEach(handleStyle, function (value, key) { + _this3.selectionHandles.styles.bottomRight[key] = value; + _this3.selectionHandles.styles.topLeft[key] = value; + }); + this.main.appendChild(this.selectionHandles.topLeft); + this.main.appendChild(this.selectionHandles.bottomRight); + this.main.appendChild(this.selectionHandles.topLeftHitArea); + this.main.appendChild(this.selectionHandles.bottomRightHitArea); + } + /** + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @returns {boolean} + */ + + }, { + key: "isPartRange", + value: function isPartRange(row, col) { + var areaSelection = this.wot.selections.createOrGetArea(); + + if (areaSelection.cellRange) { + if (row !== areaSelection.cellRange.to.row || col !== areaSelection.cellRange.to.col) { + return true; + } + } + + return false; + } + /** + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number} top The top position of the handler. + * @param {number} left The left position of the handler. + * @param {number} width The width of the handler. + * @param {number} height The height of the handler. + */ + + }, { + key: "updateMultipleSelectionHandlesPosition", + value: function updateMultipleSelectionHandlesPosition(row, col, top, left, width, height) { + var handleWidth = parseInt(this.selectionHandles.styles.topLeft.width, 10); + var hitAreaWidth = parseInt(this.selectionHandles.styles.topLeftHitArea.width, 10); + this.selectionHandles.styles.topLeft.top = "".concat(parseInt(top - handleWidth, 10), "px"); + this.selectionHandles.styles.topLeft.left = "".concat(parseInt(left - handleWidth, 10), "px"); + this.selectionHandles.styles.topLeftHitArea.top = "".concat(parseInt(top - hitAreaWidth / 4 * 3, 10), "px"); + this.selectionHandles.styles.topLeftHitArea.left = "".concat(parseInt(left - hitAreaWidth / 4 * 3, 10), "px"); + this.selectionHandles.styles.bottomRight.top = "".concat(parseInt(top + height, 10), "px"); + this.selectionHandles.styles.bottomRight.left = "".concat(parseInt(left + width, 10), "px"); + this.selectionHandles.styles.bottomRightHitArea.top = "".concat(parseInt(top + height - hitAreaWidth / 4, 10), "px"); + this.selectionHandles.styles.bottomRightHitArea.left = "".concat(parseInt(left + width - hitAreaWidth / 4, 10), "px"); + + if (this.settings.border.cornerVisible && this.settings.border.cornerVisible()) { + this.selectionHandles.styles.topLeft.display = 'block'; + this.selectionHandles.styles.topLeftHitArea.display = 'block'; + + if (this.isPartRange(row, col)) { + this.selectionHandles.styles.bottomRight.display = 'none'; + this.selectionHandles.styles.bottomRightHitArea.display = 'none'; + } else { + this.selectionHandles.styles.bottomRight.display = 'block'; + this.selectionHandles.styles.bottomRightHitArea.display = 'block'; + } + } else { + this.selectionHandles.styles.topLeft.display = 'none'; + this.selectionHandles.styles.bottomRight.display = 'none'; + this.selectionHandles.styles.topLeftHitArea.display = 'none'; + this.selectionHandles.styles.bottomRightHitArea.display = 'none'; + } + + if (row === this.wot.wtSettings.getSetting('fixedRowsTop') || col === this.wot.wtSettings.getSetting('fixedColumnsLeft')) { + this.selectionHandles.styles.topLeft.zIndex = '9999'; + this.selectionHandles.styles.topLeftHitArea.zIndex = '9999'; + } else { + this.selectionHandles.styles.topLeft.zIndex = ''; + this.selectionHandles.styles.topLeftHitArea.zIndex = ''; + } + } + /** + * Show border around one or many cells. + * + * @param {Array} corners The corner coordinates. + */ + + }, { + key: "appear", + value: function appear(corners) { + if (this.disabled) { + return; + } + + var _this$wot = this.wot, + wtTable = _this$wot.wtTable, + rootDocument = _this$wot.rootDocument, + rootWindow = _this$wot.rootWindow; + var fromRow; + var toRow; + var fromColumn; + var toColumn; + var rowsCount = wtTable.getRenderedRowsCount(); + + for (var i = 0; i < rowsCount; i += 1) { + var s = wtTable.rowFilter.renderedToSource(i); + + if (s >= corners[0] && s <= corners[2]) { + fromRow = s; + break; + } + } + + for (var _i = rowsCount - 1; _i >= 0; _i -= 1) { + var _s = wtTable.rowFilter.renderedToSource(_i); + + if (_s >= corners[0] && _s <= corners[2]) { + toRow = _s; + break; + } + } + + var columnsCount = wtTable.getRenderedColumnsCount(); + + for (var _i2 = 0; _i2 < columnsCount; _i2 += 1) { + var _s2 = wtTable.columnFilter.renderedToSource(_i2); + + if (_s2 >= corners[1] && _s2 <= corners[3]) { + fromColumn = _s2; + break; + } + } + + for (var _i3 = columnsCount - 1; _i3 >= 0; _i3 -= 1) { + var _s3 = wtTable.columnFilter.renderedToSource(_i3); + + if (_s3 >= corners[1] && _s3 <= corners[3]) { + toColumn = _s3; + break; + } + } + + if (fromRow === void 0 || fromColumn === void 0) { + this.disappear(); + return; + } + + var fromTD = wtTable.getCell(new CellCoords(fromRow, fromColumn)); + var isMultiple = fromRow !== toRow || fromColumn !== toColumn; + var toTD = isMultiple ? wtTable.getCell(new CellCoords(toRow, toColumn)) : fromTD; + var fromOffset = offset(fromTD); + var toOffset = isMultiple ? offset(toTD) : fromOffset; + var containerOffset = offset(wtTable.TABLE); + var minTop = fromOffset.top; + var minLeft = fromOffset.left; + var left = minLeft - containerOffset.left - 1; + var width = toOffset.left + outerWidth(toTD) - minLeft; + + if (this.isEntireColumnSelected(fromRow, toRow)) { + var modifiedValues = this.getDimensionsFromHeader('columns', fromColumn, toColumn, containerOffset); + var fromTH = null; + + if (modifiedValues) { + var _modifiedValues = _slicedToArray$1(modifiedValues, 3); + + fromTH = _modifiedValues[0]; + left = _modifiedValues[1]; + width = _modifiedValues[2]; + } + + if (fromTH) { + fromTD = fromTH; + } + } + + var top = minTop - containerOffset.top - 1; + var height = toOffset.top + outerHeight(toTD) - minTop; + + if (this.isEntireRowSelected(fromColumn, toColumn)) { + var _modifiedValues2 = this.getDimensionsFromHeader('rows', fromRow, toRow, containerOffset); + + var _fromTH = null; + + if (_modifiedValues2) { + var _modifiedValues3 = _slicedToArray$1(_modifiedValues2, 3); + + _fromTH = _modifiedValues3[0]; + top = _modifiedValues3[1]; + height = _modifiedValues3[2]; + } + + if (_fromTH) { + fromTD = _fromTH; + } + } + + var style = getComputedStyle(fromTD, rootWindow); + + if (parseInt(style.borderTopWidth, 10) > 0) { + top += 1; + height = height > 0 ? height - 1 : 0; + } + + if (parseInt(style.borderLeftWidth, 10) > 0) { + left += 1; + width = width > 0 ? width - 1 : 0; + } + + this.topStyle.top = "".concat(top, "px"); + this.topStyle.left = "".concat(left, "px"); + this.topStyle.width = "".concat(width, "px"); + this.topStyle.display = 'block'; + this.leftStyle.top = "".concat(top, "px"); + this.leftStyle.left = "".concat(left, "px"); + this.leftStyle.height = "".concat(height, "px"); + this.leftStyle.display = 'block'; + var delta = Math.floor(this.settings.border.width / 2); + this.bottomStyle.top = "".concat(top + height - delta, "px"); + this.bottomStyle.left = "".concat(left, "px"); + this.bottomStyle.width = "".concat(width, "px"); + this.bottomStyle.display = 'block'; + this.rightStyle.top = "".concat(top, "px"); + this.rightStyle.left = "".concat(left + width - delta, "px"); + this.rightStyle.height = "".concat(height + 1, "px"); + this.rightStyle.display = 'block'; + var cornerVisibleSetting = this.settings.border.cornerVisible; + cornerVisibleSetting = typeof cornerVisibleSetting === 'function' ? cornerVisibleSetting(this.settings.layerLevel) : cornerVisibleSetting; + var hookResult = this.wot.getSetting('onModifyGetCellCoords', toRow, toColumn); + var checkRow = toRow, + checkCol = toColumn; + + if (hookResult && Array.isArray(hookResult)) { + var _hookResult = _slicedToArray$1(hookResult, 4); + + checkRow = _hookResult[2]; + checkCol = _hookResult[3]; + } + + if (isMobileBrowser() || !cornerVisibleSetting || this.isPartRange(checkRow, checkCol)) { + this.cornerStyle.display = 'none'; + } else { + this.cornerStyle.top = "".concat(top + height + this.cornerCenterPointOffset - 1, "px"); + this.cornerStyle.left = "".concat(left + width + this.cornerCenterPointOffset - 1, "px"); + this.cornerStyle.borderRightWidth = this.cornerDefaultStyle.borderWidth; + this.cornerStyle.width = this.cornerDefaultStyle.width; // Hide the fill handle, so the possible further adjustments won't force unneeded scrollbars. + + this.cornerStyle.display = 'none'; + var trimmingContainer = getTrimmingContainer(wtTable.TABLE); + var trimToWindow = trimmingContainer === rootWindow; + + if (trimToWindow) { + trimmingContainer = rootDocument.documentElement; + } + + if (toColumn === this.wot.getSetting('totalColumns') - 1) { + var toTdOffsetLeft = trimToWindow ? toTD.getBoundingClientRect().left : toTD.offsetLeft; + var cornerRightEdge = toTdOffsetLeft + outerWidth(toTD) + parseInt(this.cornerDefaultStyle.width, 10) / 2; + var cornerOverlappingContainer = cornerRightEdge >= innerWidth(trimmingContainer); + + if (cornerOverlappingContainer) { + this.cornerStyle.left = "".concat(Math.floor(left + width + this.cornerCenterPointOffset - parseInt(this.cornerDefaultStyle.width, 10) / 2), "px"); // eslint-disable-line max-len + + this.cornerStyle.borderRightWidth = 0; + } + } + + if (toRow === this.wot.getSetting('totalRows') - 1) { + var toTdOffsetTop = trimToWindow ? toTD.getBoundingClientRect().top : toTD.offsetTop; + var cornerBottomEdge = toTdOffsetTop + outerHeight(toTD) + parseInt(this.cornerDefaultStyle.height, 10) / 2; + + var _cornerOverlappingContainer = cornerBottomEdge >= innerHeight(trimmingContainer); + + if (_cornerOverlappingContainer) { + this.cornerStyle.top = "".concat(Math.floor(top + height + this.cornerCenterPointOffset - parseInt(this.cornerDefaultStyle.height, 10) / 2), "px"); // eslint-disable-line max-len + + this.cornerStyle.borderBottomWidth = 0; + } + } + + this.cornerStyle.display = 'block'; + } + + if (isMobileBrowser()) { + this.updateMultipleSelectionHandlesPosition(toRow, toColumn, top, left, width, height); + } + } + /** + * Check whether an entire column of cells is selected. + * + * @private + * @param {number} startRowIndex Start row index. + * @param {number} endRowIndex End row index. + * @returns {boolean} + */ + + }, { + key: "isEntireColumnSelected", + value: function isEntireColumnSelected(startRowIndex, endRowIndex) { + return startRowIndex === this.wot.wtTable.getFirstRenderedRow() && endRowIndex === this.wot.wtTable.getLastRenderedRow(); + } + /** + * Check whether an entire row of cells is selected. + * + * @private + * @param {number} startColumnIndex Start column index. + * @param {number} endColumnIndex End column index. + * @returns {boolean} + */ + + }, { + key: "isEntireRowSelected", + value: function isEntireRowSelected(startColumnIndex, endColumnIndex) { + return startColumnIndex === this.wot.wtTable.getFirstRenderedColumn() && endColumnIndex === this.wot.wtTable.getLastRenderedColumn(); + } + /** + * Get left/top index and width/height depending on the `direction` provided. + * + * @private + * @param {string} direction `rows` or `columns`, defines if an entire column or row is selected. + * @param {number} fromIndex Start index of the selection. + * @param {number} toIndex End index of the selection. + * @param {number} containerOffset Offset of the container. + * @returns {Array|boolean} Returns an array of [headerElement, left, width] or [headerElement, top, height], depending on `direction` (`false` in case of an error getting the headers). + */ + + }, { + key: "getDimensionsFromHeader", + value: function getDimensionsFromHeader(direction, fromIndex, toIndex, containerOffset) { + var wtTable = this.wot.wtTable; + var rootHotElement = wtTable.wtRootElement.parentNode; + var getHeaderFn = null; + var dimensionFn = null; + var entireSelectionClassname = null; + var index = null; + var dimension = null; + var dimensionProperty = null; + var startHeader = null; + var endHeader = null; + + switch (direction) { + case 'rows': + getHeaderFn = function getHeaderFn() { + return wtTable.getRowHeader.apply(wtTable, arguments); + }; + + dimensionFn = function dimensionFn() { + return outerHeight.apply(void 0, arguments); + }; + + entireSelectionClassname = 'ht__selection--rows'; + dimensionProperty = 'top'; + break; + + case 'columns': + getHeaderFn = function getHeaderFn() { + return wtTable.getColumnHeader.apply(wtTable, arguments); + }; + + dimensionFn = function dimensionFn() { + return outerWidth.apply(void 0, arguments); + }; + + entireSelectionClassname = 'ht__selection--columns'; + dimensionProperty = 'left'; + break; + } + + if (rootHotElement.className.includes(entireSelectionClassname)) { + var columnHeaderLevelCount = this.wot.getSetting('columnHeaders').length; + startHeader = getHeaderFn(fromIndex, columnHeaderLevelCount - 1); + endHeader = getHeaderFn(toIndex, columnHeaderLevelCount - 1); + + if (!startHeader || !endHeader) { + return false; + } + + var startHeaderOffset = offset(startHeader); + var endOffset = offset(endHeader); + + if (startHeader && endHeader) { + index = startHeaderOffset[dimensionProperty] - containerOffset[dimensionProperty] - 1; + dimension = endOffset[dimensionProperty] + dimensionFn(endHeader) - startHeaderOffset[dimensionProperty]; + } + + return [startHeader, index, dimension]; + } + + return false; + } + /** + * Change border style. + * + * @private + * @param {string} borderElement Coordinate where add/remove border: top, right, bottom, left. + * @param {object} border The border object descriptor. + */ + + }, { + key: "changeBorderStyle", + value: function changeBorderStyle(borderElement, border) { + var style = this[borderElement].style; + var borderStyle = border[borderElement]; + + if (!borderStyle || borderStyle.hide) { + addClass(this[borderElement], 'hidden'); + } else { + if (hasClass(this[borderElement], 'hidden')) { + removeClass(this[borderElement], 'hidden'); + } + + style.backgroundColor = borderStyle.color; + + if (borderElement === 'top' || borderElement === 'bottom') { + style.height = "".concat(borderStyle.width, "px"); + } + + if (borderElement === 'right' || borderElement === 'left') { + style.width = "".concat(borderStyle.width, "px"); + } + } + } + /** + * Change border style to default. + * + * @private + * @param {string} position The position type ("top", "bottom", "left", "right") to change. + */ + + }, { + key: "changeBorderToDefaultStyle", + value: function changeBorderToDefaultStyle(position) { + var defaultBorder = { + width: 1, + color: '#000' + }; + var style = this[position].style; + style.backgroundColor = defaultBorder.color; + style.width = "".concat(defaultBorder.width, "px"); + style.height = "".concat(defaultBorder.width, "px"); + } + /** + * Toggle class 'hidden' to element. + * + * @private + * @param {string} borderElement Coordinate where add/remove border: top, right, bottom, left. + * @param {boolean} [remove] Defines type of the action to perform. + */ + + }, { + key: "toggleHiddenClass", + value: function toggleHiddenClass(borderElement, remove) { + this.changeBorderToDefaultStyle(borderElement); + + if (remove) { + addClass(this[borderElement], 'hidden'); + } else { + removeClass(this[borderElement], 'hidden'); + } + } + /** + * Hide border. + */ + + }, { + key: "disappear", + value: function disappear() { + this.topStyle.display = 'none'; + this.leftStyle.display = 'none'; + this.bottomStyle.display = 'none'; + this.rightStyle.display = 'none'; + this.cornerStyle.display = 'none'; + + if (isMobileBrowser()) { + this.selectionHandles.styles.topLeft.display = 'none'; + this.selectionHandles.styles.bottomRight.display = 'none'; + } + } + /** + * Cleans up all the DOM state related to a Border instance. Call this prior to deleting a Border instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.eventManager.destroyWithOwnEventsOnly(); + this.main.parentNode.removeChild(this.main); + } + }]); + + return Border; +}(); + +function _classCallCheck$A(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$v(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); } } + +function _createClass$v(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$v(Constructor.prototype, protoProps); if (staticProps) _defineProperties$v(Constructor, staticProps); return Constructor; } +var privatePool$2 = new WeakMap(); +/** + * @class Event + */ + +var Event$1 = /*#__PURE__*/function () { + /** + * @param {*} instance Walkontable instance. + */ + function Event(instance) { + _classCallCheck$A(this, Event); + + /** + * Instance of {@link Walkontable}. + * + * @private + * @type {Walkontable} + */ + this.instance = instance; + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + this.eventManager = new EventManager(instance); + privatePool$2.set(this, { + selectedCellBeforeTouchEnd: void 0, + dblClickTimeout: [null, null], + dblClickOrigin: [null, null] + }); + this.registerEvents(); + } + /** + * Adds listeners for mouse and touch events. + * + * @private + */ + + + _createClass$v(Event, [{ + key: "registerEvents", + value: function registerEvents() { + var _this = this; + + this.eventManager.addEventListener(this.instance.wtTable.holder, 'contextmenu', function (event) { + return _this.onContextMenu(event); + }); + this.eventManager.addEventListener(this.instance.wtTable.TABLE, 'mouseover', function (event) { + return _this.onMouseOver(event); + }); + this.eventManager.addEventListener(this.instance.wtTable.TABLE, 'mouseout', function (event) { + return _this.onMouseOut(event); + }); + + var initTouchEvents = function initTouchEvents() { + _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'touchstart', function (event) { + return _this.onTouchStart(event); + }); + + _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'touchend', function (event) { + return _this.onTouchEnd(event); + }); + + if (!_this.instance.momentumScrolling) { + _this.instance.momentumScrolling = {}; + } + + _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'scroll', function () { + clearTimeout(_this.instance.momentumScrolling._timeout); + + if (!_this.instance.momentumScrolling.ongoing) { + _this.instance.getSetting('onBeforeTouchScroll'); + } + + _this.instance.momentumScrolling.ongoing = true; + _this.instance.momentumScrolling._timeout = setTimeout(function () { + if (!_this.instance.touchApplied) { + _this.instance.momentumScrolling.ongoing = false; + + _this.instance.getSetting('onAfterMomentumScroll'); + } + }, 200); + }); + }; + + var initMouseEvents = function initMouseEvents() { + _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'mouseup', function (event) { + return _this.onMouseUp(event); + }); + + _this.eventManager.addEventListener(_this.instance.wtTable.holder, 'mousedown', function (event) { + return _this.onMouseDown(event); + }); + }; + + if (isMobileBrowser()) { + initTouchEvents(); + } else { + // PC like devices which support both methods (touchscreen and ability to plug-in mouse). + if (isTouchSupported()) { + initTouchEvents(); + } + + initMouseEvents(); + } + } + /** + * Checks if an element is already selected. + * + * @private + * @param {Element} touchTarget An element to check. + * @returns {boolean} + */ + + }, { + key: "selectedCellWasTouched", + value: function selectedCellWasTouched(touchTarget) { + var priv = privatePool$2.get(this); + var cellUnderFinger = this.parentCell(touchTarget); + var coordsOfCellUnderFinger = cellUnderFinger.coords; + + if (priv.selectedCellBeforeTouchEnd && coordsOfCellUnderFinger) { + var _ref = [coordsOfCellUnderFinger.row, priv.selectedCellBeforeTouchEnd.from.row], + rowTouched = _ref[0], + rowSelected = _ref[1]; + var _ref2 = [coordsOfCellUnderFinger.col, priv.selectedCellBeforeTouchEnd.from.col], + colTouched = _ref2[0], + colSelected = _ref2[1]; + return rowTouched === rowSelected && colTouched === colSelected; + } + + return false; + } + /** + * Gets closest TD or TH element. + * + * @private + * @param {Element} elem An element from the traversing starts. + * @returns {object} Contains coordinates and reference to TD or TH if it exists. Otherwise it's empty object. + */ + + }, { + key: "parentCell", + value: function parentCell(elem) { + var cell = {}; + var TABLE = this.instance.wtTable.TABLE; + var TD = closestDown(elem, ['TD', 'TH'], TABLE); + + if (TD) { + cell.coords = this.instance.wtTable.getCoords(TD); + cell.TD = TD; + } else if (hasClass(elem, 'wtBorder') && hasClass(elem, 'current')) { + cell.coords = this.instance.selections.getCell().cellRange.highlight; + cell.TD = this.instance.wtTable.getCell(cell.coords); + } else if (hasClass(elem, 'wtBorder') && hasClass(elem, 'area')) { + if (this.instance.selections.createOrGetArea().cellRange) { + cell.coords = this.instance.selections.createOrGetArea().cellRange.to; + cell.TD = this.instance.wtTable.getCell(cell.coords); + } + } + + return cell; + } + /** + * OnMouseDown callback. + * + * @private + * @param {MouseEvent} event The mouse event object. + */ + + }, { + key: "onMouseDown", + value: function onMouseDown(event) { + var priv = privatePool$2.get(this); + var activeElement = this.instance.rootDocument.activeElement; + var getParentNode = partial(getParent, event.target); + var realTarget = event.target; // ignore focusable element from mouse down processing (https://github.com/handsontable/handsontable/issues/3555) + + if (realTarget === activeElement || getParentNode(0) === activeElement || getParentNode(1) === activeElement) { + return; + } + + var cell = this.parentCell(realTarget); + + if (hasClass(realTarget, 'corner')) { + this.instance.getSetting('onCellCornerMouseDown', event, realTarget); + } else if (cell.TD && this.instance.hasSetting('onCellMouseDown')) { + this.instance.getSetting('onCellMouseDown', event, cell.coords, cell.TD, this.instance); + } // doubleclick reacts only for left mouse button or from touch events + + + if ((event.button === 0 || this.instance.touchApplied) && cell.TD) { + priv.dblClickOrigin[0] = cell.TD; + clearTimeout(priv.dblClickTimeout[0]); + priv.dblClickTimeout[0] = setTimeout(function () { + priv.dblClickOrigin[0] = null; + }, 1000); + } + } + /** + * OnContextMenu callback. + * + * @private + * @param {MouseEvent} event The mouse event object. + */ + + }, { + key: "onContextMenu", + value: function onContextMenu(event) { + if (this.instance.hasSetting('onCellContextMenu')) { + var cell = this.parentCell(event.target); + + if (cell.TD) { + this.instance.getSetting('onCellContextMenu', event, cell.coords, cell.TD, this.instance); + } + } + } + /** + * OnMouseOver callback. + * + * @private + * @param {MouseEvent} event The mouse event object. + */ + + }, { + key: "onMouseOver", + value: function onMouseOver(event) { + if (!this.instance.hasSetting('onCellMouseOver')) { + return; + } + + var table = this.instance.wtTable.TABLE; + var td = closestDown(event.target, ['TD', 'TH'], table); + var mainWOT = this.instance.cloneSource || this.instance; + + if (td && td !== mainWOT.lastMouseOver && isChildOf(td, table)) { + mainWOT.lastMouseOver = td; + this.instance.getSetting('onCellMouseOver', event, this.instance.wtTable.getCoords(td), td, this.instance); + } + } + /** + * OnMouseOut callback. + * + * @private + * @param {MouseEvent} event The mouse event object. + */ + + }, { + key: "onMouseOut", + value: function onMouseOut(event) { + if (!this.instance.hasSetting('onCellMouseOut')) { + return; + } + + var table = this.instance.wtTable.TABLE; + var lastTD = closestDown(event.target, ['TD', 'TH'], table); + var nextTD = closestDown(event.relatedTarget, ['TD', 'TH'], table); + + if (lastTD && lastTD !== nextTD && isChildOf(lastTD, table)) { + this.instance.getSetting('onCellMouseOut', event, this.instance.wtTable.getCoords(lastTD), lastTD, this.instance); + } + } + /** + * OnMouseUp callback. + * + * @private + * @param {MouseEvent} event The mouse event object. + */ + + }, { + key: "onMouseUp", + value: function onMouseUp(event) { + var priv = privatePool$2.get(this); + var cell = this.parentCell(event.target); + + if (cell.TD && this.instance.hasSetting('onCellMouseUp')) { + this.instance.getSetting('onCellMouseUp', event, cell.coords, cell.TD, this.instance); + } // if not left mouse button, and the origin event is not comes from touch + + + if (event.button !== 0 && !this.instance.touchApplied) { + return; + } + + if (cell.TD === priv.dblClickOrigin[0] && cell.TD === priv.dblClickOrigin[1]) { + if (hasClass(event.target, 'corner')) { + this.instance.getSetting('onCellCornerDblClick', event, cell.coords, cell.TD, this.instance); + } else { + this.instance.getSetting('onCellDblClick', event, cell.coords, cell.TD, this.instance); + } + + priv.dblClickOrigin[0] = null; + priv.dblClickOrigin[1] = null; + } else if (cell.TD === priv.dblClickOrigin[0]) { + priv.dblClickOrigin[1] = cell.TD; + clearTimeout(priv.dblClickTimeout[1]); + priv.dblClickTimeout[1] = setTimeout(function () { + priv.dblClickOrigin[1] = null; + }, 500); + } + } + /** + * OnTouchStart callback. Simulates mousedown event. + * + * @private + * @param {MouseEvent} event The mouse event object. + */ + + }, { + key: "onTouchStart", + value: function onTouchStart(event) { + var priv = privatePool$2.get(this); + priv.selectedCellBeforeTouchEnd = this.instance.selections.getCell().cellRange; + this.instance.touchApplied = true; + this.onMouseDown(event); + } + /** + * OnTouchEnd callback. Simulates mouseup event. + * + * @private + * @param {MouseEvent} event The mouse event object. + */ + + }, { + key: "onTouchEnd", + value: function onTouchEnd(event) { + var excludeTags = ['A', 'BUTTON', 'INPUT']; + var target = event.target; // When the standard event was performed on the link element (a cell which contains HTML `a` element) then here + // we check if it should be canceled. Click is blocked in a situation when the element is rendered outside + // selected cells. This prevents accidentally page reloads while selecting adjacent cells. + + if (this.selectedCellWasTouched(target) === false && excludeTags.includes(target.tagName)) { + event.preventDefault(); + } + + this.onMouseUp(event); + this.instance.touchApplied = false; + } + /** + * Clears double-click timeouts and destroys the internal eventManager instance. + */ + + }, { + key: "destroy", + value: function destroy() { + var priv = privatePool$2.get(this); + clearTimeout(priv.dblClickTimeout[0]); + clearTimeout(priv.dblClickTimeout[1]); + this.eventManager.destroy(); + } + }]); + + return Event; +}(); + +var KEY_CODES = { + MOUSE_LEFT: 1, + MOUSE_RIGHT: 3, + MOUSE_MIDDLE: 2, + BACKSPACE: 8, + COMMA: 188, + INSERT: 45, + DELETE: 46, + END: 35, + ENTER: 13, + ESCAPE: 27, + CONTROL: 17, + COMMAND_LEFT: 91, + COMMAND_RIGHT: 93, + COMMAND_FIREFOX: 224, + ALT: 18, + HOME: 36, + PAGE_DOWN: 34, + PAGE_UP: 33, + PERIOD: 190, + SPACE: 32, + SHIFT: 16, + CAPS_LOCK: 20, + TAB: 9, + ARROW_RIGHT: 39, + ARROW_LEFT: 37, + ARROW_UP: 38, + ARROW_DOWN: 40, + F1: 112, + F2: 113, + F3: 114, + F4: 115, + F5: 116, + F6: 117, + F7: 118, + F8: 119, + F9: 120, + F10: 121, + F11: 122, + F12: 123, + A: 65, + C: 67, + D: 68, + F: 70, + L: 76, + O: 79, + P: 80, + S: 83, + V: 86, + X: 88 +}; +/** + * Returns true if keyCode represents a printable character. + * + * @param {number} keyCode The keyboard key code. + * @returns {boolean} + */ + +function isPrintableChar(keyCode) { + return keyCode === 32 || // space + keyCode >= 48 && keyCode <= 57 || // 0-9 + keyCode >= 96 && keyCode <= 111 || // numpad + keyCode >= 186 && keyCode <= 192 || // ;=,-./` + keyCode >= 219 && keyCode <= 222 || // []{}\|"' + keyCode >= 226 || // special chars (229 for Asian chars) + keyCode >= 65 && keyCode <= 90; // a-z +} +/** + * @param {number} keyCode The keyboard key code. + * @returns {boolean} + */ + +function isMetaKey(keyCode) { + var metaKeys = [KEY_CODES.ARROW_DOWN, KEY_CODES.ARROW_UP, KEY_CODES.ARROW_LEFT, KEY_CODES.ARROW_RIGHT, KEY_CODES.HOME, KEY_CODES.END, KEY_CODES.DELETE, KEY_CODES.BACKSPACE, KEY_CODES.F1, KEY_CODES.F2, KEY_CODES.F3, KEY_CODES.F4, KEY_CODES.F5, KEY_CODES.F6, KEY_CODES.F7, KEY_CODES.F8, KEY_CODES.F9, KEY_CODES.F10, KEY_CODES.F11, KEY_CODES.F12, KEY_CODES.TAB, KEY_CODES.PAGE_DOWN, KEY_CODES.PAGE_UP, KEY_CODES.ENTER, KEY_CODES.ESCAPE, KEY_CODES.SHIFT, KEY_CODES.CAPS_LOCK, KEY_CODES.ALT]; + return metaKeys.indexOf(keyCode) !== -1; +} +/** + * Checks if passed key code is ctrl or cmd key. Depends on what OS the code runs it check key code based on + * different meta key codes. + * + * @param {number} keyCode The keyboard key code. + * @returns {boolean} + */ + +function isCtrlKey(keyCode) { + var keys = []; + + if (navigator.platform.includes('Mac')) { + keys.push(KEY_CODES.COMMAND_LEFT, KEY_CODES.COMMAND_RIGHT, KEY_CODES.COMMAND_FIREFOX); + } else { + keys.push(KEY_CODES.CONTROL); + } + + return keys.includes(keyCode); +} +/** + * Checks if passed key code is ctrl or cmd key. This helper checks if the key code matches to meta keys + * regardless of the OS on which it is running. + * + * @param {number} keyCode The keyboard key code. + * @returns {boolean} + */ + +function isCtrlMetaKey(keyCode) { + return [KEY_CODES.CONTROL, KEY_CODES.COMMAND_LEFT, KEY_CODES.COMMAND_RIGHT, KEY_CODES.COMMAND_FIREFOX].includes(keyCode); +} +/** + * @param {number} keyCode The keyboard key code. + * @param {string} baseCode The list of the key codes to compare with. + * @returns {boolean} + */ + +function isKey(keyCode, baseCode) { + var keys = baseCode.split('|'); + var result = false; + arrayEach(keys, function (key) { + if (keyCode === KEY_CODES[key]) { + result = true; + return false; + } + }); + return result; +} + +var unicodeHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + KEY_CODES: KEY_CODES, + isPrintableChar: isPrintableChar, + isMetaKey: isMetaKey, + isCtrlKey: isCtrlKey, + isCtrlMetaKey: isCtrlMetaKey, + isKey: isKey +}); + +function _classCallCheck$B(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$w(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); } } + +function _createClass$w(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$w(Constructor.prototype, protoProps); if (staticProps) _defineProperties$w(Constructor, staticProps); return Constructor; } +registerOverlayOnce(BottomLeftCornerOverlay); +registerOverlayOnce(BottomOverlay); +registerOverlayOnce(LeftOverlay); +registerOverlayOnce(TopLeftCornerOverlay); +registerOverlayOnce(TopOverlay); +/** + * @class Overlays + */ + +var Overlays = /*#__PURE__*/function () { + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + function Overlays(wotInstance) { + _classCallCheck$B(this, Overlays); + + /** + * Walkontable instance's reference. + * + * @private + * @type {Walkontable} + */ + this.wot = wotInstance; + var _this$wot = this.wot, + rootDocument = _this$wot.rootDocument, + rootWindow = _this$wot.rootWindow, + wtTable = _this$wot.wtTable; + /** + * Sometimes `line-height` might be set to 'normal'. In that case, a default `font-size` should be multiplied by roughly 1.2. + * Https://developer.mozilla.org/pl/docs/Web/CSS/line-height#Values. + */ + + var BODY_LINE_HEIGHT = parseInt(rootWindow.getComputedStyle(rootDocument.body).lineHeight, 10); + var FALLBACK_BODY_LINE_HEIGHT = parseInt(rootWindow.getComputedStyle(rootDocument.body).fontSize, 10) * 1.2; // legacy support + + this.instance = this.wot; + this.eventManager = new EventManager(this.wot); + this.scrollbarSize = getScrollbarWidth(rootDocument); + this.wot.update('scrollbarWidth', this.scrollbarSize); + this.wot.update('scrollbarHeight', this.scrollbarSize); + var isOverflowHidden = rootWindow.getComputedStyle(wtTable.wtRootElement.parentNode).getPropertyValue('overflow') === 'hidden'; + this.scrollableElement = isOverflowHidden ? wtTable.holder : getScrollableElement(wtTable.TABLE); + this.topOverlay = void 0; + this.bottomOverlay = void 0; + this.leftOverlay = void 0; + this.topLeftCornerOverlay = void 0; + this.bottomLeftCornerOverlay = void 0; + this.prepareOverlays(); + this.hasScrollbarBottom = false; + this.hasScrollbarRight = false; + this.destroyed = false; + this.keyPressed = false; + this.spreaderLastSize = { + width: null, + height: null + }; + this.verticalScrolling = false; + this.horizontalScrolling = false; + this.browserLineHeight = BODY_LINE_HEIGHT || FALLBACK_BODY_LINE_HEIGHT; + this.registerListeners(); + this.lastScrollX = rootWindow.scrollX; + this.lastScrollY = rootWindow.scrollY; + } + /** + * Prepare overlays based on user settings. + * + * @returns {boolean} Returns `true` if changes applied to overlay needs scroll synchronization. + */ + + + _createClass$w(Overlays, [{ + key: "prepareOverlays", + value: function prepareOverlays() { + var syncScroll = false; + + if (this.topOverlay) { + syncScroll = this.topOverlay.updateStateOfRendering() || syncScroll; + } else { + this.topOverlay = createOverlay(CLONE_TOP, this.wot); + } + + if (!hasOverlay(CLONE_BOTTOM)) { + this.bottomOverlay = { + needFullRender: false, + updateStateOfRendering: function updateStateOfRendering() { + return false; + } + }; + } + + if (!hasOverlay(CLONE_BOTTOM_LEFT_CORNER)) { + this.bottomLeftCornerOverlay = { + needFullRender: false, + updateStateOfRendering: function updateStateOfRendering() { + return false; + } + }; + } + + if (this.bottomOverlay) { + syncScroll = this.bottomOverlay.updateStateOfRendering() || syncScroll; + } else { + this.bottomOverlay = createOverlay(CLONE_BOTTOM, this.wot); + } + + if (this.leftOverlay) { + syncScroll = this.leftOverlay.updateStateOfRendering() || syncScroll; + } else { + this.leftOverlay = createOverlay(CLONE_LEFT, this.wot); + } + + if (this.topOverlay.needFullRender && this.leftOverlay.needFullRender) { + if (this.topLeftCornerOverlay) { + syncScroll = this.topLeftCornerOverlay.updateStateOfRendering() || syncScroll; + } else { + this.topLeftCornerOverlay = createOverlay(CLONE_TOP_LEFT_CORNER, this.wot); + } + } + + if (this.bottomOverlay.needFullRender && this.leftOverlay.needFullRender) { + if (this.bottomLeftCornerOverlay) { + syncScroll = this.bottomLeftCornerOverlay.updateStateOfRendering() || syncScroll; + } else { + this.bottomLeftCornerOverlay = createOverlay(CLONE_BOTTOM_LEFT_CORNER, this.wot); + } + } + + return syncScroll; + } + /** + * Refresh and redraw table. + */ + + }, { + key: "refreshAll", + value: function refreshAll() { + if (!this.wot.drawn) { + return; + } + + if (!this.wot.wtTable.holder.parentNode) { + // Walkontable was detached from DOM, but this handler was not removed + this.destroy(); + return; + } + + this.wot.draw(true); + + if (this.verticalScrolling) { + this.leftOverlay.onScroll(); + } + + if (this.horizontalScrolling) { + this.topOverlay.onScroll(); + } + + this.verticalScrolling = false; + this.horizontalScrolling = false; + } + /** + * Register all necessary event listeners. + */ + + }, { + key: "registerListeners", + value: function registerListeners() { + var _this = this; + + var _this$wot2 = this.wot, + rootDocument = _this$wot2.rootDocument, + rootWindow = _this$wot2.rootWindow; + var topOverlayScrollableElement = this.topOverlay.mainTableScrollableElement; + var leftOverlayScrollableElement = this.leftOverlay.mainTableScrollableElement; + this.eventManager.addEventListener(rootDocument.documentElement, 'keydown', function (event) { + return _this.onKeyDown(event); + }); + this.eventManager.addEventListener(rootDocument.documentElement, 'keyup', function () { + return _this.onKeyUp(); + }); + this.eventManager.addEventListener(rootDocument, 'visibilitychange', function () { + return _this.onKeyUp(); + }); + this.eventManager.addEventListener(topOverlayScrollableElement, 'scroll', function (event) { + return _this.onTableScroll(event); + }, { + passive: true + }); + + if (topOverlayScrollableElement !== leftOverlayScrollableElement) { + this.eventManager.addEventListener(leftOverlayScrollableElement, 'scroll', function (event) { + return _this.onTableScroll(event); + }, { + passive: true + }); + } + + var isHighPixelRatio = rootWindow.devicePixelRatio && rootWindow.devicePixelRatio > 1; + var isScrollOnWindow = this.scrollableElement === rootWindow; + var preventWheel = this.wot.wtSettings.getSetting('preventWheel'); + var wheelEventOptions = { + passive: isScrollOnWindow + }; + + if (preventWheel || isHighPixelRatio || !isChrome()) { + this.eventManager.addEventListener(this.wot.wtTable.wtRootElement, 'wheel', function (event) { + return _this.onCloneWheel(event, preventWheel); + }, wheelEventOptions); + } + + var overlays = [this.topOverlay, this.bottomOverlay, this.leftOverlay, this.topLeftCornerOverlay, this.bottomLeftCornerOverlay]; + overlays.forEach(function (overlay) { + if (overlay && overlay.needFullRender) { + var holder = overlay.clone.wtTable.holder; + + _this.eventManager.addEventListener(holder, 'wheel', function (event) { + return _this.onCloneWheel(event, preventWheel); + }, wheelEventOptions); + } + }); + var resizeTimeout; + this.eventManager.addEventListener(rootWindow, 'resize', function () { + clearTimeout(resizeTimeout); + resizeTimeout = setTimeout(function () { + _this.wot.getSetting('onWindowResize'); + }, 200); + }); + } + /** + * Deregister all previously registered listeners. + */ + + }, { + key: "deregisterListeners", + value: function deregisterListeners() { + this.eventManager.clearEvents(true); + } + /** + * Scroll listener. + * + * @param {Event} event The mouse event object. + */ + + }, { + key: "onTableScroll", + value: function onTableScroll(event) { + // There was if statement which controlled flow of this function. It avoided the execution of the next lines + // on mobile devices. It was changed. Broader description of this case is included within issue #4856. + var rootWindow = this.wot.rootWindow; + var masterHorizontal = this.leftOverlay.mainTableScrollableElement; + var masterVertical = this.topOverlay.mainTableScrollableElement; + var target = event.target; // For key press, sync only master -> overlay position because while pressing Walkontable.render is triggered + // by hot.refreshBorder + + if (this.keyPressed) { + if (masterVertical !== rootWindow && target !== rootWindow && !event.target.contains(masterVertical) || masterHorizontal !== rootWindow && target !== rootWindow && !event.target.contains(masterHorizontal)) { + return; + } + } + + this.syncScrollPositions(event); + } + /** + * Wheel listener for cloned overlays. + * + * @param {Event} event The mouse event object. + * @param {boolean} preventDefault If `true`, the `preventDefault` will be called on event object. + */ + + }, { + key: "onCloneWheel", + value: function onCloneWheel(event, preventDefault) { + var rootWindow = this.wot.rootWindow; // There was if statement which controlled flow of this function. It avoided the execution of the next lines + // on mobile devices. It was changed. Broader description of this case is included within issue #4856. + + var masterHorizontal = this.leftOverlay.mainTableScrollableElement; + var masterVertical = this.topOverlay.mainTableScrollableElement; + var target = event.target; // For key press, sync only master -> overlay position because while pressing Walkontable.render is triggered + // by hot.refreshBorder + + var shouldNotWheelVertically = masterVertical !== rootWindow && target !== rootWindow && !target.contains(masterVertical); + var shouldNotWheelHorizontally = masterHorizontal !== rootWindow && target !== rootWindow && !target.contains(masterHorizontal); + + if (this.keyPressed && (shouldNotWheelVertically || shouldNotWheelHorizontally)) { + return; + } + + var isScrollPossible = this.translateMouseWheelToScroll(event); + + if (preventDefault || this.scrollableElement !== rootWindow && isScrollPossible) { + event.preventDefault(); + } + } + /** + * Key down listener. + * + * @param {Event} event The keyboard event object. + */ + + }, { + key: "onKeyDown", + value: function onKeyDown(event) { + this.keyPressed = isKey(event.keyCode, 'ARROW_UP|ARROW_RIGHT|ARROW_DOWN|ARROW_LEFT'); + } + /** + * Key up listener. + */ + + }, { + key: "onKeyUp", + value: function onKeyUp() { + this.keyPressed = false; + } + /** + * Translate wheel event into scroll event and sync scroll overlays position. + * + * @private + * @param {Event} event The mouse event object. + * @returns {boolean} + */ + + }, { + key: "translateMouseWheelToScroll", + value: function translateMouseWheelToScroll(event) { + var browserLineHeight = this.browserLineHeight; + var deltaY = isNaN(event.deltaY) ? -1 * event.wheelDeltaY : event.deltaY; + var deltaX = isNaN(event.deltaX) ? -1 * event.wheelDeltaX : event.deltaX; + + if (event.deltaMode === 1) { + deltaX += deltaX * browserLineHeight; + deltaY += deltaY * browserLineHeight; + } + + var isScrollVerticallyPossible = this.scrollVertically(deltaY); + var isScrollHorizontallyPossible = this.scrollHorizontally(deltaX); + return isScrollVerticallyPossible || isScrollHorizontallyPossible; + } + /** + * Scrolls main scrollable element horizontally. + * + * @param {number} delta Relative value to scroll. + * @returns {boolean} + */ + + }, { + key: "scrollVertically", + value: function scrollVertically(delta) { + var previousScroll = this.scrollableElement.scrollTop; + this.scrollableElement.scrollTop += delta; + return previousScroll !== this.scrollableElement.scrollTop; + } + /** + * Scrolls main scrollable element horizontally. + * + * @param {number} delta Relative value to scroll. + * @returns {boolean} + */ + + }, { + key: "scrollHorizontally", + value: function scrollHorizontally(delta) { + var previousScroll = this.scrollableElement.scrollLeft; + this.scrollableElement.scrollLeft += delta; + return previousScroll !== this.scrollableElement.scrollLeft; + } + /** + * Synchronize scroll position between master table and overlay table. + * + * @private + */ + + }, { + key: "syncScrollPositions", + value: function syncScrollPositions() { + if (this.destroyed) { + return; + } + + var rootWindow = this.wot.rootWindow; + var topHolder = this.topOverlay.clone.wtTable.holder; + var leftHolder = this.leftOverlay.clone.wtTable.holder; + var _ref = [this.scrollableElement.scrollLeft, this.scrollableElement.scrollTop], + scrollLeft = _ref[0], + scrollTop = _ref[1]; + this.horizontalScrolling = topHolder.scrollLeft !== scrollLeft || this.lastScrollX !== rootWindow.scrollX; + this.verticalScrolling = leftHolder.scrollTop !== scrollTop || this.lastScrollY !== rootWindow.scrollY; + this.lastScrollX = rootWindow.scrollX; + this.lastScrollY = rootWindow.scrollY; + + if (this.horizontalScrolling) { + topHolder.scrollLeft = scrollLeft; + var bottomHolder = this.bottomOverlay.needFullRender ? this.bottomOverlay.clone.wtTable.holder : null; + + if (bottomHolder) { + bottomHolder.scrollLeft = scrollLeft; + } + } + + if (this.verticalScrolling) { + leftHolder.scrollTop = scrollTop; + } + + this.refreshAll(); + } + /** + * Synchronize overlay scrollbars with the master scrollbar. + */ + + }, { + key: "syncScrollWithMaster", + value: function syncScrollWithMaster() { + var master = this.topOverlay.mainTableScrollableElement; + var scrollLeft = master.scrollLeft, + scrollTop = master.scrollTop; + + if (this.topOverlay.needFullRender) { + this.topOverlay.clone.wtTable.holder.scrollLeft = scrollLeft; + } + + if (this.bottomOverlay.needFullRender) { + this.bottomOverlay.clone.wtTable.holder.scrollLeft = scrollLeft; + } + + if (this.leftOverlay.needFullRender) { + this.leftOverlay.clone.wtTable.holder.scrollTop = scrollTop; + } + } + /** + * Update the main scrollable elements for all the overlays. + */ + + }, { + key: "updateMainScrollableElements", + value: function updateMainScrollableElements() { + this.deregisterListeners(); + this.leftOverlay.updateMainScrollableElement(); + this.topOverlay.updateMainScrollableElement(); + + if (this.bottomOverlay.needFullRender) { + this.bottomOverlay.updateMainScrollableElement(); + } + + var _this$wot3 = this.wot, + rootWindow = _this$wot3.rootWindow, + wtTable = _this$wot3.wtTable; + + if (rootWindow.getComputedStyle(wtTable.wtRootElement.parentNode).getPropertyValue('overflow') === 'hidden') { + this.scrollableElement = wtTable.holder; + } else { + this.scrollableElement = getScrollableElement(wtTable.TABLE); + } + + this.registerListeners(); + } + /** + * + */ + + }, { + key: "destroy", + value: function destroy() { + this.eventManager.destroy(); + this.topOverlay.destroy(); + + if (this.bottomOverlay.clone) { + this.bottomOverlay.destroy(); + } + + this.leftOverlay.destroy(); + + if (this.topLeftCornerOverlay) { + this.topLeftCornerOverlay.destroy(); + } + + if (this.bottomLeftCornerOverlay && this.bottomLeftCornerOverlay.clone) { + this.bottomLeftCornerOverlay.destroy(); + } + + this.destroyed = true; + } + /** + * @param {boolean} [fastDraw=false] When `true`, try to refresh only the positions of borders without rerendering + * the data. It will only work if Table.draw() does not force + * rendering anyway. + */ + + }, { + key: "refresh", + value: function refresh() { + var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var spreader = this.wot.wtTable.spreader; + var width = spreader.clientWidth; + var height = spreader.clientHeight; + + if (width !== this.spreaderLastSize.width || height !== this.spreaderLastSize.height) { + this.spreaderLastSize.width = width; + this.spreaderLastSize.height = height; + this.adjustElementsSize(); + } + + if (this.bottomOverlay.clone) { + this.bottomOverlay.refresh(fastDraw); + } + + this.leftOverlay.refresh(fastDraw); + this.topOverlay.refresh(fastDraw); + + if (this.topLeftCornerOverlay) { + this.topLeftCornerOverlay.refresh(fastDraw); + } + + if (this.bottomLeftCornerOverlay && this.bottomLeftCornerOverlay.clone) { + this.bottomLeftCornerOverlay.refresh(fastDraw); + } + } + /** + * Adjust overlays elements size and master table size. + * + * @param {boolean} [force=false] When `true`, it adjust the DOM nodes sizes for all overlays. + */ + + }, { + key: "adjustElementsSize", + value: function adjustElementsSize() { + var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var _this$wot4 = this.wot, + wtViewport = _this$wot4.wtViewport, + wtTable = _this$wot4.wtTable; + var totalColumns = this.wot.getSetting('totalColumns'); + var totalRows = this.wot.getSetting('totalRows'); + var headerRowSize = wtViewport.getRowHeaderWidth(); + var headerColumnSize = wtViewport.getColumnHeaderHeight(); + var hiderStyle = wtTable.hider.style; + hiderStyle.width = "".concat(headerRowSize + this.leftOverlay.sumCellSizes(0, totalColumns), "px"); + hiderStyle.height = "".concat(headerColumnSize + this.topOverlay.sumCellSizes(0, totalRows) + 1, "px"); + + if (this.scrollbarSize > 0) { + var _wtTable$wtRootElemen = wtTable.wtRootElement, + rootElemScrollHeight = _wtTable$wtRootElemen.scrollHeight, + rootElemScrollWidth = _wtTable$wtRootElemen.scrollWidth; + var _wtTable$holder = wtTable.holder, + holderScrollHeight = _wtTable$holder.scrollHeight, + holderScrollWidth = _wtTable$holder.scrollWidth; + this.hasScrollbarRight = rootElemScrollHeight < holderScrollHeight; + this.hasScrollbarBottom = rootElemScrollWidth < holderScrollWidth; + + if (this.hasScrollbarRight && wtTable.hider.scrollWidth + this.scrollbarSize > rootElemScrollWidth) { + this.hasScrollbarBottom = true; + } else if (this.hasScrollbarBottom && wtTable.hider.scrollHeight + this.scrollbarSize > rootElemScrollHeight) { + this.hasScrollbarRight = true; + } + } + + this.topOverlay.adjustElementsSize(force); + this.leftOverlay.adjustElementsSize(force); + this.bottomOverlay.adjustElementsSize(force); + } + /** + * + */ + + }, { + key: "applyToDOM", + value: function applyToDOM() { + var wtTable = this.wot.wtTable; + + if (!wtTable.isVisible()) { + return; + } + + this.topOverlay.applyToDOM(); + + if (this.bottomOverlay.clone) { + this.bottomOverlay.applyToDOM(); + } + + this.leftOverlay.applyToDOM(); + } + /** + * Get the parent overlay of the provided element. + * + * @param {HTMLElement} element An element to process. + * @returns {object|null} + */ + + }, { + key: "getParentOverlay", + value: function getParentOverlay(element) { + if (!element) { + return null; + } + + var overlays = [this.topOverlay, this.leftOverlay, this.bottomOverlay, this.topLeftCornerOverlay, this.bottomLeftCornerOverlay]; + var result = null; + arrayEach(overlays, function (elem) { + if (!elem) { + return; + } + + if (elem.clone && elem.clone.wtTable.TABLE.contains(element)) { + result = elem.clone; + } + }); + return result; + } + /** + * Synchronize the class names between the main overlay table and the tables on the other overlays. + * + */ + + }, { + key: "syncOverlayTableClassNames", + value: function syncOverlayTableClassNames() { + var masterTable = this.instance.wtTable.TABLE; + var overlays = [this.topOverlay, this.leftOverlay, this.bottomOverlay, this.topLeftCornerOverlay, this.bottomLeftCornerOverlay]; + arrayEach(overlays, function (elem) { + if (!elem) { + return; + } + + elem.clone.wtTable.TABLE.className = masterTable.className; + }); + } + }]); + + return Overlays; +}(); + +function _classCallCheck$C(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$x(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); } } + +function _createClass$x(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$x(Constructor.prototype, protoProps); if (staticProps) _defineProperties$x(Constructor, staticProps); return Constructor; } +/** + * @class Scroll + */ + +var Scroll = /*#__PURE__*/function () { + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + function Scroll(wotInstance) { + _classCallCheck$C(this, Scroll); + + this.wot = wotInstance; + } + /** + * Scrolls viewport to a cell. + * + * @param {CellCoords} coords The cell coordinates. + * @param {boolean} [snapToTop] If `true`, viewport is scrolled to show the cell on the top of the table. + * @param {boolean} [snapToRight] If `true`, viewport is scrolled to show the cell on the right of the table. + * @param {boolean} [snapToBottom] If `true`, viewport is scrolled to show the cell on the bottom of the table. + * @param {boolean} [snapToLeft] If `true`, viewport is scrolled to show the cell on the left of the table. + * @returns {boolean} + */ + + + _createClass$x(Scroll, [{ + key: "scrollViewport", + value: function scrollViewport(coords, snapToTop, snapToRight, snapToBottom, snapToLeft) { + if (coords.col < 0 || coords.row < 0) { + return false; + } + + var scrolledHorizontally = this.scrollViewportHorizontally(coords.col, snapToRight, snapToLeft); + var scrolledVertically = this.scrollViewportVertically(coords.row, snapToTop, snapToBottom); + return scrolledHorizontally || scrolledVertically; + } + /** + * Scrolls viewport to a column. + * + * @param {number} column Visual column index. + * @param {boolean} [snapToRight] If `true`, viewport is scrolled to show the cell on the right of the table. + * @param {boolean} [snapToLeft] If `true`, viewport is scrolled to show the cell on the left of the table. + * @returns {boolean} + */ + + }, { + key: "scrollViewportHorizontally", + value: function scrollViewportHorizontally(column, snapToRight, snapToLeft) { + if (!this.wot.drawn) { + return false; + } + + var _this$_getVariables = this._getVariables(), + fixedColumnsLeft = _this$_getVariables.fixedColumnsLeft, + leftOverlay = _this$_getVariables.leftOverlay, + totalColumns = _this$_getVariables.totalColumns; + + var result = false; + + if (column >= 0 && column <= Math.max(totalColumns - 1, 0)) { + var firstVisibleColumn = this.getFirstVisibleColumn(); + var lastVisibleColumn = this.getLastVisibleColumn(); + + if (column >= fixedColumnsLeft && firstVisibleColumn > -1 && (column < firstVisibleColumn || snapToLeft)) { + result = leftOverlay.scrollTo(column); + } else if (lastVisibleColumn === -1 || lastVisibleColumn > -1 && (column > lastVisibleColumn || snapToRight)) { + result = leftOverlay.scrollTo(column, true); + } + } + + return result; + } + /** + * Scrolls viewport to a row. + * + * @param {number} row Visual row index. + * @param {boolean} [snapToTop] If `true`, viewport is scrolled to show the cell on the top of the table. + * @param {boolean} [snapToBottom] If `true`, viewport is scrolled to show the cell on the bottom of the table. + * @returns {boolean} + */ + + }, { + key: "scrollViewportVertically", + value: function scrollViewportVertically(row, snapToTop, snapToBottom) { + if (!this.wot.drawn) { + return false; + } + + var _this$_getVariables2 = this._getVariables(), + fixedRowsBottom = _this$_getVariables2.fixedRowsBottom, + fixedRowsTop = _this$_getVariables2.fixedRowsTop, + topOverlay = _this$_getVariables2.topOverlay, + totalRows = _this$_getVariables2.totalRows; + + var result = false; + + if (row >= 0 && row <= Math.max(totalRows - 1, 0)) { + var firstVisibleRow = this.getFirstVisibleRow(); + var lastVisibleRow = this.getLastVisibleRow(); + + if (row >= fixedRowsTop && firstVisibleRow > -1 && (row < firstVisibleRow || snapToTop)) { + result = topOverlay.scrollTo(row); + } else if (lastVisibleRow === -1 || lastVisibleRow > -1 && (row > lastVisibleRow && row < totalRows - fixedRowsBottom || snapToBottom)) { + result = topOverlay.scrollTo(row, true); + } + } + + return result; + } + /** + * Get first visible row based on virtual dom and how table is visible in browser window viewport. + * + * @returns {number} + */ + + }, { + key: "getFirstVisibleRow", + value: function getFirstVisibleRow() { + var _this$_getVariables3 = this._getVariables(), + topOverlay = _this$_getVariables3.topOverlay, + wtTable = _this$_getVariables3.wtTable, + wtViewport = _this$_getVariables3.wtViewport, + totalRows = _this$_getVariables3.totalRows, + fixedRowsTop = _this$_getVariables3.fixedRowsTop; + + var rootWindow = this.wot.rootWindow; + var firstVisibleRow = wtTable.getFirstVisibleRow(); + + if (topOverlay.mainTableScrollableElement === rootWindow) { + var rootElementOffset = offset(wtTable.wtRootElement); + var totalTableHeight = innerHeight(wtTable.hider); + var windowHeight = innerHeight(rootWindow); + var windowScrollTop = getScrollTop(rootWindow, rootWindow); // Only calculate firstVisibleRow when table didn't filled (from up) whole viewport space + + if (rootElementOffset.top + totalTableHeight - windowHeight <= windowScrollTop) { + var rowsHeight = wtViewport.getColumnHeaderHeight(); + rowsHeight += topOverlay.sumCellSizes(0, fixedRowsTop); + + for (var row = totalRows; row > 0; row--) { + rowsHeight += topOverlay.sumCellSizes(row - 1, row); + + if (rootElementOffset.top + totalTableHeight - rowsHeight <= windowScrollTop) { + // Return physical row + 1 + firstVisibleRow = row; + break; + } + } + } + } + + return firstVisibleRow; + } + /** + * Get last visible row based on virtual dom and how table is visible in browser window viewport. + * + * @returns {number} + */ + + }, { + key: "getLastVisibleRow", + value: function getLastVisibleRow() { + var _this$_getVariables4 = this._getVariables(), + topOverlay = _this$_getVariables4.topOverlay, + wtTable = _this$_getVariables4.wtTable, + wtViewport = _this$_getVariables4.wtViewport, + totalRows = _this$_getVariables4.totalRows; + + var rootWindow = this.wot.rootWindow; + var lastVisibleRow = wtTable.getLastVisibleRow(); + + if (topOverlay.mainTableScrollableElement === rootWindow) { + var rootElementOffset = offset(wtTable.wtRootElement); + var windowScrollTop = getScrollTop(rootWindow, rootWindow); // Only calculate lastVisibleRow when table didn't filled (from bottom) whole viewport space + + if (rootElementOffset.top > windowScrollTop) { + var windowHeight = innerHeight(rootWindow); + var rowsHeight = wtViewport.getColumnHeaderHeight(); + + for (var row = 1; row <= totalRows; row++) { + rowsHeight += topOverlay.sumCellSizes(row - 1, row); + + if (rootElementOffset.top + rowsHeight - windowScrollTop >= windowHeight) { + // Return physical row - 1 (-2 because rangeEach gives row index + 1 - sumCellSizes requirements) + lastVisibleRow = row - 2; + break; + } + } + } + } + + return lastVisibleRow; + } + /** + * Get first visible column based on virtual dom and how table is visible in browser window viewport. + * + * @returns {number} + */ + + }, { + key: "getFirstVisibleColumn", + value: function getFirstVisibleColumn() { + var _this$_getVariables5 = this._getVariables(), + leftOverlay = _this$_getVariables5.leftOverlay, + wtTable = _this$_getVariables5.wtTable, + wtViewport = _this$_getVariables5.wtViewport, + totalColumns = _this$_getVariables5.totalColumns; + + var rootWindow = this.wot.rootWindow; + var firstVisibleColumn = wtTable.getFirstVisibleColumn(); + + if (leftOverlay.mainTableScrollableElement === rootWindow) { + var rootElementOffset = offset(wtTable.wtRootElement); + var totalTableWidth = innerWidth(wtTable.hider); + var windowWidth = innerWidth(rootWindow); + var windowScrollLeft = getScrollLeft(rootWindow, rootWindow); // Only calculate firstVisibleColumn when table didn't filled (from left) whole viewport space + + if (rootElementOffset.left + totalTableWidth - windowWidth <= windowScrollLeft) { + var columnsWidth = wtViewport.getRowHeaderWidth(); + + for (var column = totalColumns; column > 0; column--) { + columnsWidth += leftOverlay.sumCellSizes(column - 1, column); + + if (rootElementOffset.left + totalTableWidth - columnsWidth <= windowScrollLeft) { + // Return physical column + 1 + firstVisibleColumn = column; + break; + } + } + } + } + + return firstVisibleColumn; + } + /** + * Get last visible column based on virtual dom and how table is visible in browser window viewport. + * + * @returns {number} + */ + + }, { + key: "getLastVisibleColumn", + value: function getLastVisibleColumn() { + var _this$_getVariables6 = this._getVariables(), + leftOverlay = _this$_getVariables6.leftOverlay, + wtTable = _this$_getVariables6.wtTable, + wtViewport = _this$_getVariables6.wtViewport, + totalColumns = _this$_getVariables6.totalColumns; + + var rootWindow = this.wot.rootWindow; + var lastVisibleColumn = wtTable.getLastVisibleColumn(); + + if (leftOverlay.mainTableScrollableElement === rootWindow) { + var rootElementOffset = offset(wtTable.wtRootElement); + var windowScrollLeft = getScrollLeft(rootWindow, rootWindow); // Only calculate lastVisibleColumn when table didn't filled (from right) whole viewport space + + if (rootElementOffset.left > windowScrollLeft) { + var windowWidth = innerWidth(rootWindow); + var columnsWidth = wtViewport.getRowHeaderWidth(); + + for (var column = 1; column <= totalColumns; column++) { + columnsWidth += leftOverlay.sumCellSizes(column - 1, column); + + if (rootElementOffset.left + columnsWidth - windowScrollLeft >= windowWidth) { + // Return physical column - 1 (-2 because rangeEach gives column index + 1 - sumCellSizes requirements) + lastVisibleColumn = column - 2; + break; + } + } + } + } + + return lastVisibleColumn; + } + /** + * Returns collection of variables used to rows and columns visibility calculations. + * + * @returns {object} + * @private + */ + + }, { + key: "_getVariables", + value: function _getVariables() { + var wot = this.wot; + var topOverlay = wot.wtOverlays.topOverlay; + var leftOverlay = wot.wtOverlays.leftOverlay; + var wtTable = wot.wtTable; + var wtViewport = wot.wtViewport; + var totalRows = wot.getSetting('totalRows'); + var totalColumns = wot.getSetting('totalColumns'); + var fixedRowsTop = wot.getSetting('fixedRowsTop'); + var fixedRowsBottom = wot.getSetting('fixedRowsBottom'); + var fixedColumnsLeft = wot.getSetting('fixedColumnsLeft'); + return { + topOverlay: topOverlay, + leftOverlay: leftOverlay, + wtTable: wtTable, + wtViewport: wtViewport, + totalRows: totalRows, + totalColumns: totalColumns, + fixedRowsTop: fixedRowsTop, + fixedRowsBottom: fixedRowsBottom, + fixedColumnsLeft: fixedColumnsLeft + }; + } + }]); + + return Scroll; +}(); + +function _classCallCheck$D(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$y(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); } } + +function _createClass$y(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$y(Constructor.prototype, protoProps); if (staticProps) _defineProperties$y(Constructor, staticProps); return Constructor; } +/** + * @class Settings + */ + +var Settings = /*#__PURE__*/function () { + /** + * @param {Walkontable} wotInstance The Walkontable instance. + * @param {object} settings The user defined settings. + */ + function Settings(wotInstance, settings) { + var _this = this; + + _classCallCheck$D(this, Settings); + + this.wot = wotInstance; // legacy support + + this.instance = wotInstance; // default settings. void 0 means it is required, null means it can be empty + + this.defaults = { + table: void 0, + // presentation mode + externalRowCalculator: false, + stretchH: 'none', + // values: all, last, none + currentRowClassName: null, + currentColumnClassName: null, + preventOverflow: function preventOverflow() { + return false; + }, + preventWheel: false, + // data source + data: void 0, + freezeOverlays: false, + // Number of renderable columns for the left overlay. + fixedColumnsLeft: 0, + // Number of renderable rows for the top overlay. + fixedRowsTop: 0, + // Number of renderable rows for the bottom overlay. + fixedRowsBottom: 0, + // Enable the left overlay when conditions are met. + shouldRenderLeftOverlay: function shouldRenderLeftOverlay() { + return _this.getSetting('fixedColumnsLeft') > 0 || _this.getSetting('rowHeaders').length > 0; + }, + // Enable the top overlay when conditions are met. + shouldRenderTopOverlay: function shouldRenderTopOverlay() { + return _this.getSetting('fixedRowsTop') > 0 || _this.getSetting('columnHeaders').length > 0; + }, + // Enable the bottom overlay when conditions are met. + shouldRenderBottomOverlay: function shouldRenderBottomOverlay() { + return _this.getSetting('fixedRowsBottom') > 0; + }, + minSpareRows: 0, + // this must be array of functions: [function (row, TH) {}] + rowHeaders: function rowHeaders() { + return []; + }, + // this must be array of functions: [function (column, TH) {}] + columnHeaders: function columnHeaders() { + return []; + }, + totalRows: void 0, + totalColumns: void 0, + cellRenderer: function cellRenderer(row, column, TD) { + var cellData = _this.getSetting('data', row, column); + + fastInnerText(TD, cellData === void 0 || cellData === null ? '' : cellData); + }, + // columnWidth: 50, + columnWidth: function columnWidth() {// return undefined means use default size for the rendered cell content + }, + rowHeight: function rowHeight() {// return undefined means use default size for the rendered cell content + }, + defaultRowHeight: 23, + defaultColumnWidth: 50, + selections: null, + hideBorderOnMouseDownOver: false, + viewportRowCalculatorOverride: null, + viewportColumnCalculatorOverride: null, + // callbacks + onCellMouseDown: null, + onCellContextMenu: null, + onCellMouseOver: null, + onCellMouseOut: null, + onCellMouseUp: null, + // onCellMouseOut: null, + onCellDblClick: null, + onCellCornerMouseDown: null, + onCellCornerDblClick: null, + beforeDraw: null, + onDraw: null, + onBeforeRemoveCellClassNames: null, + onAfterDrawSelection: null, + onBeforeDrawBorders: null, + onScrollVertically: null, + onScrollHorizontally: null, + onBeforeTouchScroll: null, + onAfterMomentumScroll: null, + onBeforeStretchingColumnWidth: function onBeforeStretchingColumnWidth(width) { + return width; + }, + onModifyRowHeaderWidth: null, + onModifyGetCellCoords: null, + onWindowResize: null, + // constants + scrollbarWidth: 10, + scrollbarHeight: 10, + renderAllRows: false, + groups: false, + rowHeaderWidth: null, + columnHeaderHeight: null, + headerClassName: null + }; // reference to settings + + this.settings = {}; + objectEach(this.defaults, function (value, key) { + if (settings[key] !== void 0) { + _this.settings[key] = settings[key]; + } else if (value === void 0) { + throw new Error("A required setting \"".concat(key, "\" was not provided")); + } else { + _this.settings[key] = value; + } + }); + } + /** + * Update settings. + * + * @param {object} settings The singular settings to update or if passed as object to merge with. + * @param {*} value The value to set if the first argument is passed as string. + * @returns {Walkontable} + */ + + + _createClass$y(Settings, [{ + key: "update", + value: function update(settings, value) { + var _this2 = this; + + if (value === void 0) { + // settings is object + objectEach(settings, function (settingValue, key) { + _this2.settings[key] = settingValue; + }); + } else { + // if value is defined then settings is the key + this.settings[settings] = value; + } + + return this.wot; + } + /** + * Get setting by name. + * + * @param {string} key The settings key to retrieve. + * @param {*} [param1] Additional parameter passed to the options defined as function. + * @param {*} [param2] Additional parameter passed to the options defined as function. + * @param {*} [param3] Additional parameter passed to the options defined as function. + * @param {*} [param4] Additional parameter passed to the options defined as function. + * @returns {*} + */ + + }, { + key: "getSetting", + value: function getSetting(key, param1, param2, param3, param4) { + if (typeof this.settings[key] === 'function') { + // this is faster than .apply - https://github.com/handsontable/handsontable/wiki/JavaScript-&-DOM-performance-tips + return this.settings[key](param1, param2, param3, param4); + } else if (param1 !== void 0 && Array.isArray(this.settings[key])) { + // perhaps this can be removed, it is only used in tests + return this.settings[key][param1]; + } + + return this.settings[key]; + } + /** + * Checks if setting exists. + * + * @param {boolean} key The settings key to check. + * @returns {boolean} + */ + + }, { + key: "has", + value: function has(key) { + return !!this.settings[key]; + } + }]); + + return Settings; +}(); + +function _classCallCheck$E(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$z(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); } } + +function _createClass$z(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$z(Constructor.prototype, protoProps); if (staticProps) _defineProperties$z(Constructor, staticProps); return Constructor; } +/** + * @class Viewport + */ + +var Viewport = /*#__PURE__*/function () { + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + function Viewport(wotInstance) { + var _this = this; + + _classCallCheck$E(this, Viewport); + + this.wot = wotInstance; // legacy support + + this.instance = this.wot; + this.oversizedRows = []; + this.oversizedColumnHeaders = []; + this.hasOversizedColumnHeadersMarked = {}; + this.clientHeight = 0; + this.containerWidth = NaN; + this.rowHeaderWidth = NaN; + this.rowsVisibleCalculator = null; + this.columnsVisibleCalculator = null; + this.eventManager = new EventManager(this.wot); + this.eventManager.addEventListener(this.wot.rootWindow, 'resize', function () { + _this.clientHeight = _this.getWorkspaceHeight(); + }); + } + /** + * @returns {number} + */ + + + _createClass$z(Viewport, [{ + key: "getWorkspaceHeight", + value: function getWorkspaceHeight() { + var currentDocument = this.wot.rootDocument; + var trimmingContainer = this.instance.wtOverlays.topOverlay.trimmingContainer; + var height = 0; + + if (trimmingContainer === this.wot.rootWindow) { + height = currentDocument.documentElement.clientHeight; + } else { + var elemHeight = outerHeight(trimmingContainer); // returns height without DIV scrollbar + + height = elemHeight > 0 && trimmingContainer.clientHeight > 0 ? trimmingContainer.clientHeight : Infinity; + } + + return height; + } + }, { + key: "getWorkspaceWidth", + value: function getWorkspaceWidth() { + var wot = this.wot; + var rootDocument = wot.rootDocument, + rootWindow = wot.rootWindow; + var trimmingContainer = this.instance.wtOverlays.leftOverlay.trimmingContainer; + var docOffsetWidth = rootDocument.documentElement.offsetWidth; + var totalColumns = wot.getSetting('totalColumns'); + var preventOverflow = wot.getSetting('preventOverflow'); + var width; + var overflow; + + if (preventOverflow) { + return outerWidth(this.instance.wtTable.wtRootElement); + } + + if (wot.getSetting('freezeOverlays')) { + width = Math.min(docOffsetWidth - this.getWorkspaceOffset().left, docOffsetWidth); + } else { + width = Math.min(this.getContainerFillWidth(), docOffsetWidth - this.getWorkspaceOffset().left, docOffsetWidth); + } + + if (trimmingContainer === rootWindow && totalColumns > 0 && this.sumColumnWidths(0, totalColumns - 1) > width) { + // in case sum of column widths is higher than available stylesheet width, let's assume using the whole window + // otherwise continue below, which will allow stretching + // this is used in `scroll_window.html` + // TODO test me + return rootDocument.documentElement.clientWidth; + } + + if (trimmingContainer !== rootWindow) { + overflow = getStyle(this.instance.wtOverlays.leftOverlay.trimmingContainer, 'overflow', rootWindow); + + if (overflow === 'scroll' || overflow === 'hidden' || overflow === 'auto') { + // this is used in `scroll.html` + // TODO test me + return Math.max(width, trimmingContainer.clientWidth); + } + } + + var stretchSetting = wot.getSetting('stretchH'); + + if (stretchSetting === 'none' || !stretchSetting) { + // if no stretching is used, return the maximum used workspace width + return Math.max(width, outerWidth(this.instance.wtTable.TABLE)); + } // if stretching is used, return the actual container width, so the columns can fit inside it + + + return width; + } + /** + * Checks if viewport has vertical scroll. + * + * @returns {boolean} + */ + + }, { + key: "hasVerticalScroll", + value: function hasVerticalScroll() { + return this.getWorkspaceActualHeight() > this.getWorkspaceHeight(); + } + /** + * Checks if viewport has horizontal scroll. + * + * @returns {boolean} + */ + + }, { + key: "hasHorizontalScroll", + value: function hasHorizontalScroll() { + return this.getWorkspaceActualWidth() > this.getWorkspaceWidth(); + } + /** + * @param {number} from The visual column index from the width sum is start calculated. + * @param {number} length The length of the column to traverse. + * @returns {number} + */ + + }, { + key: "sumColumnWidths", + value: function sumColumnWidths(from, length) { + var wtTable = this.wot.wtTable; + var sum = 0; + var column = from; + + while (column < length) { + sum += wtTable.getColumnWidth(column); + column += 1; + } + + return sum; + } + /** + * @returns {number} + */ + + }, { + key: "getContainerFillWidth", + value: function getContainerFillWidth() { + if (this.containerWidth) { + return this.containerWidth; + } + + var mainContainer = this.instance.wtTable.holder; + var dummyElement = this.wot.rootDocument.createElement('div'); + dummyElement.style.width = '100%'; + dummyElement.style.height = '1px'; + mainContainer.appendChild(dummyElement); + var fillWidth = dummyElement.offsetWidth; + this.containerWidth = fillWidth; + mainContainer.removeChild(dummyElement); + return fillWidth; + } + /** + * @returns {number} + */ + + }, { + key: "getWorkspaceOffset", + value: function getWorkspaceOffset() { + return offset(this.wot.wtTable.TABLE); + } + /** + * @returns {number} + */ + + }, { + key: "getWorkspaceActualHeight", + value: function getWorkspaceActualHeight() { + return outerHeight(this.wot.wtTable.TABLE); + } + /** + * @returns {number} + */ + + }, { + key: "getWorkspaceActualWidth", + value: function getWorkspaceActualWidth() { + var wtTable = this.wot.wtTable; + return outerWidth(wtTable.TABLE) || outerWidth(wtTable.TBODY) || outerWidth(wtTable.THEAD); // IE8 reports 0 as offsetWidth; + } + /** + * @returns {number} + */ + + }, { + key: "getColumnHeaderHeight", + value: function getColumnHeaderHeight() { + var columnHeaders = this.instance.getSetting('columnHeaders'); + + if (!columnHeaders.length) { + this.columnHeaderHeight = 0; + } else if (isNaN(this.columnHeaderHeight)) { + this.columnHeaderHeight = outerHeight(this.wot.wtTable.THEAD); + } + + return this.columnHeaderHeight; + } + /** + * @returns {number} + */ + + }, { + key: "getViewportHeight", + value: function getViewportHeight() { + var containerHeight = this.getWorkspaceHeight(); + + if (containerHeight === Infinity) { + return containerHeight; + } + + var columnHeaderHeight = this.getColumnHeaderHeight(); + + if (columnHeaderHeight > 0) { + containerHeight -= columnHeaderHeight; + } + + return containerHeight; + } + /** + * @returns {number} + */ + + }, { + key: "getRowHeaderWidth", + value: function getRowHeaderWidth() { + var rowHeadersWidthSetting = this.instance.getSetting('rowHeaderWidth'); + var rowHeaders = this.instance.getSetting('rowHeaders'); + + if (rowHeadersWidthSetting) { + this.rowHeaderWidth = 0; + + for (var i = 0, len = rowHeaders.length; i < len; i++) { + this.rowHeaderWidth += rowHeadersWidthSetting[i] || rowHeadersWidthSetting; + } + } + + if (this.wot.cloneSource) { + return this.wot.cloneSource.wtViewport.getRowHeaderWidth(); + } + + if (isNaN(this.rowHeaderWidth)) { + if (rowHeaders.length) { + var TH = this.instance.wtTable.TABLE.querySelector('TH'); + this.rowHeaderWidth = 0; + + for (var _i = 0, _len = rowHeaders.length; _i < _len; _i++) { + if (TH) { + this.rowHeaderWidth += outerWidth(TH); + TH = TH.nextSibling; + } else { + // yes this is a cheat but it worked like that before, just taking assumption from CSS instead of measuring. + // TODO: proper fix + this.rowHeaderWidth += 50; + } + } + } else { + this.rowHeaderWidth = 0; + } + } + + this.rowHeaderWidth = this.instance.getSetting('onModifyRowHeaderWidth', this.rowHeaderWidth) || this.rowHeaderWidth; + return this.rowHeaderWidth; + } + /** + * @returns {number} + */ + + }, { + key: "getViewportWidth", + value: function getViewportWidth() { + var containerWidth = this.getWorkspaceWidth(); + + if (containerWidth === Infinity) { + return containerWidth; + } + + var rowHeaderWidth = this.getRowHeaderWidth(); + + if (rowHeaderWidth > 0) { + return containerWidth - rowHeaderWidth; + } + + return containerWidth; + } + /** + * Creates: + * - rowsRenderCalculator (before draw, to qualify rows for rendering) + * - rowsVisibleCalculator (after draw, to measure which rows are actually visible). + * + * @param {number} calculationType The render type ID, which determines for what type of + * calculation calculator is created. + * @returns {ViewportRowsCalculator} + */ + + }, { + key: "createRowsCalculator", + value: function createRowsCalculator() { + var calculationType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RENDER_TYPE; + var wot = this.wot; + var wtSettings = wot.wtSettings, + wtOverlays = wot.wtOverlays, + wtTable = wot.wtTable, + rootDocument = wot.rootDocument; + var height; + var scrollbarHeight; + var fixedRowsHeight; + this.rowHeaderWidth = NaN; + + if (wtSettings.settings.renderAllRows && calculationType === RENDER_TYPE) { + height = Infinity; + } else { + height = this.getViewportHeight(); + } + + var pos = wtOverlays.topOverlay.getScrollPosition() - wtOverlays.topOverlay.getTableParentOffset(); + + if (pos < 0) { + pos = 0; + } + + var fixedRowsTop = wot.getSetting('fixedRowsTop'); + var fixedRowsBottom = wot.getSetting('fixedRowsBottom'); + var totalRows = wot.getSetting('totalRows'); + + if (fixedRowsTop) { + fixedRowsHeight = wtOverlays.topOverlay.sumCellSizes(0, fixedRowsTop); + pos += fixedRowsHeight; + height -= fixedRowsHeight; + } + + if (fixedRowsBottom && wtOverlays.bottomOverlay.clone) { + fixedRowsHeight = wtOverlays.bottomOverlay.sumCellSizes(totalRows - fixedRowsBottom, totalRows); + height -= fixedRowsHeight; + } + + if (wtTable.holder.clientHeight === wtTable.holder.offsetHeight) { + scrollbarHeight = 0; + } else { + scrollbarHeight = getScrollbarWidth(rootDocument); + } + + return new ViewportRowsCalculator({ + viewportSize: height, + scrollOffset: pos, + totalItems: wot.getSetting('totalRows'), + itemSizeFn: function itemSizeFn(sourceRow) { + return wtTable.getRowHeight(sourceRow); + }, + overrideFn: wtSettings.settings.viewportRowCalculatorOverride, + calculationType: calculationType, + scrollbarHeight: scrollbarHeight + }); + } + /** + * Creates: + * - columnsRenderCalculator (before draw, to qualify columns for rendering) + * - columnsVisibleCalculator (after draw, to measure which columns are actually visible). + * + * @param {number} calculationType The render type ID, which determines for what type of + * calculation calculator is created. + * @returns {ViewportRowsCalculator} + */ + + }, { + key: "createColumnsCalculator", + value: function createColumnsCalculator() { + var calculationType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RENDER_TYPE; + var wot = this.wot; + var wtSettings = wot.wtSettings, + wtOverlays = wot.wtOverlays, + wtTable = wot.wtTable, + rootDocument = wot.rootDocument; + var width = this.getViewportWidth(); + var pos = wtOverlays.leftOverlay.getScrollPosition() - wtOverlays.leftOverlay.getTableParentOffset(); + this.columnHeaderHeight = NaN; + + if (pos < 0) { + pos = 0; + } + + var fixedColumnsLeft = wot.getSetting('fixedColumnsLeft'); + + if (fixedColumnsLeft) { + var fixedColumnsWidth = wtOverlays.leftOverlay.sumCellSizes(0, fixedColumnsLeft); + pos += fixedColumnsWidth; + width -= fixedColumnsWidth; + } + + if (wtTable.holder.clientWidth !== wtTable.holder.offsetWidth) { + width -= getScrollbarWidth(rootDocument); + } + + return new ViewportColumnsCalculator({ + viewportSize: width, + scrollOffset: pos, + totalItems: wot.getSetting('totalColumns'), + itemSizeFn: function itemSizeFn(sourceCol) { + return wot.wtTable.getColumnWidth(sourceCol); + }, + overrideFn: wtSettings.settings.viewportColumnCalculatorOverride, + calculationType: calculationType, + stretchMode: wot.getSetting('stretchH'), + stretchingItemWidthFn: function stretchingItemWidthFn(stretchedWidth, column) { + return wot.getSetting('onBeforeStretchingColumnWidth', stretchedWidth, column); + } + }); + } + /** + * Creates rowsRenderCalculator and columnsRenderCalculator (before draw, to determine what rows and + * cols should be rendered). + * + * @param {boolean} fastDraw If `true`, will try to avoid full redraw and only update the border positions. + * If `false` or `undefined`, will perform a full redraw. + * @returns {boolean} The fastDraw value, possibly modified. + */ + + }, { + key: "createRenderCalculators", + value: function createRenderCalculators() { + var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var runFastDraw = fastDraw; + + if (runFastDraw) { + var proposedRowsVisibleCalculator = this.createRowsCalculator(FULLY_VISIBLE_TYPE); + var proposedColumnsVisibleCalculator = this.createColumnsCalculator(FULLY_VISIBLE_TYPE); + + if (!(this.areAllProposedVisibleRowsAlreadyRendered(proposedRowsVisibleCalculator) && this.areAllProposedVisibleColumnsAlreadyRendered(proposedColumnsVisibleCalculator))) { + runFastDraw = false; + } + } + + if (!runFastDraw) { + this.rowsRenderCalculator = this.createRowsCalculator(RENDER_TYPE); + this.columnsRenderCalculator = this.createColumnsCalculator(RENDER_TYPE); + } // delete temporarily to make sure that renderers always use rowsRenderCalculator, not rowsVisibleCalculator + + + this.rowsVisibleCalculator = null; + this.columnsVisibleCalculator = null; + return runFastDraw; + } + /** + * Creates rowsVisibleCalculator and columnsVisibleCalculator (after draw, to determine what are + * the actually fully visible rows and columns). + */ + + }, { + key: "createVisibleCalculators", + value: function createVisibleCalculators() { + this.rowsVisibleCalculator = this.createRowsCalculator(FULLY_VISIBLE_TYPE); + this.columnsVisibleCalculator = this.createColumnsCalculator(FULLY_VISIBLE_TYPE); + } + /** + * Returns information whether proposedRowsVisibleCalculator viewport + * is contained inside rows rendered in previous draw (cached in rowsRenderCalculator). + * + * @param {ViewportRowsCalculator} proposedRowsVisibleCalculator The instance of the viewport calculator to compare with. + * @returns {boolean} Returns `true` if all proposed visible rows are already rendered (meaning: redraw is not needed). + * Returns `false` if at least one proposed visible row is not already rendered (meaning: redraw is needed). + */ + + }, { + key: "areAllProposedVisibleRowsAlreadyRendered", + value: function areAllProposedVisibleRowsAlreadyRendered(proposedRowsVisibleCalculator) { + if (!this.rowsVisibleCalculator) { + return false; + } + + var startRow = proposedRowsVisibleCalculator.startRow, + endRow = proposedRowsVisibleCalculator.endRow; + var _this$rowsRenderCalcu = this.rowsRenderCalculator, + renderedStartRow = _this$rowsRenderCalcu.startRow, + renderedEndRow = _this$rowsRenderCalcu.endRow; + + if (startRow < renderedStartRow || startRow === renderedStartRow && startRow > 0) { + return false; + } else if (endRow > renderedEndRow || endRow === renderedEndRow && endRow < this.wot.getSetting('totalRows') - 1) { + return false; + } + + return true; + } + /** + * Returns information whether proposedColumnsVisibleCalculator viewport + * is contained inside column rendered in previous draw (cached in columnsRenderCalculator). + * + * @param {ViewportRowsCalculator} proposedColumnsVisibleCalculator The instance of the viewport calculator to compare with. + * @returns {boolean} Returns `true` if all proposed visible columns are already rendered (meaning: redraw is not needed). + * Returns `false` if at least one proposed visible column is not already rendered (meaning: redraw is needed). + */ + + }, { + key: "areAllProposedVisibleColumnsAlreadyRendered", + value: function areAllProposedVisibleColumnsAlreadyRendered(proposedColumnsVisibleCalculator) { + if (!this.columnsVisibleCalculator) { + return false; + } + + var startColumn = proposedColumnsVisibleCalculator.startColumn, + endColumn = proposedColumnsVisibleCalculator.endColumn; + var _this$columnsRenderCa = this.columnsRenderCalculator, + renderedStartColumn = _this$columnsRenderCa.startColumn, + renderedEndColumn = _this$columnsRenderCa.endColumn; + + if (startColumn < renderedStartColumn || startColumn === renderedStartColumn && startColumn > 0) { + return false; + } else if (endColumn > renderedEndColumn || endColumn === renderedEndColumn && endColumn < this.wot.getSetting('totalColumns') - 1) { + return false; + } + + return true; + } + /** + * Resets values in keys of the hasOversizedColumnHeadersMarked object after updateSettings. + */ + + }, { + key: "resetHasOversizedColumnHeadersMarked", + value: function resetHasOversizedColumnHeadersMarked() { + objectEach(this.hasOversizedColumnHeadersMarked, function (value, key, object) { + object[key] = void 0; + }); + } + }]); + + return Viewport; +}(); + +function _classCallCheck$F(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$A(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); } } + +function _createClass$A(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$A(Constructor.prototype, protoProps); if (staticProps) _defineProperties$A(Constructor, staticProps); return Constructor; } +/** + * @class Walkontable + */ + +var Walkontable = /*#__PURE__*/function () { + /** + * @param {object} settings The Walkontable settings. + */ + function Walkontable(settings) { + _classCallCheck$F(this, Walkontable); + + var originalHeaders = []; // this is the namespace for global events + + this.guid = "wt_".concat(randomString()); + this.rootDocument = settings.table.ownerDocument; + this.rootWindow = this.rootDocument.defaultView; // bootstrap from settings + + if (settings.cloneSource) { + this.cloneSource = settings.cloneSource; + this.cloneOverlay = settings.cloneOverlay; + this.wtSettings = settings.cloneSource.wtSettings; + this.wtTable = this.cloneOverlay.createTable(this, settings.table); + this.wtScroll = new Scroll(this); + this.wtViewport = settings.cloneSource.wtViewport; + this.wtEvent = new Event$1(this); + this.selections = this.cloneSource.selections; + } else { + this.wtSettings = new Settings(this, settings); + this.wtTable = new MasterTable(this, settings.table); + this.wtScroll = new Scroll(this); + this.wtViewport = new Viewport(this); + this.wtEvent = new Event$1(this); + this.selections = this.getSetting('selections'); + this.wtOverlays = new Overlays(this); + this.exportSettingsAsClassNames(); + } // find original headers + + + if (this.wtTable.THEAD.childNodes.length && this.wtTable.THEAD.childNodes[0].childNodes.length) { + for (var c = 0, clen = this.wtTable.THEAD.childNodes[0].childNodes.length; c < clen; c++) { + originalHeaders.push(this.wtTable.THEAD.childNodes[0].childNodes[c].innerHTML); + } + + if (!this.getSetting('columnHeaders').length) { + this.update('columnHeaders', [function (column, TH) { + fastInnerText(TH, originalHeaders[column]); + }]); + } + } + + this.drawn = false; + this.drawInterrupted = false; + } + /** + * Force rerender of Walkontable. + * + * @param {boolean} [fastDraw=false] When `true`, try to refresh only the positions of borders without rerendering + * the data. It will only work if Table.draw() does not force + * rendering anyway. + * @returns {Walkontable} + */ + + + _createClass$A(Walkontable, [{ + key: "draw", + value: function draw() { + var fastDraw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + this.drawInterrupted = false; + + if (!fastDraw && !this.wtTable.isVisible()) { + // draw interrupted because TABLE is not visible + this.drawInterrupted = true; + } else { + this.wtTable.draw(fastDraw); + } + + return this; + } + /** + * Returns the TD at coords. If topmost is set to true, returns TD from the topmost overlay layer, + * if not set or set to false, returns TD from the master table. + * + * @param {CellCoords} coords The cell coordinates. + * @param {boolean} [topmost=false] If set to `true`, it returns the TD element from the topmost overlay. For example, + * if the wanted cell is in the range of fixed rows, it will return a TD element + * from the top overlay. + * @returns {HTMLElement} + */ + + }, { + key: "getCell", + value: function getCell(coords) { + var topmost = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + if (!topmost) { + return this.wtTable.getCell(coords); + } + + var totalRows = this.wtSettings.getSetting('totalRows'); + var fixedRowsTop = this.wtSettings.getSetting('fixedRowsTop'); + var fixedRowsBottom = this.wtSettings.getSetting('fixedRowsBottom'); + var fixedColumns = this.wtSettings.getSetting('fixedColumnsLeft'); + + if (coords.row < fixedRowsTop && coords.col < fixedColumns) { + return this.wtOverlays.topLeftCornerOverlay.clone.wtTable.getCell(coords); + } else if (coords.row < fixedRowsTop) { + return this.wtOverlays.topOverlay.clone.wtTable.getCell(coords); + } else if (coords.col < fixedColumns && coords.row >= totalRows - fixedRowsBottom) { + if (this.wtOverlays.bottomLeftCornerOverlay && this.wtOverlays.bottomLeftCornerOverlay.clone) { + return this.wtOverlays.bottomLeftCornerOverlay.clone.wtTable.getCell(coords); + } + } else if (coords.col < fixedColumns) { + return this.wtOverlays.leftOverlay.clone.wtTable.getCell(coords); + } else if (coords.row < totalRows && coords.row >= totalRows - fixedRowsBottom) { + if (this.wtOverlays.bottomOverlay && this.wtOverlays.bottomOverlay.clone) { + return this.wtOverlays.bottomOverlay.clone.wtTable.getCell(coords); + } + } + + return this.wtTable.getCell(coords); + } + /** + * @param {object} settings The singular settings to update or if passed as object to merge with. + * @param {*} value The value to set if the first argument is passed as string. + * @returns {Walkontable} + */ + + }, { + key: "update", + value: function update(settings, value) { + return this.wtSettings.update(settings, value); + } + /** + * Scrolls the viewport to a cell (rerenders if needed). + * + * @param {CellCoords} coords The cell coordinates to scroll to. + * @param {boolean} [snapToTop] If `true`, viewport is scrolled to show the cell on the top of the table. + * @param {boolean} [snapToRight] If `true`, viewport is scrolled to show the cell on the right of the table. + * @param {boolean} [snapToBottom] If `true`, viewport is scrolled to show the cell on the bottom of the table. + * @param {boolean} [snapToLeft] If `true`, viewport is scrolled to show the cell on the left of the table. + * @returns {boolean} + */ + + }, { + key: "scrollViewport", + value: function scrollViewport(coords, snapToTop, snapToRight, snapToBottom, snapToLeft) { + if (coords.col < 0 || coords.row < 0) { + return false; + } + + return this.wtScroll.scrollViewport(coords, snapToTop, snapToRight, snapToBottom, snapToLeft); + } + /** + * Scrolls the viewport to a column (rerenders if needed). + * + * @param {number} column Visual column index. + * @param {boolean} [snapToRight] If `true`, viewport is scrolled to show the cell on the right of the table. + * @param {boolean} [snapToLeft] If `true`, viewport is scrolled to show the cell on the left of the table. + * @returns {boolean} + */ + + }, { + key: "scrollViewportHorizontally", + value: function scrollViewportHorizontally(column, snapToRight, snapToLeft) { + if (column < 0) { + return false; + } + + return this.wtScroll.scrollViewportHorizontally(column, snapToRight, snapToLeft); + } + /** + * Scrolls the viewport to a row (rerenders if needed). + * + * @param {number} row Visual row index. + * @param {boolean} [snapToTop] If `true`, viewport is scrolled to show the cell on the top of the table. + * @param {boolean} [snapToBottom] If `true`, viewport is scrolled to show the cell on the bottom of the table. + * @returns {boolean} + */ + + }, { + key: "scrollViewportVertically", + value: function scrollViewportVertically(row, snapToTop, snapToBottom) { + if (row < 0) { + return false; + } + + return this.wtScroll.scrollViewportVertically(row, snapToTop, snapToBottom); + } + /** + * @returns {Array} + */ + + }, { + key: "getViewport", + value: function getViewport() { + return [this.wtTable.getFirstVisibleRow(), this.wtTable.getFirstVisibleColumn(), this.wtTable.getLastVisibleRow(), this.wtTable.getLastVisibleColumn()]; + } + /** + * Get overlay name. + * + * @returns {string} + */ + + }, { + key: "getOverlayName", + value: function getOverlayName() { + return this.cloneOverlay ? this.cloneOverlay.type : 'master'; + } + /** + * Export settings as class names added to the parent element of the table. + */ + + }, { + key: "exportSettingsAsClassNames", + value: function exportSettingsAsClassNames() { + var _this = this; + + var toExport = { + rowHeaders: 'htRowHeaders', + columnHeaders: 'htColumnHeaders' + }; + var allClassNames = []; + var newClassNames = []; + objectEach(toExport, function (className, key) { + if (_this.getSetting(key).length) { + newClassNames.push(className); + } + + allClassNames.push(className); + }); + removeClass(this.wtTable.wtRootElement.parentNode, allClassNames); + addClass(this.wtTable.wtRootElement.parentNode, newClassNames); + } + /** + * Get/Set Walkontable instance setting. + * + * @param {string} key The settings key to retrieve. + * @param {*} [param1] Additional parameter passed to the options defined as function. + * @param {*} [param2] Additional parameter passed to the options defined as function. + * @param {*} [param3] Additional parameter passed to the options defined as function. + * @param {*} [param4] Additional parameter passed to the options defined as function. + * @returns {*} + */ + + }, { + key: "getSetting", + value: function getSetting(key, param1, param2, param3, param4) { + // this is faster than .apply - https://github.com/handsontable/handsontable/wiki/JavaScript-&-DOM-performance-tips + return this.wtSettings.getSetting(key, param1, param2, param3, param4); + } + /** + * Checks if setting exists. + * + * @param {string} key The settings key to check. + * @returns {boolean} + */ + + }, { + key: "hasSetting", + value: function hasSetting(key) { + return this.wtSettings.has(key); + } + /** + * Destroy instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.wtOverlays.destroy(); + this.wtEvent.destroy(); + } + }]); + + return Walkontable; +}(); + +var propertyIsEnumerable = objectPropertyIsEnumerable.f; + +// `Object.{ entries, values }` methods implementation +var createMethod$5 = function (TO_ENTRIES) { + return function (it) { + var O = toIndexedObject(it); + var keys = objectKeys(O); + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!descriptors || propertyIsEnumerable.call(O, key)) { + result.push(TO_ENTRIES ? [key, O[key]] : O[key]); + } + } + return result; + }; +}; + +var objectToArray = { + // `Object.entries` method + // https://tc39.es/ecma262/#sec-object.entries + entries: createMethod$5(true), + // `Object.values` method + // https://tc39.es/ecma262/#sec-object.values + values: createMethod$5(false) +}; + +var $values = objectToArray.values; + +// `Object.values` method +// https://tc39.es/ecma262/#sec-object.values +_export({ target: 'Object', stat: true }, { + values: function values(O) { + return $values(O); + } +}); + +function _slicedToArray$2(arr, i) { return _arrayWithHoles$2(arr) || _iterableToArrayLimit$2(arr, i) || _unsupportedIterableToArray$3(arr, i) || _nonIterableRest$2(); } + +function _nonIterableRest$2() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$3(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$3(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$3(o, minLen); } + +function _arrayLikeToArray$3(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$2(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$2(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof$m(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$m = function _typeof(obj) { return typeof obj; }; } else { _typeof$m = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$m(obj); } + +function _classCallCheck$G(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$B(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); } } + +function _createClass$B(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$B(Constructor.prototype, protoProps); if (staticProps) _defineProperties$B(Constructor, staticProps); return Constructor; } +/** + * @class Selection + */ + +var Selection = /*#__PURE__*/function () { + /** + * @param {object} settings The selection settings object. + * @param {CellRange} cellRange The cell range instance. + */ + function Selection(settings, cellRange) { + _classCallCheck$G(this, Selection); + + this.settings = settings; + this.cellRange = cellRange || null; + this.instanceBorders = {}; + this.classNames = [this.settings.className]; + this.classNameGenerator = this.linearClassNameGenerator(this.settings.className, this.settings.layerLevel); + } + /** + * Each Walkontable clone requires it's own border for every selection. This method creates and returns selection + * borders per instance. + * + * @param {Walkontable} wotInstance The Walkontable instance. + * @returns {Border} + */ + + + _createClass$B(Selection, [{ + key: "getBorder", + value: function getBorder(wotInstance) { + if (!this.instanceBorders[wotInstance.guid]) { + this.instanceBorders[wotInstance.guid] = new Border(wotInstance, this.settings); + } + + return this.instanceBorders[wotInstance.guid]; + } + /** + * Checks if selection is empty. + * + * @returns {boolean} + */ + + }, { + key: "isEmpty", + value: function isEmpty() { + return this.cellRange === null; + } + /** + * Adds a cell coords to the selection. + * + * @param {CellCoords} coords The cell coordinates to add. + * @returns {Selection} + */ + + }, { + key: "add", + value: function add(coords) { + if (this.isEmpty()) { + this.cellRange = new CellRange(coords); + } else { + this.cellRange.expand(coords); + } + + return this; + } + /** + * If selection range from or to property equals oldCoords, replace it with newCoords. Return boolean + * information about success. + * + * @param {CellCoords} oldCoords An old cell coordinates to replace. + * @param {CellCoords} newCoords The new cell coordinates. + * @returns {boolean} + */ + + }, { + key: "replace", + value: function replace(oldCoords, newCoords) { + if (!this.isEmpty()) { + if (this.cellRange.from.isEqual(oldCoords)) { + this.cellRange.from = newCoords; + return true; + } + + if (this.cellRange.to.isEqual(oldCoords)) { + this.cellRange.to = newCoords; + return true; + } + } + + return false; + } + /** + * Clears selection. + * + * @returns {Selection} + */ + + }, { + key: "clear", + value: function clear() { + this.cellRange = null; + return this; + } + /** + * Returns the top left (TL) and bottom right (BR) selection coordinates. + * + * @returns {Array} Returns array of coordinates for example `[1, 1, 5, 5]`. + */ + + }, { + key: "getCorners", + value: function getCorners() { + var topLeft = this.cellRange.getOuterTopLeftCorner(); + var bottomRight = this.cellRange.getOuterBottomRightCorner(); + return [topLeft.row, topLeft.col, bottomRight.row, bottomRight.col]; + } + /** + * Adds class name to cell element at given coords. + * + * @param {Walkontable} wotInstance Walkontable instance. + * @param {number} sourceRow Cell row coord. + * @param {number} sourceColumn Cell column coord. + * @param {string} className Class name. + * @param {boolean} [markIntersections=false] If `true`, linear className generator will be used to add CSS classes + * in a continuous way. + * @returns {Selection} + */ + + }, { + key: "addClassAtCoords", + value: function addClassAtCoords(wotInstance, sourceRow, sourceColumn, className) { + var markIntersections = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; + var TD = wotInstance.wtTable.getCell(new CellCoords(sourceRow, sourceColumn)); + + if (_typeof$m(TD) === 'object') { + var cellClassName = className; + + if (markIntersections) { + cellClassName = this.classNameGenerator(TD); + + if (!this.classNames.includes(cellClassName)) { + this.classNames.push(cellClassName); + } + } + + addClass(TD, cellClassName); + } + + return this; + } + /** + * Generate helper for calculating classNames based on previously added base className. + * The generated className is always generated as a continuation of the previous className. For example, when + * the currently checked element has 'area-2' className the generated new className will be 'area-3'. When + * the element doesn't have any classNames than the base className will be returned ('area');. + * + * @param {string} baseClassName Base className to be used. + * @param {number} layerLevelOwner Layer level which the instance of the Selection belongs to. + * @returns {Function} + */ + + }, { + key: "linearClassNameGenerator", + value: function linearClassNameGenerator(baseClassName, layerLevelOwner) { + // TODO: Make this recursive function Proper Tail Calls (TCO/PTC) friendly. + return function calcClassName(element) { + var previousIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1; + + if (layerLevelOwner === 0 || previousIndex === 0) { + return baseClassName; + } + + var index = previousIndex >= 0 ? previousIndex : layerLevelOwner; + var className = baseClassName; + index -= 1; + var previousClassName = index === 0 ? baseClassName : "".concat(baseClassName, "-").concat(index); + + if (hasClass(element, previousClassName)) { + var currentLayer = index + 1; + className = "".concat(baseClassName, "-").concat(currentLayer); + } else { + className = calcClassName(element, index); + } + + return className; + }; + } + /** + * @param {Walkontable} wotInstance The Walkontable instance. + */ + + }, { + key: "draw", + value: function draw(wotInstance) { + if (this.isEmpty()) { + if (this.settings.border) { + this.getBorder(wotInstance).disappear(); + } + + return; + } + + var renderedRows = wotInstance.wtTable.getRenderedRowsCount(); + var renderedColumns = wotInstance.wtTable.getRenderedColumnsCount(); + var corners = this.getCorners(); + + var _corners = _slicedToArray$2(corners, 4), + topRow = _corners[0], + topColumn = _corners[1], + bottomRow = _corners[2], + bottomColumn = _corners[3]; + + if (topColumn !== null && bottomColumn !== null) { + for (var column = 0; column < renderedColumns; column += 1) { + var sourceCol = wotInstance.wtTable.columnFilter.renderedToSource(column); + + if (sourceCol >= topColumn && sourceCol <= bottomColumn) { + var TH = wotInstance.wtTable.getColumnHeader(sourceCol); + + if (TH) { + var newClasses = []; + + if (this.settings.highlightHeaderClassName) { + newClasses.push(this.settings.highlightHeaderClassName); + } + + if (this.settings.highlightColumnClassName) { + newClasses.push(this.settings.highlightColumnClassName); + } + + addClass(TH, newClasses); + } + } + } + } + + if (topRow !== null && bottomRow !== null) { + for (var row = 0; row < renderedRows; row += 1) { + var sourceRow = wotInstance.wtTable.rowFilter.renderedToSource(row); + + if (sourceRow >= topRow && sourceRow <= bottomRow) { + var _TH = wotInstance.wtTable.getRowHeader(sourceRow); + + if (_TH) { + var _newClasses = []; + + if (this.settings.highlightHeaderClassName) { + _newClasses.push(this.settings.highlightHeaderClassName); + } + + if (this.settings.highlightRowClassName) { + _newClasses.push(this.settings.highlightRowClassName); + } + + addClass(_TH, _newClasses); + } + } + + if (topColumn !== null && bottomColumn !== null) { + for (var _column = 0; _column < renderedColumns; _column += 1) { + var _sourceCol = wotInstance.wtTable.columnFilter.renderedToSource(_column); + + if (sourceRow >= topRow && sourceRow <= bottomRow && _sourceCol >= topColumn && _sourceCol <= bottomColumn) { + // selected cell + if (this.settings.className) { + this.addClassAtCoords(wotInstance, sourceRow, _sourceCol, this.settings.className, this.settings.markIntersections); + } + } else if (sourceRow >= topRow && sourceRow <= bottomRow) { + // selection is in this row + if (this.settings.highlightRowClassName) { + this.addClassAtCoords(wotInstance, sourceRow, _sourceCol, this.settings.highlightRowClassName); + } + } else if (_sourceCol >= topColumn && _sourceCol <= bottomColumn) { + // selection is in this column + if (this.settings.highlightColumnClassName) { + this.addClassAtCoords(wotInstance, sourceRow, _sourceCol, this.settings.highlightColumnClassName); + } + } + + var additionalSelectionClass = wotInstance.getSetting('onAfterDrawSelection', sourceRow, _sourceCol, this.settings.layerLevel); + + if (typeof additionalSelectionClass === 'string') { + this.addClassAtCoords(wotInstance, sourceRow, _sourceCol, additionalSelectionClass); + } + } + } + } + } + + wotInstance.getSetting('onBeforeDrawBorders', corners, this.settings.className); + + if (this.settings.border) { + // warning! border.appear modifies corners! + this.getBorder(wotInstance).appear(corners); + } + } + /** + * Cleans up all the DOM state related to a Selection instance. Call this prior to deleting a Selection instance. + */ + + }, { + key: "destroy", + value: function destroy() { + Object.values(this.instanceBorders).forEach(function (border) { + return border.destroy(); + }); + } + }]); + + return Selection; +}(); + +var _templateObject$2; + +function _classCallCheck$H(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$C(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); } } + +function _createClass$C(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$C(Constructor.prototype, protoProps); if (staticProps) _defineProperties$C(Constructor, staticProps); return Constructor; } + +function _taggedTemplateLiteral$2(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } +/** + * @description + * Handsontable events are the common interface that function in 2 ways: as __callbacks__ and as __hooks__. + * + * @example + * + * ```js + * // Using events as callbacks: + * ... + * const hot1 = new Handsontable(document.getElementById('example1'), { + * afterChange: function(changes, source) { + * $.ajax({ + * url: "save.php', + * data: change + * }); + * } + * }); + * ... + * ``` + * + * ```js + * // Using events as plugin hooks: + * ... + * const hot1 = new Handsontable(document.getElementById('example1'), { + * myPlugin: true + * }); + * + * const hot2 = new Handsontable(document.getElementById('example2'), { + * myPlugin: false + * }); + * + * // global hook + * Handsontable.hooks.add('afterChange', function() { + * // Fired twice - for hot1 and hot2 + * if (this.getSettings().myPlugin) { + * // function body - will only run for hot1 + * } + * }); + * + * // local hook (has same effect as a callback) + * hot2.addHook('afterChange', function() { + * // function body - will only run in #example2 + * }); + * ``` + * ... + */ +// @TODO: Move plugin description hooks to plugin? + +var REGISTERED_HOOKS = [ +/** + * Fired after resetting a cell's meta. This happens when the {@link Core#updateSettings} method is called. + * + * @event Hooks#afterCellMetaReset + */ +'afterCellMetaReset', +/** + * Fired after one or more cells has been changed. The changes are triggered in any situation when the + * value is entered using an editor or changed using API (e.q setDataAtCell). + * + * __Note:__ For performance reasons, the `changes` array is null for `"loadData"` source. + * + * @event Hooks#afterChange + * @param {Array} changes 2D array containing information about each of the edited cells `[[row, prop, oldVal, newVal], ...]`. + * @param {string} [source] String that identifies source of hook call ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + * @example + * ```js + * new Handsontable(element, { + * afterChange: (changes) => { + * changes.forEach(([row, prop, oldValue, newValue]) => { + * // Some logic... + * }); + * } + * }) + * ``` + */ +'afterChange', +/** + * Fired by {@link ObserveChanges} plugin after detecting changes in the data source. This hook is fired when + * {@link Options#observeChanges} option is enabled. + * + * @event Hooks#afterChangesObserved + */ +'afterChangesObserved', +/** + * Fired each time user opens {@link ContextMenu} and after setting up the Context Menu's default options. These options are a collection + * which user can select by setting an array of keys or an array of objects in {@link Options#contextMenu} option. + * + * @event Hooks#afterContextMenuDefaultOptions + * @param {Array} predefinedItems An array of objects containing information about the pre-defined Context Menu items. + */ +'afterContextMenuDefaultOptions', +/** + * Fired each time user opens {@link ContextMenu} plugin before setting up the Context Menu's items but after filtering these options by + * user (`contextMenu` option). This hook can by helpful to determine if user use specified menu item or to set up + * one of the menu item to by always visible. + * + * @event Hooks#beforeContextMenuSetItems + * @param {object[]} menuItems An array of objects containing information about to generated Context Menu items. + */ +'beforeContextMenuSetItems', +/** + * Fired by {@link DropdownMenu} plugin after setting up the Dropdown Menu's default options. These options are a + * collection which user can select by setting an array of keys or an array of objects in {@link Options#dropdownMenu} + * option. + * + * @event Hooks#afterDropdownMenuDefaultOptions + * @param {object[]} predefinedItems An array of objects containing information about the pre-defined Context Menu items. + */ +'afterDropdownMenuDefaultOptions', +/** + * Fired by {@link DropdownMenu} plugin before setting up the Dropdown Menu's items but after filtering these options + * by user (`dropdownMenu` option). This hook can by helpful to determine if user use specified menu item or to set + * up one of the menu item to by always visible. + * + * @event Hooks#beforeDropdownMenuSetItems + * @param {object[]} menuItems An array of objects containing information about to generated Dropdown Menu items. + */ +'beforeDropdownMenuSetItems', +/** + * Fired by {@link ContextMenu} plugin after hiding the Context Menu. This hook is fired when {@link Options#contextMenu} + * option is enabled. + * + * @event Hooks#afterContextMenuHide + * @param {object} context The Context Menu plugin instance. + */ +'afterContextMenuHide', +/** + * Fired by {@link ContextMenu} plugin before opening the Context Menu. This hook is fired when {@link Options#contextMenu} + * option is enabled. + * + * @event Hooks#beforeContextMenuShow + * @param {object} context The Context Menu instance. + */ +'beforeContextMenuShow', +/** + * Fired by {@link ContextMenu} plugin after opening the Context Menu. This hook is fired when {@link Options#contextMenu} + * option is enabled. + * + * @event Hooks#afterContextMenuShow + * @param {object} context The Context Menu plugin instance. + */ +'afterContextMenuShow', +/** + * Fired by {@link CopyPaste} plugin after reaching the copy limit while copying data. This hook is fired when + * {@link Options#copyPaste} option is enabled. + * + * @event Hooks#afterCopyLimit + * @param {number} selectedRows Count of selected copyable rows. + * @param {number} selectedColumns Count of selected copyable columns. + * @param {number} copyRowsLimit Current copy rows limit. + * @param {number} copyColumnsLimit Current copy columns limit. + */ +'afterCopyLimit', +/** + * Fired before created a new column. + * + * @event Hooks#beforeCreateCol + * @param {number} index Represents the visual index of first newly created column in the data source array. + * @param {number} amount Number of newly created columns in the data source array. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link http://docs.handsontable.com/tutorial-using-callbacks.html#page-source-definition}). + * @returns {*} If `false` then creating columns is cancelled. + * @example + * ```js + * // Return `false` to cancel column inserting. + * new Handsontable(element, { + * beforeCreateCol: function(data, coords) { + * return false; + * } + * }); + * ``` + */ +'beforeCreateCol', +/** + * Fired after created a new column. + * + * @event Hooks#afterCreateCol + * @param {number} index Represents the visual index of first newly created column in the data source. + * @param {number} amount Number of newly created columns in the data source. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + */ +'afterCreateCol', +/** + * Fired before created a new row. + * + * @event Hooks#beforeCreateRow + * @param {number} index Represents the visual index of first newly created row in the data source array. + * @param {number} amount Number of newly created rows in the data source array. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + * @returns {*|boolean} If false is returned the action is canceled. + */ +'beforeCreateRow', +/** + * Fired after created a new row. + * + * @event Hooks#afterCreateRow + * @param {number} index Represents the visual index of first newly created row in the data source array. + * @param {number} amount Number of newly created rows in the data source array. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + */ +'afterCreateRow', +/** + * Fired after the current cell is deselected. + * + * @event Hooks#afterDeselect + */ +'afterDeselect', +/** + * Fired after destroying the Handsontable instance. + * + * @event Hooks#afterDestroy + */ +'afterDestroy', +/** + * General hook which captures `keydown` events attached to the document body. These events are delegated to the + * hooks system and consumed by Core and internal modules (e.g plugins, editors). + * + * @event Hooks#afterDocumentKeyDown + * @param {Event} event A native `keydown` event object. + */ +'afterDocumentKeyDown', +/** + * Fired inside the Walkontable's selection `draw` method. Can be used to add additional class names to cells, depending on the current selection. + * + * @event Hooks#afterDrawSelection + * @param {number} currentRow Row index of the currently processed cell. + * @param {number} currentColumn Column index of the currently cell. + * @param {number[]} cornersOfSelection Array of the current selection in a form of `[startRow, startColumn, endRow, endColumn]`. + * @param {number|undefined} layerLevel Number indicating which layer of selection is currently processed. + * @since 0.38.1 + * @returns {string|undefined} Can return a `String`, which will act as an additional `className` to be added to the currently processed cell. + */ +'afterDrawSelection', +/** + * Fired inside the Walkontable's `refreshSelections` method. Can be used to remove additional class names from all cells in the table. + * + * @event Hooks#beforeRemoveCellClassNames + * @since 0.38.1 + * @returns {string[]|undefined} Can return an `Array` of `String`s. Each of these strings will act like class names to be removed from all the cells in the table. + */ +'beforeRemoveCellClassNames', +/** + * Fired after getting the cell settings. + * + * @event Hooks#afterGetCellMeta + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {object} cellProperties Object containing the cell properties. + */ +'afterGetCellMeta', +/** + * Fired after retrieving information about a column header and appending it to the table header. + * + * @event Hooks#afterGetColHeader + * @param {number} column Visual column index. + * @param {HTMLTableCellElement} TH Header's TH element. + */ +'afterGetColHeader', +/** + * Fired after retrieving information about a row header and appending it to the table header. + * + * @event Hooks#afterGetRowHeader + * @param {number} row Visual row index. + * @param {HTMLTableCellElement} TH Header's TH element. + */ +'afterGetRowHeader', +/** + * Fired after the Handsontable instance is initiated. + * + * @event Hooks#afterInit + */ +'afterInit', +/** + * Fired after new data is loaded (by `loadData` or `updateSettings` method) into the data source array. + * + * @event Hooks#afterLoadData + * @param {Array} sourceData Array of arrays or array of objects containing data. + * @param {boolean} initialLoad Flag that determines whether the data has been loaded during the initialization. + */ +'afterLoadData', +/** + * Fired after a scroll event, which is identified as a momentum scroll (e.g. On an iPad). + * + * @event Hooks#afterMomentumScroll + */ +'afterMomentumScroll', +/** + * Fired after a `mousedown` event is triggered on the cell corner (the drag handle). + * + * @event Hooks#afterOnCellCornerMouseDown + * @param {Event} event `mousedown` event object. + */ +'afterOnCellCornerMouseDown', +/** + * Fired after a `dblclick` event is triggered on the cell corner (the drag handle). + * + * @event Hooks#afterOnCellCornerDblClick + * @param {Event} event `dblclick` event object. + */ +'afterOnCellCornerDblClick', +/** + * Fired after clicking on a cell or row/column header. In case the row/column header was clicked, the coordinate + * indexes are negative. + * + * For example clicking on the row header of cell (0, 0) results with `afterOnCellMouseDown` called + * with coordinates `{row: 0, col: -1}`. + * + * @event Hooks#afterOnCellMouseDown + * @param {Event} event `mousedown` event object. + * @param {CellCoords} coords Coordinates object containing the visual row and visual column indexes of the clicked cell. + * @param {HTMLTableCellElement} TD Cell's TD (or TH) element. + */ +'afterOnCellMouseDown', +/** + * Fired after clicking on a cell or row/column header. In case the row/column header was clicked, the coordinate + * indexes are negative. + * + * For example clicking on the row header of cell (0, 0) results with `afterOnCellMouseUp` called + * with coordinates `{row: 0, col: -1}`. + * + * @event Hooks#afterOnCellMouseUp + * @param {Event} event `mouseup` event object. + * @param {CellCoords} coords Coordinates object containing the visual row and visual column indexes of the clicked cell. + * @param {HTMLTableCellElement} TD Cell's TD (or TH) element. + */ +'afterOnCellMouseUp', +/** + * Fired after clicking right mouse button on a cell or row/column header. + * + * For example clicking on the row header of cell (0, 0) results with `afterOnCellContextMenu` called + * with coordinates `{row: 0, col: -1}`. + * + * @event Hooks#afterOnCellContextMenu + * @since 4.1.0 + * @param {Event} event `contextmenu` event object. + * @param {CellCoords} coords Coordinates object containing the visual row and visual column indexes of the clicked cell. + * @param {HTMLTableCellElement} TD Cell's TD (or TH) element. + */ +'afterOnCellContextMenu', +/** + * Fired after hovering a cell or row/column header with the mouse cursor. In case the row/column header was + * hovered, the index is negative. + * + * For example, hovering over the row header of cell (0, 0) results with `afterOnCellMouseOver` called + * with coords `{row: 0, col: -1}`. + * + * @event Hooks#afterOnCellMouseOver + * @param {Event} event `mouseover` event object. + * @param {CellCoords} coords Hovered cell's visual coordinate object. + * @param {HTMLTableCellElement} TD Cell's TD (or TH) element. + */ +'afterOnCellMouseOver', +/** + * Fired after leaving a cell or row/column header with the mouse cursor. + * + * @event Hooks#afterOnCellMouseOut + * @param {Event} event `mouseout` event object. + * @param {CellCoords} coords Leaved cell's visual coordinate object. + * @param {HTMLTableCellElement} TD Cell's TD (or TH) element. + */ +'afterOnCellMouseOut', +/** + * Fired after one or more columns are removed. + * + * @event Hooks#afterRemoveCol + * @param {number} index Visual index of starter column. + * @param {number} amount An amount of removed columns. + * @param {number[]} physicalColumns An array of physical columns removed from the data source. + * @param {string} [source] String that identifies source of hook call ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + */ +'afterRemoveCol', +/** + * Fired after one or more rows are removed. + * + * @event Hooks#afterRemoveRow + * @param {number} index Visual index of starter row. + * @param {number} amount An amount of removed rows. + * @param {number[]} physicalRows An array of physical rows removed from the data source. + * @param {string} [source] String that identifies source of hook call ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + */ +'afterRemoveRow', +/** + * Fired after the Handsontable table is rendered. + * + * @event Hooks#afterRender + * @param {boolean} isForced Is `true` if rendering was triggered by a change of settings or data; or `false` if + * rendering was triggered by scrolling or moving selection. + */ +'afterRender', +/** + * Fired before starting rendering the cell. + * + * @event Hooks#beforeRenderer + * @param {HTMLTableCellElement} TD Currently rendered cell's TD element. + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string|number} prop Column property name or a column index, if datasource is an array of arrays. + * @param {*} value Value of the rendered cell. + * @param {object} cellProperties Object containing the cell's properties. + */ +'beforeRenderer', +/** + * Fired after finishing rendering the cell (after the renderer finishes). + * + * @event Hooks#afterRenderer + * @param {HTMLTableCellElement} TD Currently rendered cell's TD element. + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string|number} prop Column property name or a column index, if datasource is an array of arrays. + * @param {*} value Value of the rendered cell. + * @param {object} cellProperties Object containing the cell's properties. + */ +'afterRenderer', +/** + * Fired after the horizontal scroll event. + * + * @event Hooks#afterScrollHorizontally + */ +'afterScrollHorizontally', +/** + * Fired after the vertical scroll event. + * + * @event Hooks#afterScrollVertically + */ +'afterScrollVertically', +/** + * Fired after one or more cells are selected (e.g. During mouse move). + * + * @event Hooks#afterSelection + * @param {number} row Selection start visual row index. + * @param {number} column Selection start visual column index. + * @param {number} row2 Selection end visual row index. + * @param {number} column2 Selection end visual column index. + * @param {object} preventScrolling Object with `value` property where its value change will be observed. + * @param {number} selectionLayerLevel The number which indicates what selection layer is currently modified. + * @example + * ```js + * new Handsontable(element, { + * afterSelection: (row, column, row2, column2, preventScrolling, selectionLayerLevel) => { + * // setting if prevent scrolling after selection + * preventScrolling.value = true; + * } + * }) + * ``` + */ +'afterSelection', +/** + * Fired after one or more cells are selected. + * + * The `prop` and `prop2` arguments represent the source object property name instead of the column number. + * + * @event Hooks#afterSelectionByProp + * @param {number} row Selection start visual row index. + * @param {string} prop Selection start data source object property name. + * @param {number} row2 Selection end visual row index. + * @param {string} prop2 Selection end data source object property name. + * @param {object} preventScrolling Object with `value` property where its value change will be observed. + * @param {number} selectionLayerLevel The number which indicates what selection layer is currently modified. + * @example + * ```js + * new Handsontable(element, { + * afterSelectionByProp: (row, column, row2, column2, preventScrolling, selectionLayerLevel) => { + * // setting if prevent scrolling after selection + * preventScrolling.value = true; + * } + * }) + * ``` + */ +'afterSelectionByProp', +/** + * Fired after one or more cells are selected (e.g. On mouse up). + * + * @event Hooks#afterSelectionEnd + * @param {number} row Selection start visual row index. + * @param {number} column Selection start visual column index. + * @param {number} row2 Selection end visual row index. + * @param {number} column2 Selection end visual column index. + * @param {number} selectionLayerLevel The number which indicates what selection layer is currently modified. + */ +'afterSelectionEnd', +/** + * Fired after one or more cells are selected (e.g. On mouse up). + * + * The `prop` and `prop2` arguments represent the source object property name instead of the column number. + * + * @event Hooks#afterSelectionEndByProp + * @param {number} row Selection start visual row index. + * @param {string} prop Selection start data source object property index. + * @param {number} row2 Selection end visual row index. + * @param {string} prop2 Selection end data source object property index. + * @param {number} selectionLayerLevel The number which indicates what selection layer is currently modified. + */ +'afterSelectionEndByProp', +/** + * Fired after cell meta is changed. + * + * @event Hooks#afterSetCellMeta + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string} key The updated meta key. + * @param {*} value The updated meta value. + */ +'afterSetCellMeta', +/** + * Fired after cell meta is removed. + * + * @event Hooks#afterRemoveCellMeta + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string} key The removed meta key. + * @param {*} value Value which was under removed key of cell meta. + */ +'afterRemoveCellMeta', +/** + * Fired after cell data was changed. + * + * @event Hooks#afterSetDataAtCell + * @param {Array} changes An array of changes in format `[[row, column, oldValue, value], ...]`. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + */ +'afterSetDataAtCell', +/** + * Fired after cell data was changed. + * Called only when `setDataAtRowProp` was executed. + * + * @event Hooks#afterSetDataAtRowProp + * @param {Array} changes An array of changes in format `[[row, prop, oldValue, value], ...]`. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + */ +'afterSetDataAtRowProp', +/** + * Fired after cell source data was changed. + * + * @event Hooks#afterSetSourceDataAtCell + * @since 8.0.0 + * @param {Array} changes An array of changes in format `[[row, column, oldValue, value], ...]`. + * @param {string} [source] String that identifies source of hook call. + */ +'afterSetSourceDataAtCell', +/** + * Fired after calling the `updateSettings` method. + * + * @event Hooks#afterUpdateSettings + * @param {object} newSettings New settings object. + */ +'afterUpdateSettings', +/** + * @description + * A plugin hook executed after validator function, only if validator function is defined. + * Validation result is the first parameter. This can be used to determinate if validation passed successfully or not. + * + * __Returning false from the callback will mark the cell as invalid__. + * + * @event Hooks#afterValidate + * @param {boolean} isValid `true` if valid, `false` if not. + * @param {*} value The value in question. + * @param {number} row Visual row index. + * @param {string|number} prop Property name / visual column index. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + * @returns {void | boolean} If `false` the cell will be marked as invalid, `true` otherwise. + */ +'afterValidate', +/** + * Fired before successful change of language (when proper language code was set). + * + * @event Hooks#beforeLanguageChange + * @since 0.35.0 + * @param {string} languageCode New language code. + */ +'beforeLanguageChange', +/** + * Fired after successful change of language (when proper language code was set). + * + * @event Hooks#afterLanguageChange + * @since 0.35.0 + * @param {string} languageCode New language code. + */ +'afterLanguageChange', +/** + * Fired by {@link Autofill} plugin before populating the data in the autofill feature. This hook is fired when + * {@link Options#fillHandle} option is enabled. + * + * @event Hooks#beforeAutofill + * @param {CellCoords} start Object containing information about first filled cell: `{row: 2, col: 0}`. + * @param {CellCoords} end Object containing information about last filled cell: `{row: 4, col: 1}`. + * @param {Array[]} data 2D array containing information about fill pattern: `[["1", "Ted"], ["1", "John"]]`. + * @returns {*|boolean} If false is returned the action is canceled. + */ +'beforeAutofill', +/** + * Fired by {@link Autofill} plugin after populating the data in the autofill feature. This hook is fired when + * {@link Options#fillHandle} option is enabled. + * + * @event Hooks#afterAutofill + * @since 8.0.0 + * @param {CellCoords} start Object containing information about first filled cell: `{row: 2, col: 0}`. + * @param {CellCoords} end Object containing information about last filled cell: `{row: 4, col: 1}`. + * @param {Array[]} data 2D array containing information about fill pattern: `[["1", "Ted"], ["1", "John"]]`. + */ +'afterAutofill', +/** + * Fired before aligning the cell contents. + * + * @event Hooks#beforeCellAlignment + * @param {object} stateBefore An object with class names defining the cell alignment. + * @param {CellRange[]} range An array of CellRange coordinates where the alignment will be applied. + * @param {string} type Type of the alignment - either `horizontal` or `vertical`. + * @param {string} alignmentClass String defining the alignment class added to the cell. + * Possible values: + * * `htLeft` + * * `htCenter` + * * `htRight` + * * `htJustify` + * * `htTop` + * * `htMiddle` + * * `htBottom`. + */ +'beforeCellAlignment', +/** + * Fired before one or more cells is changed. Its main purpose is to alter changes silently after input and before + * table rendering. + * + * @event Hooks#beforeChange + * @param {Array[]} changes 2D array containing information about each of the edited cells. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + * @returns {void | boolean} If `false` all changes were cancelled, `true` otherwise. + * @example + * ```js + * // To disregard a single change, set changes[i] to null or remove it from array using changes.splice(i, 1). + * new Handsontable(element, { + * beforeChange: (changes, source) => { + * // [[row, prop, oldVal, newVal], ...] + * changes[0] = null; + * } + * }); + * // To alter a single change, overwrite the desired value to changes[i][3]. + * new Handsontable(element, { + * beforeChange: (changes, source) => { + * // [[row, prop, oldVal, newVal], ...] + * changes[0][3] = 10; + * } + * }); + * // To cancel all edit, return false from the callback or set array length to 0 (changes.length = 0). + * new Handsontable(element, { + * beforeChange: (changes, source) => { + * // [[row, prop, oldVal, newVal], ...] + * return false; + * } + * }); + * ``` + */ +'beforeChange', +/** + * Fired right before rendering the changes. + * + * @event Hooks#beforeChangeRender + * @param {Array[]} changes Array in form of `[row, prop, oldValue, newValue]`. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + */ +'beforeChangeRender', +/** + * Fired before drawing the borders. + * + * @event Hooks#beforeDrawBorders + * @param {Array} corners Array specifying the current selection borders. + * @param {string} borderClassName Specifies the border class name. + */ +'beforeDrawBorders', +/** + * Fired before getting cell settings. + * + * @event Hooks#beforeGetCellMeta + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {object} cellProperties Object containing the cell's properties. + */ +'beforeGetCellMeta', +/** + * Fired before cell meta is removed. + * + * @event Hooks#beforeRemoveCellMeta + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string} key The removed meta key. + * @param {*} value Value which is under removed key of cell meta. + * @returns {*|boolean} If false is returned the action is canceled. + */ +'beforeRemoveCellMeta', +/** + * Fired before the Handsontable instance is initiated. + * + * @event Hooks#beforeInit + */ +'beforeInit', +/** + * Fired before the Walkontable instance is initiated. + * + * @event Hooks#beforeInitWalkontable + * @param {object} walkontableConfig Walkontable configuration object. + */ +'beforeInitWalkontable', +/** + * Fired before new data is loaded (by `loadData` or `updateSettings` method) into the data source array. + * + * @event Hooks#beforeLoadData + * @since 8.0.0 + * @param {Array} sourceData Array of arrays or array of objects containing data. + * @param {boolean} initialLoad Flag that determines whether the data has been loaded during the initialization. + */ +'beforeLoadData', +/** + * Fired before keydown event is handled. It can be used to overwrite default key bindings. + * + * __Note__: To prevent default behavior you need to call `event.stopImmediatePropagation()` in your `beforeKeyDown` + * handler. + * + * @event Hooks#beforeKeyDown + * @param {Event} event Original DOM event. + */ +'beforeKeyDown', +/** + * Fired after the user clicked a cell, but before all the calculations related with it. + * + * @event Hooks#beforeOnCellMouseDown + * @param {Event} event The `mousedown` event object. + * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell. + * @param {HTMLTableCellElement} TD TD element. + * @param {object} controller An object with keys `row`, `column` and `cells` which contains boolean values. This + * object allows or disallows changing the selection for the particular axies. + */ +'beforeOnCellMouseDown', +/** + * Fired after the user clicked a cell. + * + * @event Hooks#beforeOnCellMouseUp + * @param {Event} event The `mouseup` event object. + * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell. + * @param {HTMLTableCellElement} TD TD element. + */ +'beforeOnCellMouseUp', +/** + * Fired after the user clicked a cell, but before all the calculations related with it. + * + * @event Hooks#beforeOnCellContextMenu + * @since 4.1.0 + * @param {Event} event The `contextmenu` event object. + * @param {CellCoords} coords Cell coords object containing the visual coordinates of the clicked cell. + * @param {HTMLTableCellElement} TD TD element. + */ +'beforeOnCellContextMenu', +/** + * Fired after the user moved cursor over a cell, but before all the calculations related with it. + * + * @event Hooks#beforeOnCellMouseOver + * @param {Event} event The `mouseover` event object. + * @param {CellCoords} coords CellCoords object containing the visual coordinates of the clicked cell. + * @param {HTMLTableCellElement} TD TD element. + * @param {object} controller An object with keys `row`, `column` and `cells` which contains boolean values. This + * object allows or disallows changing the selection for the particular axies. + */ +'beforeOnCellMouseOver', +/** + * Fired after the user moved cursor out from a cell, but before all the calculations related with it. + * + * @event Hooks#beforeOnCellMouseOut + * @param {Event} event The `mouseout` event object. + * @param {CellCoords} coords CellCoords object containing the visual coordinates of the leaved cell. + * @param {HTMLTableCellElement} TD TD element. + */ +'beforeOnCellMouseOut', +/** + * Fired before one or more columns are about to be removed. + * + * @event Hooks#beforeRemoveCol + * @param {number} index Visual index of starter column. + * @param {number} amount Amount of columns to be removed. + * @param {number[]} physicalColumns An array of physical columns removed from the data source. + * @param {string} [source] String that identifies source of hook call ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + * @returns {*|boolean} If false is returned the action is canceled. + */ +'beforeRemoveCol', +/** + * Fired when one or more rows are about to be removed. + * + * @event Hooks#beforeRemoveRow + * @param {number} index Visual index of starter row. + * @param {number} amount Amount of rows to be removed. + * @param {number[]} physicalRows An array of physical rows removed from the data source. + * @param {string} [source] String that identifies source of hook call ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + * @returns {*|boolean} If false is returned the action is canceled. + */ +'beforeRemoveRow', +/** + * Fired before the Handsontable table is rendered. + * + * @event Hooks#beforeRender + * @param {boolean} isForced If `true` rendering was triggered by a change of settings or data; or `false` if + * rendering was triggered by scrolling or moving selection. + * @param {object} skipRender Object with `skipRender` property, if it is set to `true ` the next rendering cycle will be skipped. + */ +'beforeRender', +/** + * Fired before cell meta is changed. + * + * @event Hooks#beforeSetCellMeta + * @since 8.0.0 + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string} key The updated meta key. + * @param {*} value The updated meta value. + * @returns {*|boolean} If false is returned the action is canceled. + */ +'beforeSetCellMeta', +/** + * Fired before setting range is started but not finished yet. + * + * @event Hooks#beforeSetRangeStartOnly + * @param {CellCoords} coords CellCoords instance. + */ +'beforeSetRangeStartOnly', +/** + * Fired before setting range is started. + * + * @event Hooks#beforeSetRangeStart + * @param {CellCoords} coords CellCoords instance. + */ +'beforeSetRangeStart', +/** + * Fired before setting range is ended. + * + * @event Hooks#beforeSetRangeEnd + * @param {CellCoords} coords CellCoords instance. + */ +'beforeSetRangeEnd', +/** + * Fired before the logic of handling a touch scroll, when user started scrolling on a touch-enabled device. + * + * @event Hooks#beforeTouchScroll + */ +'beforeTouchScroll', +/** + * Fired before cell validation, only if validator function is defined. This can be used to manipulate the value + * of changed cell before it is applied to the validator function. + * + * __Note:__ this will not affect values of changes. This will change value *ONLY* for validation. + * + * @event Hooks#beforeValidate + * @param {*} value Value of the cell. + * @param {number} row Visual row index. + * @param {string|number} prop Property name / column index. + * @param {string} [source] String that identifies source of hook call + * ([list of all available sources]{@link https://handsontable.com/docs/tutorial-using-callbacks.html#page-source-definition}). + */ +'beforeValidate', +/** + * Fired before cell value is rendered into the DOM (through renderer function). This can be used to manipulate the + * value which is passed to the renderer without modifying the renderer itself. + * + * @event Hooks#beforeValueRender + * @param {*} value Cell value to render. + * @param {object} cellProperties An object containing the cell properties. + */ +'beforeValueRender', +/** + * Fired after Handsontable instance is constructed (using `new` operator). + * + * @event Hooks#construct + */ +'construct', +/** + * Fired after Handsontable instance is initiated but before table is rendered. + * + * @event Hooks#init + */ +'init', +/** + * Fired when a column header index is about to be modified by a callback function. + * + * @event Hooks#modifyColHeader + * @param {number} column Visual column header index. + */ +'modifyColHeader', +/** + * Fired when a column width is about to be modified by a callback function. + * + * @event Hooks#modifyColWidth + * @param {number} width Current column width. + * @param {number} column Visual column index. + */ +'modifyColWidth', +/** + * Fired when a row header index is about to be modified by a callback function. + * + * @event Hooks#modifyRowHeader + * @param {number} row Visual row header index. + */ +'modifyRowHeader', +/** + * Fired when a row height is about to be modified by a callback function. + * + * @event Hooks#modifyRowHeight + * @param {number} height Row height. + * @param {number} row Visual row index. + */ +'modifyRowHeight', +/** + * Fired when a data was retrieved or modified. + * + * @event Hooks#modifyData + * @param {number} row Physical row height. + * @param {number} column Physical column index. + * @param {object} valueHolder Object which contains original value which can be modified by overwriting `.value` property. + * @param {string} ioMode String which indicates for what operation hook is fired (`get` or `set`). + */ +'modifyData', +/** + * Fired when a data was retrieved or modified from the source data set. + * + * @event Hooks#modifySourceData + * @since 8.0.0 + * @param {number} row Physical row index. + * @param {number} column Physical column index. + * @param {object} valueHolder Object which contains original value which can be modified by overwriting `.value` property. + * @param {string} ioMode String which indicates for what operation hook is fired (`get` or `set`). + */ +'modifySourceData', +/** + * Fired when a data was retrieved or modified. + * + * @event Hooks#modifyRowData + * @param {number} row Physical row index. + */ +'modifyRowData', +/** + * Used to modify the cell coordinates when using the `getCell` method, opening editor, getting value from the editor + * and saving values from the closed editor. + * + * @event Hooks#modifyGetCellCoords + * @since 0.36.0 + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {boolean} topmost If set to `true`, it returns the TD element from the topmost overlay. For example, + * if the wanted cell is in the range of fixed rows, it will return a TD element + * from the `top` overlay. + */ +'modifyGetCellCoords', +/** + * Fired by {@link PersistentState} plugin, after loading value, saved under given key, from browser local storage. This hook is fired when + * {@link Options#persistentState} option is enabled. + * + * @event Hooks#persistentStateLoad + * @param {string} key Key. + * @param {object} valuePlaceholder Object containing the loaded value under `valuePlaceholder.value` (if no value have been saved, `value` key will be undefined). + */ +'persistentStateLoad', +/** + * Fired by {@link PersistentState} plugin after resetting data from local storage. If no key is given, all values associated with table will be cleared. + * This hook is fired when {@link Options#persistentState} option is enabled. + * + * @event Hooks#persistentStateReset + * @param {string} [key] Key. + */ +'persistentStateReset', +/** + * Fired by {@link PersistentState} plugin, after saving value under given key in browser local storage. This hook is fired when + * {@link Options#persistentState} option is enabled. + * + * @event Hooks#persistentStateSave + * @param {string} key Key. + * @param {Mixed} value Value to save. + */ +'persistentStateSave', +/** + * Fired by {@link ColumnSorting} and {@link MultiColumnSorting} plugins before sorting the column. If you return `false` value inside callback for hook, then sorting + * will be not applied by the Handsontable (useful for server-side sorting). + * + * This hook is fired when {@link Options#columnSorting} or {@link Options#multiColumnSorting} option is enabled. + * + * @event Hooks#beforeColumnSort + * @param {Array} currentSortConfig Current sort configuration (for all sorted columns). + * @param {Array} destinationSortConfigs Destination sort configuration (for all sorted columns). + * @returns {boolean | void} If `false` the column will not be sorted, `true` otherwise. + */ +'beforeColumnSort', +/** + * Fired by {@link ColumnSorting} and {@link MultiColumnSorting} plugins after sorting the column. This hook is fired when {@link Options#columnSorting} + * or {@link Options#multiColumnSorting} option is enabled. + * + * @event Hooks#afterColumnSort + * @param {Array} currentSortConfig Current sort configuration (for all sorted columns). + * @param {Array} destinationSortConfigs Destination sort configuration (for all sorted columns). + */ +'afterColumnSort', +/** + * Fired by {@link Autofill} plugin after setting range of autofill. This hook is fired when {@link Options#fillHandle} + * option is enabled. + * + * @event Hooks#modifyAutofillRange + * @param {Array} startArea Array of visual coordinates of the starting point for the drag-down operation (`[startRow, startColumn, endRow, endColumn]`). + * @param {Array} entireArea Array of visual coordinates of the entire area of the drag-down operation (`[startRow, startColumn, endRow, endColumn]`). + */ +'modifyAutofillRange', +/** + * Fired to allow modifying the copyable range with a callback function. + * + * @event Hooks#modifyCopyableRange + * @param {Array[]} copyableRanges Array of objects defining copyable cells. + */ +'modifyCopyableRange', +/** + * Fired by {@link CopyPaste} plugin before copying the values into clipboard and before clearing values of + * the selected cells. This hook is fired when {@link Options#copyPaste} option is enabled. + * + * @event Hooks#beforeCut + * @param {Array[]} data An array of arrays which contains data to cut. + * @param {object[]} coords An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`) + * which will be cut out. + * @returns {*} If returns `false` then operation of the cutting out is canceled. + * @example + * ```js + * // To disregard a single row, remove it from the array using data.splice(i, 1). + * new Handsontable(element, { + * beforeCut: function(data, coords) { + * // data -> [[1, 2, 3], [4, 5, 6]] + * data.splice(0, 1); + * // data -> [[4, 5, 6]] + * // coords -> [{startRow: 0, startCol: 0, endRow: 1, endCol: 2}] + * } + * }); + * // To cancel a cutting action, just return `false`. + * new Handsontable(element, { + * beforeCut: function(data, coords) { + * return false; + * } + * }); + * ``` + */ +'beforeCut', +/** + * Fired by {@link CopyPaste} plugin after data was cut out from the table. This hook is fired when + * {@link Options#copyPaste} option is enabled. + * + * @event Hooks#afterCut + * @param {Array[]} data An array of arrays which contains the cutted out data. + * @param {object[]} coords An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`) + * which was cut out. + */ +'afterCut', +/** + * Fired before values are copied into clipboard. + * + * @event Hooks#beforeCopy + * @param {Array[]} data An array of arrays which contains data to copied. + * @param {object[]} coords An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`) + * which will copied. + * @returns {*} If returns `false` then copying is canceled. + * + * @example + * ```js + * // To disregard a single row, remove it from array using data.splice(i, 1). + * ... + * new Handsontable(document.getElementById('example'), { + * beforeCopy: (data, coords) => { + * // data -> [[1, 2, 3], [4, 5, 6]] + * data.splice(0, 1); + * // data -> [[4, 5, 6]] + * // coords -> [{startRow: 0, startCol: 0, endRow: 1, endCol: 2}] + * } + * }); + * ... + * + * // To cancel copying, return false from the callback. + * ... + * new Handsontable(document.getElementById('example'), { + * beforeCopy: (data, coords) => { + * return false; + * } + * }); + * ... + * ``` + */ +'beforeCopy', +/** + * Fired by {@link CopyPaste} plugin after data are pasted into table. This hook is fired when {@link Options#copyPaste} + * option is enabled. + * + * @event Hooks#afterCopy + * @param {Array[]} data An array of arrays which contains the copied data. + * @param {object[]} coords An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`) + * which was copied. + */ +'afterCopy', +/** + * Fired by {@link CopyPaste} plugin before values are pasted into table. This hook is fired when + * {@link Options#copyPaste} option is enabled. + * + * @event Hooks#beforePaste + * @param {Array[]} data An array of arrays which contains data to paste. + * @param {object[]} coords An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`) + * that correspond to the previously selected area. + * @returns {*} If returns `false` then pasting is canceled. + * @example + * ```js + * // To disregard a single row, remove it from array using data.splice(i, 1). + * new Handsontable(example, { + * beforePaste: (data, coords) => { + * // data -> [[1, 2, 3], [4, 5, 6]] + * data.splice(0, 1); + * // data -> [[4, 5, 6]] + * // coords -> [{startRow: 0, startCol: 0, endRow: 1, endCol: 2}] + * } + * }); + * // To cancel pasting, return false from the callback. + * new Handsontable(example, { + * beforePaste: (data, coords) => { + * return false; + * } + * }); + * ``` + */ +'beforePaste', +/** + * Fired by {@link CopyPaste} plugin after values are pasted into table. This hook is fired when + * {@link Options#copyPaste} option is enabled. + * + * @event Hooks#afterPaste + * @param {Array[]} data An array of arrays which contains the pasted data. + * @param {object[]} coords An array of objects with ranges of the visual indexes (`startRow`, `startCol`, `endRow`, `endCol`) + * that correspond to the previously selected area. + */ +'afterPaste', +/** + * Fired by {@link ManualColumnMove} plugin before change order of the visual indexes. This hook is fired when + * {@link Options#manualColumnMove} option is enabled. + * + * @event Hooks#beforeColumnMove + * @param {Array} movedColumns Array of visual column indexes to be moved. + * @param {number} finalIndex Visual column index, being a start index for the moved columns. Points to where the elements will be placed after the moving action. To check visualization of final index please take a look at [documentation](/docs/demo-moving.html). + * @param {number|undefined} dropIndex Visual column index, being a drop index for the moved columns. Points to where we are going to drop the moved elements. To check visualization of drop index please take a look at [documentation](/docs/demo-moving.html). It's `undefined` when `dragColumns` function wasn't called. + * @param {boolean} movePossible Indicates if it's possible to move rows to the desired position. + * @returns {void | boolean} If `false` the column will not be moved, `true` otherwise. + */ +'beforeColumnMove', +/** + * Fired by {@link ManualColumnMove} plugin after changing order of the visual indexes. This hook is fired when + * {@link Options#manualColumnMove} option is enabled. + * + * @event Hooks#afterColumnMove + * @param {Array} movedColumns Array of visual column indexes to be moved. + * @param {number} finalIndex Visual column index, being a start index for the moved columns. Points to where the elements will be placed after the moving action. To check visualization of final index please take a look at [documentation](/docs/demo-moving.html). + * @param {number|undefined} dropIndex Visual column index, being a drop index for the moved columns. Points to where we are going to drop the moved elements. To check visualization of drop index please take a look at [documentation](/docs/demo-moving.html). It's `undefined` when `dragColumns` function wasn't called. + * @param {boolean} movePossible Indicates if it was possible to move columns to the desired position. + * @param {boolean} orderChanged Indicates if order of columns was changed by move. + */ +'afterColumnMove', +/** + * Fired by {@link ManualRowMove} plugin before changing the order of the visual indexes. This hook is fired when + * {@link Options#manualRowMove} option is enabled. + * + * @event Hooks#beforeRowMove + * @param {Array} movedRows Array of visual row indexes to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements will be placed after the moving action. To check visualization of final index please take a look at [documentation](/docs/demo-moving.html). + * @param {number|undefined} dropIndex Visual row index, being a drop index for the moved rows. Points to where we are going to drop the moved elements. To check visualization of drop index please take a look at [documentation](/docs/demo-moving.html). It's `undefined` when `dragRows` function wasn't called. + * @param {boolean} movePossible Indicates if it's possible to move rows to the desired position. + * @returns {*|boolean} If false is returned the action is canceled. + */ +'beforeRowMove', +/** + * Fired by {@link ManualRowMove} plugin after changing the order of the visual indexes. This hook is fired when + * {@link Options#manualRowMove} option is enabled. + * + * @event Hooks#afterRowMove + * @param {Array} movedRows Array of visual row indexes to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements will be placed after the moving action. To check visualization of final index please take a look at [documentation](/docs/demo-moving.html). + * @param {number|undefined} dropIndex Visual row index, being a drop index for the moved rows. Points to where we are going to drop the moved elements. To check visualization of drop index please take a look at [documentation](/docs/demo-moving.html). It's `undefined` when `dragRows` function wasn't called. + * @param {boolean} movePossible Indicates if it was possible to move rows to the desired position. + * @param {boolean} orderChanged Indicates if order of rows was changed by move. + */ +'afterRowMove', +/** + * Fired by {@link ManualColumnResize} plugin before rendering the table with modified column sizes. This hook is + * fired when {@link Options#manualColumnResize} option is enabled. + * + * @event Hooks#beforeColumnResize + * @param {number} newSize Calculated new column width. + * @param {number} column Visual index of the resized column. + * @param {boolean} isDoubleClick Flag that determines whether there was a double-click. + * @returns {number} Returns a new column size or `undefined`, if column size should be calculated automatically. + */ +'beforeColumnResize', +/** + * Fired by {@link ManualColumnResize} plugin after rendering the table with modified column sizes. This hook is + * fired when {@link Options#manualColumnResize} option is enabled. + * + * @event Hooks#afterColumnResize + * @param {number} newSize Calculated new column width. + * @param {number} column Visual index of the resized column. + * @param {boolean} isDoubleClick Flag that determines whether there was a double-click. + */ +'afterColumnResize', +/** + * Fired by {@link ManualRowResize} plugin before rendering the table with modified row sizes. This hook is + * fired when {@link Options#manualRowResize} option is enabled. + * + * @event Hooks#beforeRowResize + * @param {number} newSize Calculated new row height. + * @param {number} row Visual index of the resized row. + * @param {boolean} isDoubleClick Flag that determines whether there was a double-click. + * @returns {number} Returns the new row size or `undefined` if row size should be calculated automatically. + */ +'beforeRowResize', +/** + * Fired by {@link ManualRowResize} plugin after rendering the table with modified row sizes. This hook is + * fired when {@link Options#manualRowResize} option is enabled. + * + * @event Hooks#afterRowResize + * @param {number} newSize Calculated new row height. + * @param {number} row Visual index of the resized row. + * @param {boolean} isDoubleClick Flag that determines whether there was a double-click. + */ +'afterRowResize', +/** + * Fired after getting the column header renderers. + * + * @event Hooks#afterGetColumnHeaderRenderers + * @param {Function[]} renderers An array of the column header renderers. + */ +'afterGetColumnHeaderRenderers', +/** + * Fired after getting the row header renderers. + * + * @event Hooks#afterGetRowHeaderRenderers + * @param {Function[]} renderers An array of the row header renderers. + */ +'afterGetRowHeaderRenderers', +/** + * Fired before applying stretched column width to column. + * + * @event Hooks#beforeStretchingColumnWidth + * @param {number} stretchedWidth Calculated width. + * @param {number} column Visual column index. + * @returns {number} Returns new width which will be applied to the column element. + */ +'beforeStretchingColumnWidth', +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * Fired by {@link Filters} plugin before applying [filtering]{@link https://handsontable.com/docs/demo-filtering.html}. This hook is fired when + * {@link Options#filters} option is enabled. + * + * @event Hooks#beforeFilter + * @param {object[]} conditionsStack An array of objects with added formulas. + * ```js + * // Example format of the conditionsStack argument: + * [ + * { + * column: 2, + * conditions: [ + * {name: 'begins_with', args: [['S']]} + * ], + * operation: 'conjunction' + * }, + * { + * column: 4, + * conditions: [ + * {name: 'not_empty', args: []} + * ], + * operation: 'conjunction' + * }, + * ] + * ``` + * @returns {boolean} If hook returns `false` value then filtering won't be applied on the UI side (server-side filtering). + */ +'beforeFilter', +/* eslint-enable jsdoc/require-description-complete-sentence */ + +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * Fired by {@link Filters} plugin after applying [filtering]{@link https://handsontable.com/docs/demo-filtering.html}. This hook is fired when + * {@link Options#filters} option is enabled. + * + * @event Hooks#afterFilter + * @param {object[]} conditionsStack An array of objects with added conditions. + * ```js + * // Example format of the conditionsStack argument: + * [ + * { + * column: 2, + * conditions: [ + * {name: 'begins_with', args: [['S']]} + * ], + * operation: 'conjunction' + * }, + * { + * column: 4, + * conditions: [ + * {name: 'not_empty', args: []} + * ], + * operation: 'conjunction' + * }, + * ] + * ``` + */ +'afterFilter', +/* eslint-enable jsdoc/require-description-complete-sentence */ + +/** + * Fired while retrieving the column header height. + * + * @event Hooks#modifyColumnHeaderHeight + */ +'modifyColumnHeaderHeight', +/** + * Fired by {@link UndoRedo} plugin before the undo action. Contains information about the action that is being undone. + * This hook is fired when {@link Options#undo} option is enabled. + * + * @event Hooks#beforeUndo + * @param {object} action The action object. Contains information about the action being undone. The `actionType` + * property of the object specifies the type of the action in a String format. (e.g. `'remove_row'`). + * @returns {*|boolean} If false is returned the action is canceled. + */ +'beforeUndo', +/** + * Fired by {@link UndoRedo} plugin after the undo action. Contains information about the action that is being undone. + * This hook is fired when {@link Options#undo} option is enabled. + * + * @event Hooks#afterUndo + * @param {object} action The action object. Contains information about the action being undone. The `actionType` + * property of the object specifies the type of the action in a String format. (e.g. `'remove_row'`). + */ +'afterUndo', +/** + * Fired by {@link UndoRedo} plugin before the redo action. Contains information about the action that is being redone. + * This hook is fired when {@link Options#undo} option is enabled. + * + * @event Hooks#beforeRedo + * @param {object} action The action object. Contains information about the action being redone. The `actionType` + * property of the object specifies the type of the action in a String format (e.g. `'remove_row'`). + * @returns {*|boolean} If false is returned the action is canceled. + */ +'beforeRedo', +/** + * Fired by {@link UndoRedo} plugin after the redo action. Contains information about the action that is being redone. + * This hook is fired when {@link Options#undo} option is enabled. + * + * @event Hooks#afterRedo + * @param {object} action The action object. Contains information about the action being redone. The `actionType` + * property of the object specifies the type of the action in a String format (e.g. `'remove_row'`). + */ +'afterRedo', +/** + * Fired while retrieving the row header width. + * + * @event Hooks#modifyRowHeaderWidth + * @param {number} rowHeaderWidth Row header width. + */ +'modifyRowHeaderWidth', +/** + * Fired from the `populateFromArray` method during the `autofill` process. Fired for each "autofilled" cell individually. + * + * @event Hooks#beforeAutofillInsidePopulate + * @param {object} index Object containing `row` and `col` properties, defining the number of rows/columns from the initial cell of the autofill. + * @param {string} direction Declares the direction of the autofill. Possible values: `up`, `down`, `left`, `right`. + * @param {Array[]} input Contains an array of rows with data being used in the autofill. + * @param {Array} deltas The deltas array passed to the `populateFromArray` method. + */ +'beforeAutofillInsidePopulate', +/** + * Fired when the start of the selection is being modified (e.g. Moving the selection with the arrow keys). + * + * @event Hooks#modifyTransformStart + * @param {CellCoords} delta Cell coords object declaring the delta of the new selection relative to the previous one. + */ +'modifyTransformStart', +/** + * Fired when the end of the selection is being modified (e.g. Moving the selection with the arrow keys). + * + * @event Hooks#modifyTransformEnd + * @param {CellCoords} delta Cell coords object declaring the delta of the new selection relative to the previous one. + */ +'modifyTransformEnd', +/** + * Fired after the start of the selection is being modified (e.g. Moving the selection with the arrow keys). + * + * @event Hooks#afterModifyTransformStart + * @param {CellCoords} coords Coords of the freshly selected cell. + * @param {number} rowTransformDir `-1` if trying to select a cell with a negative row index. `0` otherwise. + * @param {number} colTransformDir `-1` if trying to select a cell with a negative column index. `0` otherwise. + */ +'afterModifyTransformStart', +/** + * Fired after the end of the selection is being modified (e.g. Moving the selection with the arrow keys). + * + * @event Hooks#afterModifyTransformEnd + * @param {CellCoords} coords Visual coords of the freshly selected cell. + * @param {number} rowTransformDir `-1` if trying to select a cell with a negative row index. `0` otherwise. + * @param {number} colTransformDir `-1` if trying to select a cell with a negative column index. `0` otherwise. + */ +'afterModifyTransformEnd', +/** + * Fired inside the `viewportRowCalculatorOverride` method. Allows modifying the row calculator parameters. + * + * @event Hooks#afterViewportRowCalculatorOverride + * @param {object} calc The row calculator. + */ +'afterViewportRowCalculatorOverride', +/** + * Fired inside the `viewportColumnCalculatorOverride` method. Allows modifying the row calculator parameters. + * + * @event Hooks#afterViewportColumnCalculatorOverride + * @param {object} calc The row calculator. + */ +'afterViewportColumnCalculatorOverride', +/** + * Fired after initializing all the plugins. + * This hook should be added before Handsontable is initialized. + * + * @event Hooks#afterPluginsInitialized + * + * @example + * ```js + * Handsontable.hooks.add('afterPluginsInitialized', myCallback); + * ``` + */ +'afterPluginsInitialized', +/** + * Fired by {@link HiddenRows} plugin before marking the rows as hidden. Fired only if the {@link Options#hiddenRows} option is enabled. + * Returning `false` in the callback will prevent the hiding action from completing. + * + * @event Hooks#beforeHideRows + * @param {Array} currentHideConfig Current hide configuration - a list of hidden physical row indexes. + * @param {Array} destinationHideConfig Destination hide configuration - a list of hidden physical row indexes. + * @param {boolean} actionPossible `true`, if provided row indexes are valid, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the hiding action will not be completed. + */ +'beforeHideRows', +/** + * Fired by {@link HiddenRows} plugin after marking the rows as hidden. Fired only if the {@link Options#hiddenRows} option is enabled. + * + * @event Hooks#afterHideRows + * @param {Array} currentHideConfig Current hide configuration - a list of hidden physical row indexes. + * @param {Array} destinationHideConfig Destination hide configuration - a list of hidden physical row indexes. + * @param {boolean} actionPossible `true`, if provided row indexes are valid, `false` otherwise. + * @param {boolean} stateChanged `true`, if the action affected any non-hidden rows, `false` otherwise. + */ +'afterHideRows', +/** + * Fired by {@link HiddenRows} plugin before marking the rows as not hidden. Fired only if the {@link Options#hiddenRows} option is enabled. + * Returning `false` in the callback will prevent the row revealing action from completing. + * + * @event Hooks#beforeUnhideRows + * @param {Array} currentHideConfig Current hide configuration - a list of hidden physical row indexes. + * @param {Array} destinationHideConfig Destination hide configuration - a list of hidden physical row indexes. + * @param {boolean} actionPossible `true`, if provided row indexes are valid, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the revealing action will not be completed. + */ +'beforeUnhideRows', +/** + * Fired by {@link HiddenRows} plugin after marking the rows as not hidden. Fired only if the {@link Options#hiddenRows} option is enabled. + * + * @event Hooks#afterUnhideRows + * @param {Array} currentHideConfig Current hide configuration - a list of hidden physical row indexes. + * @param {Array} destinationHideConfig Destination hide configuration - a list of hidden physical row indexes. + * @param {boolean} actionPossible `true`, if provided row indexes are valid, `false` otherwise. + * @param {boolean} stateChanged `true`, if the action affected any hidden rows, `false` otherwise. + */ +'afterUnhideRows', +/** + * Fired by {@link HiddenColumns} plugin before marking the columns as hidden. Fired only if the {@link Options#hiddenColumns} option is enabled. + * Returning `false` in the callback will prevent the hiding action from completing. + * + * @event Hooks#beforeHideColumns + * @param {Array} currentHideConfig Current hide configuration - a list of hidden physical column indexes. + * @param {Array} destinationHideConfig Destination hide configuration - a list of hidden physical column indexes. + * @param {boolean} actionPossible `true`, if the provided column indexes are valid, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the hiding action will not be completed. + */ +'beforeHideColumns', +/** + * Fired by {@link HiddenColumns} plugin after marking the columns as hidden. Fired only if the {@link Options#hiddenColumns} option is enabled. + * + * @event Hooks#afterHideColumns + * @param {Array} currentHideConfig Current hide configuration - a list of hidden physical column indexes. + * @param {Array} destinationHideConfig Destination hide configuration - a list of hidden physical column indexes. + * @param {boolean} actionPossible `true`, if the provided column indexes are valid, `false` otherwise. + * @param {boolean} stateChanged `true`, if the action affected any non-hidden columns, `false` otherwise. + */ +'afterHideColumns', +/** + * Fired by {@link HiddenColumns} plugin before marking the columns as not hidden. Fired only if the {@link Options#hiddenColumns} option is enabled. + * Returning `false` in the callback will prevent the column revealing action from completing. + * + * @event Hooks#beforeUnhideColumns + * @param {Array} currentHideConfig Current hide configuration - a list of hidden physical column indexes. + * @param {Array} destinationHideConfig Destination hide configuration - a list of hidden physical column indexes. + * @param {boolean} actionPossible `true`, if the provided column indexes are valid, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the hiding action will not be completed. + */ +'beforeUnhideColumns', +/** + * Fired by {@link HiddenColumns} plugin after marking the columns as not hidden. Fired only if the {@link Options#hiddenColumns} option is enabled. + * + * @event Hooks#afterUnhideColumns + * @param {Array} currentHideConfig Current hide configuration - a list of hidden physical column indexes. + * @param {Array} destinationHideConfig Destination hide configuration - a list of hidden physical column indexes. + * @param {boolean} actionPossible `true`, if the provided column indexes are valid, `false` otherwise. + * @param {boolean} stateChanged `true`, if the action affected any hidden columns, `false` otherwise. + */ +'afterUnhideColumns', +/** + * Fired by {@link TrimRows} plugin before trimming rows. This hook is fired when {@link Options#trimRows} option is enabled. + * + * @event Hooks#beforeTrimRow + * @param {Array} currentTrimConfig Current trim configuration - a list of trimmed physical row indexes. + * @param {Array} destinationTrimConfig Destination trim configuration - a list of trimmed physical row indexes. + * @param {boolean} actionPossible `true`, if all of the row indexes are withing the bounds of the table, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the trimming action will not be completed. + */ +'beforeTrimRow', +/** + * Fired by {@link TrimRows} plugin after trimming rows. This hook is fired when {@link Options#trimRows} option is enabled. + * + * @event Hooks#afterTrimRow + * @param {Array} currentTrimConfig Current trim configuration - a list of trimmed physical row indexes. + * @param {Array} destinationTrimConfig Destination trim configuration - a list of trimmed physical row indexes. + * @param {boolean} actionPossible `true`, if all of the row indexes are withing the bounds of the table, `false` otherwise. + * @param {boolean} stateChanged `true`, if the action affected any non-trimmed rows, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the trimming action will not be completed. + */ +'afterTrimRow', +/** + * Fired by {@link TrimRows} plugin before untrimming rows. This hook is fired when {@link Options#trimRows} option is enabled. + * + * @event Hooks#beforeUntrimRow + * @param {Array} currentTrimConfig Current trim configuration - a list of trimmed physical row indexes. + * @param {Array} destinationTrimConfig Destination trim configuration - a list of trimmed physical row indexes. + * @param {boolean} actionPossible `true`, if all of the row indexes are withing the bounds of the table, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the untrimming action will not be completed. + */ +'beforeUntrimRow', +/** + * Fired by {@link TrimRows} plugin after untrimming rows. This hook is fired when {@link Options#trimRows} option is enabled. + * + * @event Hooks#afterUntrimRow + * @param {Array} currentTrimConfig Current trim configuration - a list of trimmed physical row indexes. + * @param {Array} destinationTrimConfig Destination trim configuration - a list of trimmed physical row indexes. + * @param {boolean} actionPossible `true`, if all of the row indexes are withing the bounds of the table, `false` otherwise. + * @param {boolean} stateChanged `true`, if the action affected any trimmed rows, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the untrimming action will not be completed. + */ +'afterUntrimRow', +/** + * Fired by {@link DropdownMenu} plugin before opening the dropdown menu. This hook is fired when {@link Options#dropdownMenu} + * option is enabled. + * + * @event Hooks#beforeDropdownMenuShow + * @param {DropdownMenu} dropdownMenu The DropdownMenu instance. + */ +'beforeDropdownMenuShow', +/** + * Fired by {@link DropdownMenu} plugin after opening the Dropdown Menu. This hook is fired when {@link Options#dropdownMenu} + * option is enabled. + * + * @event Hooks#afterDropdownMenuShow + * @param {DropdownMenu} dropdownMenu The DropdownMenu instance. + */ +'afterDropdownMenuShow', +/** + * Fired by {@link DropdownMenu} plugin after hiding the Dropdown Menu. This hook is fired when {@link Options#dropdownMenu} + * option is enabled. + * + * @event Hooks#afterDropdownMenuHide + * @param {DropdownMenu} instance The DropdownMenu instance. + */ +'afterDropdownMenuHide', +/** + * Fired by {@link NestedRows} plugin before adding a children to the NestedRows structure. This hook is fired when + * {@link Options#nestedRows} option is enabled. + * + * @event Hooks#beforeAddChild + * @param {object} parent The parent object. + * @param {object|undefined} element The element added as a child. If `undefined`, a blank child was added. + * @param {number|undefined} index The index within the parent where the new child was added. If `undefined`, the element was added as the last child. + */ +'beforeAddChild', +/** + * Fired by {@link NestedRows} plugin after adding a children to the NestedRows structure. This hook is fired when + * {@link Options#nestedRows} option is enabled. + * + * @event Hooks#afterAddChild + * @param {object} parent The parent object. + * @param {object|undefined} element The element added as a child. If `undefined`, a blank child was added. + * @param {number|undefined} index The index within the parent where the new child was added. If `undefined`, the element was added as the last child. + */ +'afterAddChild', +/** + * Fired by {@link NestedRows} plugin before detaching a child from its parent. This hook is fired when + * {@link Options#nestedRows} option is enabled. + * + * @event Hooks#beforeDetachChild + * @param {object} parent An object representing the parent from which the element is to be detached. + * @param {object} element The detached element. + */ +'beforeDetachChild', +/** + * Fired by {@link NestedRows} plugin after detaching a child from its parent. This hook is fired when + * {@link Options#nestedRows} option is enabled. + * + * @event Hooks#afterDetachChild + * @param {object} parent An object representing the parent from which the element was detached. + * @param {object} element The detached element. + */ +'afterDetachChild', +/** + * Fired after the editor is opened and rendered. + * + * @event Hooks#afterBeginEditing + * @param {number} row Visual row index of the edited cell. + * @param {number} column Visual column index of the edited cell. + */ +'afterBeginEditing', +/** + * Fired by {@link MergeCells} plugin before cell merging. This hook is fired when {@link Options#mergeCells} + * option is enabled. + * + * @event Hooks#beforeMergeCells + * @param {CellRange} cellRange Selection cell range. + * @param {boolean} [auto=false] `true` if called automatically by the plugin. + */ +'beforeMergeCells', +/** + * Fired by {@link MergeCells} plugin after cell merging. This hook is fired when {@link Options#mergeCells} + * option is enabled. + * + * @event Hooks#afterMergeCells + * @param {CellRange} cellRange Selection cell range. + * @param {object} mergeParent The parent collection of the provided cell range. + * @param {boolean} [auto=false] `true` if called automatically by the plugin. + */ +'afterMergeCells', +/** + * Fired by {@link MergeCells} plugin before unmerging the cells. This hook is fired when {@link Options#mergeCells} + * option is enabled. + * + * @event Hooks#beforeUnmergeCells + * @param {CellRange} cellRange Selection cell range. + * @param {boolean} [auto=false] `true` if called automatically by the plugin. + */ +'beforeUnmergeCells', +/** + * Fired by {@link MergeCells} plugin after unmerging the cells. This hook is fired when {@link Options#mergeCells} + * option is enabled. + * + * @event Hooks#afterUnmergeCells + * @param {CellRange} cellRange Selection cell range. + * @param {boolean} [auto=false] `true` if called automatically by the plugin. + */ +'afterUnmergeCells', +/** + * Fired after the table was switched into listening mode. This allows Handsontable to capture keyboard events and + * respond in the right way. + * + * @event Hooks#afterListen + */ +'afterListen', +/** + * Fired after the table was switched off from the listening mode. This makes the Handsontable inert for any + * keyboard events. + * + * @event Hooks#afterUnlisten + */ +'afterUnlisten', +/** + * Fired after the window was resized. + * + * @event Hooks#afterRefreshDimensions + * @param {object} previousDimensions Previous dimensions of the container. + * @param {object} currentDimensions Current dimensions of the container. + * @param {boolean} stateChanged `true`, if the container was re-render, `false` otherwise. + */ +'afterRefreshDimensions', +/** + * Cancellable hook, called after resizing a window, but before redrawing a table. + * + * @event Hooks#beforeRefreshDimensions + * @param {object} previousDimensions Previous dimensions of the container. + * @param {object} currentDimensions Current dimensions of the container. + * @param {boolean} actionPossible `true`, if current and previous dimensions are different, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the refresh action will not be completed. + */ +'beforeRefreshDimensions', +/** + * Fired by {@link CollapsibleColumns} plugin before columns collapse. This hook is fired when {@link Options#collapsibleColumns} option is enabled. + * + * @event Hooks#beforeColumnCollapse + * @since 8.0.0 + * @param {Array} currentCollapsedColumns Current collapsible configuration - a list of collapsible physical column indexes. + * @param {Array} destinationCollapsedColumns Destination collapsible configuration - a list of collapsible physical column indexes. + * @param {boolean} collapsePossible `true`, if all of the column indexes are withing the bounds of the collapsed sections, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the collapsing action will not be completed. + */ +'beforeColumnCollapse', +/** + * Fired by {@link CollapsibleColumns} plugin before columns collapse. This hook is fired when {@link Options#collapsibleColumns} option is enabled. + * + * @event Hooks#afterColumnCollapse + * @since 8.0.0 + * @param {Array} currentCollapsedColumns Current collapsible configuration - a list of collapsible physical column indexes. + * @param {Array} destinationCollapsedColumns Destination collapsible configuration - a list of collapsible physical column indexes. + * @param {boolean} collapsePossible `true`, if all of the column indexes are withing the bounds of the collapsed sections, `false` otherwise. + * @param {boolean} successfullyCollapsed `true`, if the action affected any non-collapsible column, `false` otherwise. + */ +'afterColumnCollapse', +/** + * Fired by {@link CollapsibleColumns} plugin before columns expand. This hook is fired when {@link Options#collapsibleColumns} option is enabled. + * + * @event Hooks#beforeColumnExpand + * @since 8.0.0 + * @param {Array} currentCollapsedColumns Current collapsible configuration - a list of collapsible physical column indexes. + * @param {Array} destinationCollapsedColumns Destination collapsible configuration - a list of collapsible physical column indexes. + * @param {boolean} expandPossible `true`, if all of the column indexes are withing the bounds of the collapsed sections, `false` otherwise. + * @returns {undefined|boolean} If the callback returns `false`, the expanding action will not be completed. + */ +'beforeColumnExpand', +/** + * Fired by {@link CollapsibleColumns} plugin before columns expand. This hook is fired when {@link Options#collapsibleColumns} option is enabled. + * + * @event Hooks#afterColumnExpand + * @since 8.0.0 + * @param {Array} currentCollapsedColumns Current collapsible configuration - a list of collapsible physical column indexes. + * @param {Array} destinationCollapsedColumns Destination collapsible configuration - a list of collapsible physical column indexes. + * @param {boolean} expandPossible `true`, if all of the column indexes are withing the bounds of the collapsed sections, `false` otherwise. + * @param {boolean} successfullyExpanded `true`, if the action affected any non-collapsible column, `false` otherwise. + */ +'afterColumnExpand']; +/** + * Template warning message for removed hooks. + * + * @type {string} + */ + +var REMOVED_MESSAGE = toSingleLine(_templateObject$2 || (_templateObject$2 = _taggedTemplateLiteral$2(["The plugin hook \"[hookName]\" was removed in Handsontable [removedInVersion]. \n Please consult release notes https://github.com/handsontable/handsontable/releases/tag/[removedInVersion] to \n learn about the migration path."], ["The plugin hook \"[hookName]\" was removed in Handsontable [removedInVersion].\\x20\n Please consult release notes https://github.com/handsontable/handsontable/releases/tag/[removedInVersion] to\\x20\n learn about the migration path."]))); +/** + * The list of the hooks which are removed from the API. The warning message is printed out in + * the developer console when the hook is used. + * + * The Map key is represented by hook name and its value points to the Handsontable version + * in which it was removed. + * + * @type {Map} + */ + +var REMOVED_HOOKS = new Map([['modifyRow', '8.0.0'], ['modifyCol', '8.0.0'], ['unmodifyRow', '8.0.0'], ['unmodifyCol', '8.0.0'], ['skipLengthCache', '8.0.0'], ['hiddenColumn', '8.0.0'], ['hiddenRow', '8.0.0']]); +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * The list of the hooks which are deprecated. The warning message is printed out in + * the developer console when the hook is used. + * + * The Map key is represented by hook name and its value keeps message which whould be + * printed out when the hook is used. + * + * Usage: + * ```js + * ... + * New Map([ + * ['beforeColumnExpand', 'The plugin hook "beforeColumnExpand" is deprecated. Use "beforeColumnExpand2" instead.'], + * ]) + * ... + * ``` + * + * + * @type {Map} + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var DEPRECATED_HOOKS = new Map([]); + +var Hooks = /*#__PURE__*/function () { + /** + * + */ + function Hooks() { + _classCallCheck$H(this, Hooks); + + this.globalBucket = this.createEmptyBucket(); + } + /** + * Returns a new object with empty handlers related to every registered hook name. + * + * @returns {object} The empty bucket object. + * + * @example + * ```js + * Handsontable.hooks.createEmptyBucket(); + * // Results: + * { + * ... + * afterCreateCol: [], + * afterCreateRow: [], + * beforeInit: [], + * ... + * } + * ``` + */ + + + _createClass$C(Hooks, [{ + key: "createEmptyBucket", + value: function createEmptyBucket() { + var bucket = Object.create(null); // eslint-disable-next-line no-return-assign + + arrayEach(REGISTERED_HOOKS, function (hook) { + return bucket[hook] = []; + }); + return bucket; + } + /** + * Get hook bucket based on the context of the object or if argument is `undefined`, get the global hook bucket. + * + * @param {object} [context=null] A Handsontable instance. + * @returns {object} Returns a global or Handsontable instance bucket. + */ + + }, { + key: "getBucket", + value: function getBucket() { + var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + if (context) { + if (!context.pluginHookBucket) { + context.pluginHookBucket = this.createEmptyBucket(); + } + + return context.pluginHookBucket; + } + + return this.globalBucket; + } + /** + * Adds a listener (globally or locally) to a specified hook name. + * If the `context` parameter is provided, the hook will be added only to the instance it references. + * Otherwise, the callback will be used everytime the hook fires on any Handsontable instance. + * You can provide an array of callback functions as the `callback` argument, this way they will all be fired + * once the hook is triggered. + * + * @see Core#addHook + * @param {string} key Hook name. + * @param {Function|Array} callback Callback function or an array of functions. + * @param {object} [context=null] The context for the hook callback to be added - a Handsontable instance or leave empty. + * @returns {Hooks} Instance of Hooks. + * + * @example + * ```js + * // single callback, added locally + * Handsontable.hooks.add('beforeInit', myCallback, hotInstance); + * + * // single callback, added globally + * Handsontable.hooks.add('beforeInit', myCallback); + * + * // multiple callbacks, added locally + * Handsontable.hooks.add('beforeInit', [myCallback, anotherCallback], hotInstance); + * + * // multiple callbacks, added globally + * Handsontable.hooks.add('beforeInit', [myCallback, anotherCallback]); + * ``` + */ + + }, { + key: "add", + value: function add(key, callback) { + var _this = this; + + var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; + + if (Array.isArray(callback)) { + arrayEach(callback, function (c) { + return _this.add(key, c, context); + }); + } else { + if (REMOVED_HOOKS.has(key)) { + warn(substitute(REMOVED_MESSAGE, { + hookName: key, + removedInVersion: REMOVED_HOOKS.get(key) + })); + } + + if (DEPRECATED_HOOKS.has(key)) { + warn(DEPRECATED_HOOKS.get(key)); + } + + var bucket = this.getBucket(context); + + if (typeof bucket[key] === 'undefined') { + this.register(key); + bucket[key] = []; + } + + callback.skip = false; + + if (bucket[key].indexOf(callback) === -1) { + // only add a hook if it has not already been added (adding the same hook twice is now silently ignored) + var foundInitialHook = false; + + if (callback.initialHook) { + arrayEach(bucket[key], function (cb, i) { + if (cb.initialHook) { + bucket[key][i] = callback; + foundInitialHook = true; + return false; + } + }); + } + + if (!foundInitialHook) { + bucket[key].push(callback); + } + } + } + + return this; + } + /** + * Adds a listener to a specified hook. After the hook runs this listener will be automatically removed from the bucket. + * + * @see Core#addHookOnce + * @param {string} key Hook/Event name. + * @param {Function|Array} callback Callback function. + * @param {object} [context=null] A Handsontable instance. + * + * @example + * ```js + * Handsontable.hooks.once('beforeInit', myCallback, hotInstance); + * ``` + */ + + }, { + key: "once", + value: function once(key, callback) { + var _this2 = this; + + var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; + + if (Array.isArray(callback)) { + arrayEach(callback, function (c) { + return _this2.once(key, c, context); + }); + } else { + callback.runOnce = true; + this.add(key, callback, context); + } + } + /** + * Removes a listener from a hook with a given name. If the `context` argument is provided, it removes a listener from a local hook assigned to the given Handsontable instance. + * + * @see Core#removeHook + * @param {string} key Hook/Event name. + * @param {Function} callback Callback function (needs the be the function that was previously added to the hook). + * @param {object} [context=null] Handsontable instance. + * @returns {boolean} Returns `true` if hook was removed, `false` otherwise. + * + * @example + * ```js + * Handsontable.hooks.remove('beforeInit', myCallback); + * ``` + */ + + }, { + key: "remove", + value: function remove(key, callback) { + var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; + var bucket = this.getBucket(context); + + if (typeof bucket[key] !== 'undefined') { + if (bucket[key].indexOf(callback) >= 0) { + callback.skip = true; + return true; + } + } + + return false; + } + /** + * Checks whether there are any registered listeners for the provided hook name. + * If the `context` parameter is provided, it only checks for listeners assigned to the given Handsontable instance. + * + * @param {string} key Hook name. + * @param {object} [context=null] A Handsontable instance. + * @returns {boolean} `true` for success, `false` otherwise. + */ + + }, { + key: "has", + value: function has(key) { + var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var bucket = this.getBucket(context); + return !!(bucket[key] !== void 0 && bucket[key].length); + } + /** + * Runs all local and global callbacks assigned to the hook identified by the `key` parameter. + * It returns either a return value from the last called callback or the first parameter (`p1`) passed to the `run` function. + * + * @see Core#runHooks + * @param {object} context Handsontable instance. + * @param {string} key Hook/Event name. + * @param {*} [p1] Parameter to be passed as an argument to the callback function. + * @param {*} [p2] Parameter to be passed as an argument to the callback function. + * @param {*} [p3] Parameter to be passed as an argument to the callback function. + * @param {*} [p4] Parameter to be passed as an argument to the callback function. + * @param {*} [p5] Parameter to be passed as an argument to the callback function. + * @param {*} [p6] Parameter to be passed as an argument to the callback function. + * @returns {*} Either a return value from the last called callback or `p1`. + * + * @example + * ```js + * Handsontable.hooks.run(hot, 'beforeInit'); + * ``` + */ + + }, { + key: "run", + value: function run(context, key, p1, p2, p3, p4, p5, p6) { + { + var globalHandlers = this.globalBucket[key]; + var length = globalHandlers ? globalHandlers.length : 0; + var index = 0; + + if (length) { + // Do not optimise this loop with arrayEach or arrow function! If you do You'll decrease perf because of GC. + while (index < length) { + if (!globalHandlers[index] || globalHandlers[index].skip) { + index += 1; + /* eslint-disable no-continue */ + + continue; + } // performance considerations - http://jsperf.com/call-vs-apply-for-a-plugin-architecture + + + var res = globalHandlers[index].call(context, p1, p2, p3, p4, p5, p6); + + if (res !== void 0) { + // eslint-disable-next-line no-param-reassign + p1 = res; + } + + if (globalHandlers[index] && globalHandlers[index].runOnce) { + this.remove(key, globalHandlers[index]); + } + + index += 1; + } + } + } + { + var localHandlers = this.getBucket(context)[key]; + + var _length = localHandlers ? localHandlers.length : 0; + + var _index = 0; + + if (_length) { + // Do not optimise this loop with arrayEach or arrow function! If you do You'll decrease perf because of GC. + while (_index < _length) { + if (!localHandlers[_index] || localHandlers[_index].skip) { + _index += 1; + /* eslint-disable no-continue */ + + continue; + } // performance considerations - http://jsperf.com/call-vs-apply-for-a-plugin-architecture + + + var _res = localHandlers[_index].call(context, p1, p2, p3, p4, p5, p6); + + if (_res !== void 0) { + // eslint-disable-next-line no-param-reassign + p1 = _res; + } + + if (localHandlers[_index] && localHandlers[_index].runOnce) { + this.remove(key, localHandlers[_index], context); + } + + _index += 1; + } + } + } + return p1; + } + /** + * Destroy all listeners connected to the context. If no context is provided, the global listeners will be destroyed. + * + * @param {object} [context=null] A Handsontable instance. + * @example + * ```js + * // destroy the global listeners + * Handsontable.hooks.destroy(); + * + * // destroy the local listeners + * Handsontable.hooks.destroy(hotInstance); + * ``` + */ + + }, { + key: "destroy", + value: function destroy() { + var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + // eslint-disable-next-line no-return-assign + objectEach(this.getBucket(context), function (value, key, bucket) { + return bucket[key].length = 0; + }); + } + /** + * Registers a hook name (adds it to the list of the known hook names). Used by plugins. + * It is not necessary to call register, but if you use it, your plugin hook will be used returned by + * the `getRegistered` method. (which itself is used in the demo https://handsontable.com/docs/tutorial-using-callbacks.html). + * + * @param {string} key The hook name. + * + * @example + * ```js + * Handsontable.hooks.register('myHook'); + * ``` + */ + + }, { + key: "register", + value: function register(key) { + if (!this.isRegistered(key)) { + REGISTERED_HOOKS.push(key); + } + } + /** + * Deregisters a hook name (removes it from the list of known hook names). + * + * @param {string} key The hook name. + * + * @example + * ```js + * Handsontable.hooks.deregister('myHook'); + * ``` + */ + + }, { + key: "deregister", + value: function deregister(key) { + if (this.isRegistered(key)) { + REGISTERED_HOOKS.splice(REGISTERED_HOOKS.indexOf(key), 1); + } + } + /** + * Returns a boolean value depending on if a hook by such name has been removed or deprecated. + * + * @param {string} hookName The hook name to check. + * @returns {boolean} Returns `true` if the provided hook name was marked as deprecated or + * removed from API, `false` otherwise. + * @example + * ```js + * Handsontable.hooks.isDeprecated('skipLengthCache'); + * + * // Results: + * true + * ``` + */ + + }, { + key: "isDeprecated", + value: function isDeprecated(hookName) { + return DEPRECATED_HOOKS.has(hookName) || REMOVED_HOOKS.has(hookName); + } + /** + * Returns a boolean depending on if a hook by such name has been registered. + * + * @param {string} hookName The hook name to check. + * @returns {boolean} `true` for success, `false` otherwise. + * @example + * ```js + * Handsontable.hooks.isRegistered('beforeInit'); + * + * // Results: + * true + * ``` + */ + + }, { + key: "isRegistered", + value: function isRegistered(hookName) { + return REGISTERED_HOOKS.indexOf(hookName) >= 0; + } + /** + * Returns an array of registered hooks. + * + * @returns {Array} An array of registered hooks. + * + * @example + * ```js + * Handsontable.hooks.getRegistered(); + * + * // Results: + * [ + * ... + * 'beforeInit', + * 'beforeRender', + * 'beforeSetRangeEnd', + * 'beforeDrawBorders', + * 'beforeChange', + * ... + * ] + * ``` + */ + + }, { + key: "getRegistered", + value: function getRegistered() { + return REGISTERED_HOOKS; + } + }], [{ + key: "getSingleton", + value: function getSingleton() { + return getGlobalSingleton(); + } + }]); + + return Hooks; +}(); + +var globalSingleton = new Hooks(); +/** + * @returns {Hooks} + */ + +function getGlobalSingleton() { + return globalSingleton; +} + +function _toConsumableArray$4(arr) { return _arrayWithoutHoles$2(arr) || _iterableToArray$2(arr) || _unsupportedIterableToArray$4(arr) || _nonIterableSpread$2(); } + +function _nonIterableSpread$2() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$4(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$4(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$4(o, minLen); } + +function _iterableToArray$2(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$2(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$4(arr); } + +function _arrayLikeToArray$4(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +var collection$1 = new Map(); +/** + * @param {string} namespace The namespace for the storage. + * @returns {object} + */ + +function staticRegister() { + var namespace = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'common'; + + if (!collection$1.has(namespace)) { + collection$1.set(namespace, new Map()); + } + + var subCollection = collection$1.get(namespace); + /** + * Register an item to the collection. If the item under the same was exist earlier then this item will be replaced with new one. + * + * @param {string} name Identification of the item. + * @param {*} item Item to save in the collection. + */ + + function register(name, item) { + subCollection.set(name, item); + } + /** + * Retrieve the item from the collection. + * + * @param {string} name Identification of the item. + * @returns {*} Returns item which was saved in the collection. + */ + + + function getItem(name) { + return subCollection.get(name); + } + /** + * Check if item under specified name is exists. + * + * @param {string} name Identification of the item. + * @returns {boolean} Returns `true` or `false` depends on if element exists in the collection. + */ + + + function hasItem(name) { + return subCollection.has(name); + } + /** + * Retrieve list of names registered from the collection. + * + * @returns {Array} Returns an array of strings with all names under which objects are stored. + */ + + + function getNames() { + return _toConsumableArray$4(subCollection.keys()); + } + /** + * Retrieve all registered values from the collection. + * + * @returns {Array} Returns an array with all values stored in the collection. + */ + + + function getValues() { + return _toConsumableArray$4(subCollection.values()); + } + + return { + register: register, + getItem: getItem, + hasItem: hasItem, + getNames: getNames, + getValues: getValues + }; +} + +var registeredEditorClasses = new WeakMap(); + +var _staticRegister = staticRegister('editors'), + register = _staticRegister.register, + getItem = _staticRegister.getItem, + hasItem = _staticRegister.hasItem, + getNames = _staticRegister.getNames; +/** + * @param {BaseEditor} editorClass The editor constructor. + */ + + +function RegisteredEditor(editorClass) { + var instances = {}; + var Clazz = editorClass; + + this.getConstructor = function () { + return editorClass; + }; + + this.getInstance = function (hotInstance) { + if (!(hotInstance.guid in instances)) { + instances[hotInstance.guid] = new Clazz(hotInstance); + } + + return instances[hotInstance.guid]; + }; + + Hooks.getSingleton().add('afterDestroy', function () { + instances[this.guid] = null; + }); +} +/** + * Returns instance (singleton) of editor class. + * + * @param {string} name Name of an editor under which it has been stored. + * @param {object} hotInstance Instance of Handsontable. + * @returns {Function} Returns instance of editor. + */ + +function _getEditorInstance(name, hotInstance) { + var editor; + + if (typeof name === 'function') { + if (!registeredEditorClasses.get(name)) { + _register(null, name); + } + + editor = registeredEditorClasses.get(name); + } else if (typeof name === 'string') { + editor = getItem(name); + } else { + throw Error('Only strings and functions can be passed as "editor" parameter'); + } + + if (!editor) { + throw Error("No editor registered under name \"".concat(name, "\"")); + } + + return editor.getInstance(hotInstance); +} +/** + * Retrieve editor class. + * + * @param {string} name Editor identification. + * @returns {Function} Returns editor class. + */ + +function _getItem(name) { + if (!hasItem(name)) { + throw Error("No registered editor found under \"".concat(name, "\" name")); + } + + return getItem(name).getConstructor(); +} +/** + * Register editor class under specified name. + * + * @param {string} name Editor identification. + * @param {Function} editorClass Editor class. + */ + + +function _register(name, editorClass) { + if (name && typeof name !== 'string') { + editorClass = name; + name = editorClass.EDITOR_TYPE; + } + + var editorWrapper = new RegisteredEditor(editorClass); + + if (typeof name === 'string') { + register(name, editorWrapper); + } + + registeredEditorClasses.set(editorClass, editorWrapper); +} + +var onFreeze = internalMetadata.onFreeze; + +var nativeFreeze = Object.freeze; +var FAILS_ON_PRIMITIVES$2 = fails(function () { nativeFreeze(1); }); + +// `Object.freeze` method +// https://tc39.es/ecma262/#sec-object.freeze +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$2, sham: !freezing }, { + freeze: function freeze(it) { + return nativeFreeze && isObject(it) ? nativeFreeze(onFreeze(it)) : it; + } +}); + +var MIXIN_NAME$5 = 'hooksRefRegisterer'; +/** + * Mixin object to extend objects functionality for auto registering hooks in an Handsontable instance. + * + * @type {object} + */ + +var hooksRefRegisterer = { + /** + * Internal hooks storage. + */ + _hooksStorage: Object.create(null), + + /** + * Add hook to the collection. + * + * @param {string} key The hook name. + * @param {Function} callback The hook callback. + * @returns {object} + */ + addHook: function addHook(key, callback) { + if (!this._hooksStorage[key]) { + this._hooksStorage[key] = []; + } + + this.hot.addHook(key, callback); + + this._hooksStorage[key].push(callback); + + return this; + }, + + /** + * Remove all hooks listeners by hook name. + * + * @param {string} key The hook name. + */ + removeHooksByKey: function removeHooksByKey(key) { + var _this = this; + + arrayEach(this._hooksStorage[key] || [], function (callback) { + _this.hot.removeHook(key, callback); + }); + }, + + /** + * Clear all added hooks. + */ + clearHooks: function clearHooks() { + var _this2 = this; + + objectEach(this._hooksStorage, function (callbacks, name) { + return _this2.removeHooksByKey(name); + }); + this._hooksStorage = {}; + } +}; +defineGetter(hooksRefRegisterer, 'MIXIN_NAME', MIXIN_NAME$5, { + writable: false, + enumerable: false +}); + +function _typeof$n(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$n = function _typeof(obj) { return typeof obj; }; } else { _typeof$n = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$n(obj); } + +function _slicedToArray$3(arr, i) { return _arrayWithHoles$3(arr) || _iterableToArrayLimit$3(arr, i) || _unsupportedIterableToArray$5(arr, i) || _nonIterableRest$3(); } + +function _nonIterableRest$3() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$5(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$5(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$5(o, minLen); } + +function _arrayLikeToArray$5(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$3(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$3(arr) { if (Array.isArray(arr)) return arr; } + +function _inherits$h(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$h(subClass, superClass); } + +function _setPrototypeOf$h(o, p) { _setPrototypeOf$h = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$h(o, p); } + +function _createSuper$h(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$h(); return function _createSuperInternal() { var Super = _getPrototypeOf$h(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$h(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$h(this, result); }; } + +function _possibleConstructorReturn$h(self, call) { if (call && (_typeof$n(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$h(self); } + +function _assertThisInitialized$h(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$h() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$h(o) { _getPrototypeOf$h = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$h(o); } + +function _classCallCheck$I(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$D(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); } } + +function _createClass$D(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$D(Constructor.prototype, protoProps); if (staticProps) _defineProperties$D(Constructor, staticProps); return Constructor; } +var EDITOR_TYPE = 'base'; +var EDITOR_STATE = Object.freeze({ + VIRGIN: 'STATE_VIRGIN', + // before editing + EDITING: 'STATE_EDITING', + WAITING: 'STATE_WAITING', + // waiting for async validation + FINISHED: 'STATE_FINISHED' +}); +/** + * @util + * @class BaseEditor + */ + +var BaseEditor = /*#__PURE__*/function () { + /** + * @param {Handsontable} instance A reference to the source instance of the Handsontable. + */ + function BaseEditor(instance) { + _classCallCheck$I(this, BaseEditor); + + /** + * A reference to the source instance of the Handsontable. + * + * @type {Handsontable} + */ + this.hot = instance; + /** + * A reference to the source instance of the Handsontable. + * + * @deprecated + * + * @type {Handsontable} + */ + + this.instance = instance; + /** + * Editor's state. + * + * @type {string} + */ + + this.state = EDITOR_STATE.VIRGIN; + /** + * Flag to store information about editor's opening status. + * + * @private + * + * @type {boolean} + */ + + this._opened = false; + /** + * Defines the editor's editing mode. When false, then an editor works in fast editing mode. + * + * @private + * + * @type {boolean} + */ + + this._fullEditMode = false; + /** + * Callback to call after closing editor. + * + * @type {Function} + */ + + this._closeCallback = null; + /** + * Currently rendered cell's TD element. + * + * @type {HTMLTableCellElement} + */ + + this.TD = null; + /** + * Visual row index. + * + * @type {number} + */ + + this.row = null; + /** + * Visual column index. + * + * @type {number} + */ + + this.col = null; + /** + * Column property name or a column index, if datasource is an array of arrays. + * + * @type {number|string} + */ + + this.prop = null; + /** + * Original cell's value. + * + * @type {*} + */ + + this.originalValue = null; + /** + * Object containing the cell's properties. + * + * @type {object} + */ + + this.cellProperties = null; + this.init(); + } + /** + * Fires callback after closing editor. + * + * @private + * @param {boolean} result The editor value. + */ + + + _createClass$D(BaseEditor, [{ + key: "_fireCallbacks", + value: function _fireCallbacks(result) { + if (this._closeCallback) { + this._closeCallback(result); + + this._closeCallback = null; + } + } + /** + * Initializes an editor's intance. + */ + + }, { + key: "init", + value: function init() {} + /** + * Required method to get current value from editable element. + */ + + }, { + key: "getValue", + value: function getValue() { + throw Error('Editor getValue() method unimplemented'); + } + /** + * Required method to set new value into editable element. + */ + + }, { + key: "setValue", + value: function setValue() { + throw Error('Editor setValue() method unimplemented'); + } + /** + * Required method to open editor. + */ + + }, { + key: "open", + value: function open() { + throw Error('Editor open() method unimplemented'); + } + /** + * Required method to close editor. + */ + + }, { + key: "close", + value: function close() { + throw Error('Editor close() method unimplemented'); + } + /** + * Prepares editor's meta data. + * + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {HTMLTableCellElement} td The rendered cell element. + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + + }, { + key: "prepare", + value: function prepare(row, col, prop, td, value, cellProperties) { + this.TD = td; + this.row = row; + this.col = col; + this.prop = prop; + this.originalValue = value; + this.cellProperties = cellProperties; + this.state = EDITOR_STATE.VIRGIN; + } + /** + * Fallback method to provide extendable editors in ES5. + * + * @returns {Function} + */ + + }, { + key: "extend", + value: function extend() { + return /*#__PURE__*/function (_this$constructor) { + _inherits$h(Editor, _this$constructor); + + var _super = _createSuper$h(Editor); + + function Editor() { + _classCallCheck$I(this, Editor); + + return _super.apply(this, arguments); + } + + return Editor; + }(this.constructor); + } + /** + * Saves value from editor into data storage. + * + * @param {*} value The editor value. + * @param {boolean} ctrlDown If `true`, applies value to each cell in the last selected range. + */ + + }, { + key: "saveValue", + value: function saveValue(value, ctrlDown) { + var visualRowFrom; + var visualColumnFrom; + var visualRowTo; + var visualColumnTo; // if ctrl+enter and multiple cells selected, behave like Excel (finish editing and apply to all cells) + + if (ctrlDown) { + var selectedLast = this.hot.getSelectedLast(); + visualRowFrom = Math.min(selectedLast[0], selectedLast[2]); + visualColumnFrom = Math.min(selectedLast[1], selectedLast[3]); + visualRowTo = Math.max(selectedLast[0], selectedLast[2]); + visualColumnTo = Math.max(selectedLast[1], selectedLast[3]); + } else { + var _ref = [this.row, this.col, null, null]; + visualRowFrom = _ref[0]; + visualColumnFrom = _ref[1]; + visualRowTo = _ref[2]; + visualColumnTo = _ref[3]; + } + + var modifiedCellCoords = this.hot.runHooks('modifyGetCellCoords', visualRowFrom, visualColumnFrom); + + if (Array.isArray(modifiedCellCoords)) { + var _modifiedCellCoords = _slicedToArray$3(modifiedCellCoords, 2); + + visualRowFrom = _modifiedCellCoords[0]; + visualColumnFrom = _modifiedCellCoords[1]; + } // Saving values using the modified coordinates. + + + this.hot.populateFromArray(visualRowFrom, visualColumnFrom, value, visualRowTo, visualColumnTo, 'edit'); + } + /** + * Begins editing on a highlighted cell and hides fillHandle corner if was present. + * + * @param {*} newInitialValue The initial editor value. + * @param {Event} event The keyboard event object. + */ + + }, { + key: "beginEditing", + value: function beginEditing(newInitialValue, event) { + if (this.state !== EDITOR_STATE.VIRGIN) { + return; + } + + var hotInstance = this.hot; // We have to convert visual indexes into renderable indexes + // due to hidden columns don't participate in the rendering process + + var renderableRowIndex = hotInstance.rowIndexMapper.getRenderableFromVisualIndex(this.row); + var renderableColumnIndex = hotInstance.columnIndexMapper.getRenderableFromVisualIndex(this.col); + hotInstance.view.scrollViewport(new CellCoords(renderableRowIndex, renderableColumnIndex)); + this.state = EDITOR_STATE.EDITING; // Set the editor value only in the full edit mode. In other mode the focusable element has to be empty, + // otherwise IME (editor for Asia users) doesn't work. + + if (this.isInFullEditMode()) { + var stringifiedInitialValue = typeof newInitialValue === 'string' ? newInitialValue : stringify(this.originalValue); + this.setValue(stringifiedInitialValue); + } + + this.open(event); + this._opened = true; + this.focus(); // only rerender the selections (FillHandle should disappear when beginediting is triggered) + + hotInstance.view.render(); + hotInstance.runHooks('afterBeginEditing', this.row, this.col); + } + /** + * Finishes editing and start saving or restoring process for editing cell or last selected range. + * + * @param {boolean} restoreOriginalValue If true, then closes editor without saving value from the editor into a cell. + * @param {boolean} ctrlDown If true, then saveValue will save editor's value to each cell in the last selected range. + * @param {Function} callback The callback function, fired after editor closing. + */ + + }, { + key: "finishEditing", + value: function finishEditing(restoreOriginalValue, ctrlDown, callback) { + var _this = this; + + var val; + + if (callback) { + var previousCloseCallback = this._closeCallback; + + this._closeCallback = function (result) { + if (previousCloseCallback) { + previousCloseCallback(result); + } + + callback(result); + + _this.hot.view.render(); + }; + } + + if (this.isWaiting()) { + return; + } + + if (this.state === EDITOR_STATE.VIRGIN) { + this.hot._registerTimeout(function () { + _this._fireCallbacks(true); + }); + + return; + } + + if (this.state === EDITOR_STATE.EDITING) { + if (restoreOriginalValue) { + this.cancelChanges(); + this.hot.view.render(); + return; + } + + var value = this.getValue(); + + if (this.hot.getSettings().trimWhitespace) { + // We trim only string values + val = [[typeof value === 'string' ? String.prototype.trim.call(value || '') : value]]; + } else { + val = [[value]]; + } + + this.state = EDITOR_STATE.WAITING; + this.saveValue(val, ctrlDown); + + if (this.hot.getCellValidator(this.cellProperties)) { + this.hot.addHookOnce('postAfterValidate', function (result) { + _this.state = EDITOR_STATE.FINISHED; + + _this.discardEditor(result); + }); + } else { + this.state = EDITOR_STATE.FINISHED; + this.discardEditor(true); + } + } + } + /** + * Finishes editing without singout saving value. + */ + + }, { + key: "cancelChanges", + value: function cancelChanges() { + this.state = EDITOR_STATE.FINISHED; + this.discardEditor(); + } + /** + * Verifies result of validation or closes editor if user's cancelled changes. + * + * @param {boolean|undefined} result If `false` and the cell using allowInvalid option, + * then an editor won't be closed until validation is passed. + */ + + }, { + key: "discardEditor", + value: function discardEditor(result) { + if (this.state !== EDITOR_STATE.FINISHED) { + return; + } // validator was defined and failed + + + if (result === false && this.cellProperties.allowInvalid !== true) { + this.hot.selectCell(this.row, this.col); + this.focus(); + this.state = EDITOR_STATE.EDITING; + + this._fireCallbacks(false); + } else { + this.close(); + this._opened = false; + this._fullEditMode = false; + this.state = EDITOR_STATE.VIRGIN; + + this._fireCallbacks(true); + } + } + /** + * Switch editor into full edit mode. In this state navigation keys don't close editor. This mode is activated + * automatically after hit ENTER or F2 key on the cell or while editing cell press F2 key. + */ + + }, { + key: "enableFullEditMode", + value: function enableFullEditMode() { + this._fullEditMode = true; + } + /** + * Checks if editor is in full edit mode. + * + * @returns {boolean} + */ + + }, { + key: "isInFullEditMode", + value: function isInFullEditMode() { + return this._fullEditMode; + } + /** + * Returns information whether the editor is open. + * + * @returns {boolean} + */ + + }, { + key: "isOpened", + value: function isOpened() { + return this._opened; + } + /** + * Returns information whether the editor is waiting, eg.: for async validation. + * + * @returns {boolean} + */ + + }, { + key: "isWaiting", + value: function isWaiting() { + return this.state === EDITOR_STATE.WAITING; + } + /** + * Gets className of the edited cell if exist. + * + * @returns {string} + */ + + }, { + key: "getEditedCellsLayerClass", + value: function getEditedCellsLayerClass() { + var editorSection = this.checkEditorSection(); + + switch (editorSection) { + case 'right': + return 'ht_clone_right'; + + case 'left': + return 'ht_clone_left'; + + case 'bottom': + return 'ht_clone_bottom'; + + case 'bottom-right-corner': + return 'ht_clone_bottom_right_corner'; + + case 'bottom-left-corner': + return 'ht_clone_bottom_left_corner'; + + case 'top': + return 'ht_clone_top'; + + case 'top-right-corner': + return 'ht_clone_top_right_corner'; + + case 'top-left-corner': + return 'ht_clone_top_left_corner'; + + default: + return 'ht_clone_master'; + } + } + /** + * Gets HTMLTableCellElement of the edited cell if exist. + * + * @returns {HTMLTableCellElement|null} + */ + + }, { + key: "getEditedCell", + value: function getEditedCell() { + return this.hot.getCell(this.row, this.col, true); + } + /** + * Returns name of the overlay, where editor is placed. + * + * @private + * @returns {string} + */ + + }, { + key: "checkEditorSection", + value: function checkEditorSection() { + var totalRows = this.hot.countRows(); + var section = ''; + + if (this.row < this.hot.getSettings().fixedRowsTop) { + if (this.col < this.hot.getSettings().fixedColumnsLeft) { + section = 'top-left-corner'; + } else { + section = 'top'; + } + } else if (this.hot.getSettings().fixedRowsBottom && this.row >= totalRows - this.hot.getSettings().fixedRowsBottom) { + if (this.col < this.hot.getSettings().fixedColumnsLeft) { + section = 'bottom-left-corner'; + } else { + section = 'bottom'; + } + } else if (this.col < this.hot.getSettings().fixedColumnsLeft) { + section = 'left'; + } + + return section; + } + }], [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE; + } + }]); + + return BaseEditor; +}(); +mixin(BaseEditor, hooksRefRegisterer); + +function _slicedToArray$4(arr, i) { return _arrayWithHoles$4(arr) || _iterableToArrayLimit$4(arr, i) || _unsupportedIterableToArray$6(arr, i) || _nonIterableRest$4(); } + +function _nonIterableRest$4() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$6(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$6(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$6(o, minLen); } + +function _arrayLikeToArray$6(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$4(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$4(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$J(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$E(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); } } + +function _createClass$E(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$E(Constructor.prototype, protoProps); if (staticProps) _defineProperties$E(Constructor, staticProps); return Constructor; } + +var EditorManager = /*#__PURE__*/function () { + /** + * @param {Core} instance The Handsontable instance. + * @param {TableMeta} tableMeta The table meta instance. + * @param {Selection} selection The selection instance. + */ + function EditorManager(instance, tableMeta, selection) { + var _this = this; + + _classCallCheck$J(this, EditorManager); + + /** + * Instance of {@link Handsontable}. + * + * @private + * @type {Handsontable} + */ + this.instance = instance; + /** + * Reference to an instance's private GridSettings object. + * + * @private + * @type {GridSettings} + */ + + this.tableMeta = tableMeta; + /** + * Instance of {@link Selection}. + * + * @private + * @type {Selection} + */ + + this.selection = selection; + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + this.eventManager = new EventManager(instance); + /** + * Determines if EditorManager is destroyed. + * + * @private + * @type {boolean} + */ + + this.destroyed = false; + /** + * Determines if EditorManager is locked. + * + * @private + * @type {boolean} + */ + + this.lock = false; + /** + * A reference to an instance of the activeEditor. + * + * @private + * @type {*} + */ + + this.activeEditor = void 0; + /** + * Keeps a reference to the cell's properties object. + * + * @type {object} + */ + + this.cellProperties = void 0; + /** + * Keeps last keyCode pressed from the keydown event. + * + * @type {number} + */ + + this.lastKeyCode = void 0; + this.instance.addHook('afterDocumentKeyDown', function (event) { + return _this.onAfterDocumentKeyDown(event); + }); + var frame = this.instance.rootWindow; + + while (frame) { + this.eventManager.addEventListener(frame.document.documentElement, 'keydown', function (event) { + if (!_this.destroyed) { + _this.instance.runHooks('afterDocumentKeyDown', event); + } + }); + frame = getParentWindow(frame); + } // Open editor when text composition is started (IME editor) + + + this.eventManager.addEventListener(this.instance.rootDocument.documentElement, 'compositionstart', function (event) { + if (!_this.destroyed && _this.activeEditor && !_this.activeEditor.isOpened() && _this.instance.isListening()) { + _this.openEditor('', event); + } + }); + this.instance.view.wt.update('onCellDblClick', function (event, coords, elem) { + return _this.onCellDblClick(event, coords, elem); + }); + } + /** + * Lock the editor from being prepared and closed. Locking the editor prevents its closing and + * reinitialized after selecting the new cell. This feature is necessary for a mobile editor. + */ + + + _createClass$E(EditorManager, [{ + key: "lockEditor", + value: function lockEditor() { + this.lock = true; + } + /** + * Unlock the editor from being prepared and closed. This method restores the original behavior of + * the editors where for every new selection its instances are closed. + */ + + }, { + key: "unlockEditor", + value: function unlockEditor() { + this.lock = false; + } + /** + * Destroy current editor, if exists. + * + * @param {boolean} revertOriginal If `false` and the cell using allowInvalid option, + * then an editor won't be closed until validation is passed. + */ + + }, { + key: "destroyEditor", + value: function destroyEditor(revertOriginal) { + if (!this.lock) { + this.closeEditor(revertOriginal); + } + } + /** + * Get active editor. + * + * @returns {*} + */ + + }, { + key: "getActiveEditor", + value: function getActiveEditor() { + return this.activeEditor; + } + /** + * Prepare text input to be displayed at given grid cell. + */ + + }, { + key: "prepareEditor", + value: function prepareEditor() { + var _this2 = this; + + if (this.lock) { + return; + } + + if (this.activeEditor && this.activeEditor.isWaiting()) { + this.closeEditor(false, false, function (dataSaved) { + if (dataSaved) { + _this2.prepareEditor(); + } + }); + return; + } + + var _this$instance$select = this.instance.selection.selectedRange.current().highlight, + row = _this$instance$select.row, + col = _this$instance$select.col; + var modifiedCellCoords = this.instance.runHooks('modifyGetCellCoords', row, col); + var visualRowToCheck = row; + var visualColumnToCheck = col; + + if (Array.isArray(modifiedCellCoords)) { + var _modifiedCellCoords = _slicedToArray$4(modifiedCellCoords, 2); + + visualRowToCheck = _modifiedCellCoords[0]; + visualColumnToCheck = _modifiedCellCoords[1]; + } // Getting values using the modified coordinates. + + + this.cellProperties = this.instance.getCellMeta(visualRowToCheck, visualColumnToCheck); + var activeElement = this.instance.rootDocument.activeElement; + + if (activeElement) { + // Bluring the activeElement removes unwanted border around the focusable element + // (and resets activeElement prop). Without blurring the activeElement points to the + // previously focusable element after clicking onto the cell (#6877). + activeElement.blur(); + } + + if (this.cellProperties.readOnly) { + this.clearActiveEditor(); + return; + } + + var editorClass = this.instance.getCellEditor(this.cellProperties); // Getting element using coordinates from the selection. + + var td = this.instance.getCell(row, col, true); + + if (editorClass && td) { + var prop = this.instance.colToProp(visualColumnToCheck); + var originalValue = this.instance.getSourceDataAtCell(this.instance.toPhysicalRow(visualRowToCheck), visualColumnToCheck); + this.activeEditor = _getEditorInstance(editorClass, this.instance); // Using not modified coordinates, as we need to get the table element using selection coordinates. + // There is an extra translation in the editor for saving value. + + this.activeEditor.prepare(row, col, prop, td, originalValue, this.cellProperties); + } else { + this.clearActiveEditor(); + } + } + /** + * Check is editor is opened/showed. + * + * @returns {boolean} + */ + + }, { + key: "isEditorOpened", + value: function isEditorOpened() { + return this.activeEditor && this.activeEditor.isOpened(); + } + /** + * Open editor with initial value. + * + * @param {null|string} newInitialValue New value from which editor will start if handled property it's not the `null`. + * @param {Event} event The event object. + */ + + }, { + key: "openEditor", + value: function openEditor(newInitialValue, event) { + if (!this.activeEditor) { + return; + } + + this.activeEditor.beginEditing(newInitialValue, event); + } + /** + * Close editor, finish editing cell. + * + * @param {boolean} restoreOriginalValue If `true`, then closes editor without saving value from the editor into a cell. + * @param {boolean} isCtrlPressed If `true`, then editor will save value to each cell in the last selected range. + * @param {Function} callback The callback function, fired after editor closing. + */ + + }, { + key: "closeEditor", + value: function closeEditor(restoreOriginalValue, isCtrlPressed, callback) { + if (this.activeEditor) { + this.activeEditor.finishEditing(restoreOriginalValue, isCtrlPressed, callback); + } else if (callback) { + callback(false); + } + } + /** + * Close editor and save changes. + * + * @param {boolean} isCtrlPressed If `true`, then editor will save value to each cell in the last selected range. + */ + + }, { + key: "closeEditorAndSaveChanges", + value: function closeEditorAndSaveChanges(isCtrlPressed) { + this.closeEditor(false, isCtrlPressed); + } + /** + * Close editor and restore original value. + * + * @param {boolean} isCtrlPressed Indication of whether the CTRL button is pressed. + */ + + }, { + key: "closeEditorAndRestoreOriginalValue", + value: function closeEditorAndRestoreOriginalValue(isCtrlPressed) { + this.closeEditor(true, isCtrlPressed); + } + /** + * Clears reference to an instance of the active editor. + * + * @private + */ + + }, { + key: "clearActiveEditor", + value: function clearActiveEditor() { + this.activeEditor = void 0; + } + /** + * Controls selection's behaviour after clicking `Enter`. + * + * @private + * @param {boolean} isShiftPressed If `true`, then the selection will move up after hit enter. + */ + + }, { + key: "moveSelectionAfterEnter", + value: function moveSelectionAfterEnter(isShiftPressed) { + var enterMoves = typeof this.tableMeta.enterMoves === 'function' ? this.tableMeta.enterMoves(event) : this.tableMeta.enterMoves; + + if (isShiftPressed) { + // move selection up + this.selection.transformStart(-enterMoves.row, -enterMoves.col); + } else { + // move selection down (add a new row if needed) + this.selection.transformStart(enterMoves.row, enterMoves.col, true); + } + } + /** + * Controls selection behaviour after clicking `arrow up`. + * + * @private + * @param {boolean} isShiftPressed If `true`, then the selection will expand up. + */ + + }, { + key: "moveSelectionUp", + value: function moveSelectionUp(isShiftPressed) { + if (isShiftPressed) { + this.selection.transformEnd(-1, 0); + } else { + this.selection.transformStart(-1, 0); + } + } + /** + * Controls selection's behaviour after clicking `arrow down`. + * + * @private + * @param {boolean} isShiftPressed If `true`, then the selection will expand down. + */ + + }, { + key: "moveSelectionDown", + value: function moveSelectionDown(isShiftPressed) { + if (isShiftPressed) { + // expanding selection down with shift + this.selection.transformEnd(1, 0); + } else { + this.selection.transformStart(1, 0); + } + } + /** + * Controls selection's behaviour after clicking `arrow right`. + * + * @private + * @param {boolean} isShiftPressed If `true`, then the selection will expand right. + */ + + }, { + key: "moveSelectionRight", + value: function moveSelectionRight(isShiftPressed) { + if (isShiftPressed) { + this.selection.transformEnd(0, 1); + } else { + this.selection.transformStart(0, 1); + } + } + /** + * Controls selection's behaviour after clicking `arrow left`. + * + * @private + * @param {boolean} isShiftPressed If `true`, then the selection will expand left. + */ + + }, { + key: "moveSelectionLeft", + value: function moveSelectionLeft(isShiftPressed) { + if (isShiftPressed) { + this.selection.transformEnd(0, -1); + } else { + this.selection.transformStart(0, -1); + } + } + /** + * OnAfterDocumentKeyDown callback. + * + * @private + * @param {KeyboardEvent} event The keyboard event object. + */ + + }, { + key: "onAfterDocumentKeyDown", + value: function onAfterDocumentKeyDown(event) { + if (!this.instance.isListening()) { + return; + } + + this.instance.runHooks('beforeKeyDown', event); // keyCode 229 aka 'uninitialized' doesn't take into account with editors. This key code is produced when unfinished + // character is entering (using IME editor). It is fired mainly on linux (ubuntu) with installed ibus-pinyin package. + + if (this.destroyed || event.keyCode === 229) { + return; + } + + if (isImmediatePropagationStopped(event)) { + return; + } + + this.lastKeyCode = event.keyCode; + + if (!this.selection.isSelected()) { + return; + } // catch CTRL but not right ALT (which in some systems triggers ALT+CTRL) + + + var isCtrlPressed = (event.ctrlKey || event.metaKey) && !event.altKey; + + if (this.activeEditor && !this.activeEditor.isWaiting()) { + if (!isMetaKey(event.keyCode) && !isCtrlMetaKey(event.keyCode) && !isCtrlPressed && !this.isEditorOpened()) { + this.openEditor('', event); + return; + } + } + + var isShiftPressed = event.shiftKey; + var rangeModifier = isShiftPressed ? this.selection.setRangeEnd : this.selection.setRangeStart; + var tabMoves; + + switch (event.keyCode) { + case KEY_CODES.A: + if (!this.isEditorOpened() && isCtrlPressed) { + this.instance.selectAll(); + event.preventDefault(); + event.stopPropagation(); + } + + break; + + case KEY_CODES.ARROW_UP: + if (this.isEditorOpened() && !this.activeEditor.isWaiting()) { + this.closeEditorAndSaveChanges(isCtrlPressed); + } + + this.moveSelectionUp(isShiftPressed); + event.preventDefault(); + event.stopPropagation(); + break; + + case KEY_CODES.ARROW_DOWN: + if (this.isEditorOpened() && !this.activeEditor.isWaiting()) { + this.closeEditorAndSaveChanges(isCtrlPressed); + } + + this.moveSelectionDown(isShiftPressed); + event.preventDefault(); + event.stopPropagation(); + break; + + case KEY_CODES.ARROW_RIGHT: + if (this.isEditorOpened() && !this.activeEditor.isWaiting()) { + this.closeEditorAndSaveChanges(isCtrlPressed); + } + + this.moveSelectionRight(isShiftPressed); + event.preventDefault(); + event.stopPropagation(); + break; + + case KEY_CODES.ARROW_LEFT: + if (this.isEditorOpened() && !this.activeEditor.isWaiting()) { + this.closeEditorAndSaveChanges(isCtrlPressed); + } + + this.moveSelectionLeft(isShiftPressed); + event.preventDefault(); + event.stopPropagation(); + break; + + case KEY_CODES.TAB: + tabMoves = typeof this.tableMeta.tabMoves === 'function' ? this.tableMeta.tabMoves(event) : this.tableMeta.tabMoves; + + if (isShiftPressed) { + // move selection left + this.selection.transformStart(-tabMoves.row, -tabMoves.col); + } else { + // move selection right (add a new column if needed) + this.selection.transformStart(tabMoves.row, tabMoves.col, true); + } + + event.preventDefault(); + event.stopPropagation(); + break; + + case KEY_CODES.BACKSPACE: + case KEY_CODES.DELETE: + this.instance.emptySelectedCells(); + this.prepareEditor(); + event.preventDefault(); + break; + + case KEY_CODES.F2: + /* F2 */ + if (this.activeEditor) { + this.activeEditor.enableFullEditMode(); + } + + this.openEditor(null, event); + event.preventDefault(); // prevent Opera from opening 'Go to Page dialog' + + break; + + case KEY_CODES.ENTER: + /* return/enter */ + if (this.isEditorOpened()) { + if (this.activeEditor && this.activeEditor.state !== EDITOR_STATE.WAITING) { + this.closeEditorAndSaveChanges(isCtrlPressed); + } + + this.moveSelectionAfterEnter(isShiftPressed); + } else if (this.instance.getSettings().enterBeginsEditing) { + if (this.cellProperties.readOnly) { + this.moveSelectionAfterEnter(); + } else if (this.activeEditor) { + this.activeEditor.enableFullEditMode(); + this.openEditor(null, event); + } + } else { + this.moveSelectionAfterEnter(isShiftPressed); + } + + event.preventDefault(); // don't add newline to field + + stopImmediatePropagation(event); // required by HandsontableEditor + + break; + + case KEY_CODES.ESCAPE: + if (this.isEditorOpened()) { + this.closeEditorAndRestoreOriginalValue(isCtrlPressed); + this.activeEditor.focus(); + } + + event.preventDefault(); + break; + + case KEY_CODES.HOME: + if (event.ctrlKey || event.metaKey) { + rangeModifier.call(this.selection, new CellCoords(0, this.selection.selectedRange.current().from.col)); + } else { + rangeModifier.call(this.selection, new CellCoords(this.selection.selectedRange.current().from.row, 0)); + } + + event.preventDefault(); // don't scroll the window + + event.stopPropagation(); + break; + + case KEY_CODES.END: + if (event.ctrlKey || event.metaKey) { + rangeModifier.call(this.selection, new CellCoords(this.instance.countRows() - 1, this.selection.selectedRange.current().from.col)); + } else { + rangeModifier.call(this.selection, new CellCoords(this.selection.selectedRange.current().from.row, this.instance.countCols() - 1)); + } + + event.preventDefault(); // don't scroll the window + + event.stopPropagation(); + break; + + case KEY_CODES.PAGE_UP: + this.selection.transformStart(-this.instance.countVisibleRows(), 0); + event.preventDefault(); // don't page up the window + + event.stopPropagation(); + break; + + case KEY_CODES.PAGE_DOWN: + this.selection.transformStart(this.instance.countVisibleRows(), 0); + event.preventDefault(); // don't page down the window + + event.stopPropagation(); + break; + } + } + /** + * OnCellDblClick callback. + * + * @private + * @param {MouseEvent} event The mouse event object. + * @param {object} coords The cell coordinates. + * @param {HTMLTableCellElement|HTMLTableHeaderCellElement} elem The element which triggers the action. + */ + + }, { + key: "onCellDblClick", + value: function onCellDblClick(event, coords, elem) { + // may be TD or TH + if (elem.nodeName === 'TD') { + if (this.activeEditor) { + this.activeEditor.enableFullEditMode(); + } + + this.openEditor(null, event); + } + } + /** + * Destroy the instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.destroyed = true; + this.eventManager.destroy(); + } + }]); + + return EditorManager; +}(); + +var instances = new WeakMap(); +/** + * @param {Core} hotInstance The Handsontable instance. + * @param {TableMeta} tableMeta The table meta class instance. + * @param {Selection} selection The selection instance. + * @returns {EditorManager} + */ + +EditorManager.getInstance = function (hotInstance, tableMeta, selection) { + var editorManager = instances.get(hotInstance); + + if (!editorManager) { + editorManager = new EditorManager(hotInstance, tableMeta, selection); + instances.set(hotInstance, editorManager); + } + + return editorManager; +}; + +var $findIndex = arrayIteration.findIndex; + + +var FIND_INDEX = 'findIndex'; +var SKIPS_HOLES = true; + +// Shouldn't skip holes +if (FIND_INDEX in []) Array(1)[FIND_INDEX](function () { SKIPS_HOLES = false; }); + +// `Array.prototype.findIndex` method +// https://tc39.es/ecma262/#sec-array.prototype.findindex +_export({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { + findIndex: function findIndex(callbackfn /* , that = undefined */) { + return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables(FIND_INDEX); + +var min$5 = Math.min; +var nativeLastIndexOf = [].lastIndexOf; +var NEGATIVE_ZERO$1 = !!nativeLastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0; +var STRICT_METHOD$4 = arrayMethodIsStrict('lastIndexOf'); +var FORCED$4 = NEGATIVE_ZERO$1 || !STRICT_METHOD$4; + +// `Array.prototype.lastIndexOf` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.lastindexof +var arrayLastIndexOf = FORCED$4 ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) { + // convert -0 to +0 + if (NEGATIVE_ZERO$1) return nativeLastIndexOf.apply(this, arguments) || 0; + var O = toIndexedObject(this); + var length = toLength(O.length); + var index = length - 1; + if (arguments.length > 1) index = min$5(index, toInteger(arguments[1])); + if (index < 0) index = length + index; + for (;index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0; + return -1; +} : nativeLastIndexOf; + +// `Array.prototype.lastIndexOf` method +// https://tc39.es/ecma262/#sec-array.prototype.lastindexof +_export({ target: 'Array', proto: true, forced: arrayLastIndexOf !== [].lastIndexOf }, { + lastIndexOf: arrayLastIndexOf +}); + +var $map = arrayIteration.map; + + +var HAS_SPECIES_SUPPORT$3 = arrayMethodHasSpeciesSupport('map'); + +// `Array.prototype.map` method +// https://tc39.es/ecma262/#sec-array.prototype.map +// with adding support of @@species +_export({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$3 }, { + map: function map(callbackfn /* , thisArg */) { + return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// `Array.prototype.{ reduce, reduceRight }` methods implementation +var createMethod$6 = function (IS_RIGHT) { + return function (that, callbackfn, argumentsLength, memo) { + aFunction$1(callbackfn); + var O = toObject(that); + var self = indexedObject(O); + var length = toLength(O.length); + var index = IS_RIGHT ? length - 1 : 0; + var i = IS_RIGHT ? -1 : 1; + if (argumentsLength < 2) while (true) { + if (index in self) { + memo = self[index]; + index += i; + break; + } + index += i; + if (IS_RIGHT ? index < 0 : length <= index) { + throw TypeError('Reduce of empty array with no initial value'); + } + } + for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) { + memo = callbackfn(memo, self[index], index, O); + } + return memo; + }; +}; + +var arrayReduce$1 = { + // `Array.prototype.reduce` method + // https://tc39.es/ecma262/#sec-array.prototype.reduce + left: createMethod$6(false), + // `Array.prototype.reduceRight` method + // https://tc39.es/ecma262/#sec-array.prototype.reduceright + right: createMethod$6(true) +}; + +var $reduce = arrayReduce$1.left; + + + + +var STRICT_METHOD$5 = arrayMethodIsStrict('reduce'); +// Chrome 80-82 has a critical bug +// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982 +var CHROME_BUG = !engineIsNode && engineV8Version > 79 && engineV8Version < 83; + +// `Array.prototype.reduce` method +// https://tc39.es/ecma262/#sec-array.prototype.reduce +_export({ target: 'Array', proto: true, forced: !STRICT_METHOD$5 || CHROME_BUG }, { + reduce: function reduce(callbackfn /* , initialValue */) { + return $reduce(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +var FAILS_ON_PRIMITIVES$3 = fails(function () { objectKeys(1); }); + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +_export({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES$3 }, { + keys: function keys(it) { + return objectKeys(toObject(it)); + } +}); + +// @@match logic +fixRegexpWellKnownSymbolLogic('match', 1, function (MATCH, nativeMatch, maybeCallNative) { + return [ + // `String.prototype.match` method + // https://tc39.es/ecma262/#sec-string.prototype.match + function match(regexp) { + var O = requireObjectCoercible(this); + var matcher = regexp == undefined ? undefined : regexp[MATCH]; + return matcher !== undefined ? matcher.call(regexp, O) : new RegExp(regexp)[MATCH](String(O)); + }, + // `RegExp.prototype[@@match]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@match + function (regexp) { + var res = maybeCallNative(nativeMatch, regexp, this); + if (res.done) return res.value; + + var rx = anObject(regexp); + var S = String(this); + + if (!rx.global) return regexpExecAbstract(rx, S); + + var fullUnicode = rx.unicode; + rx.lastIndex = 0; + var A = []; + var n = 0; + var result; + while ((result = regexpExecAbstract(rx, S)) !== null) { + var matchStr = String(result[0]); + A[n] = matchStr; + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + n++; + } + return n === 0 ? null : A; + } + ]; +}); + +function _toConsumableArray$5(arr) { return _arrayWithoutHoles$3(arr) || _iterableToArray$3(arr) || _unsupportedIterableToArray$7(arr) || _nonIterableSpread$3(); } + +function _nonIterableSpread$3() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$7(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$7(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$7(o, minLen); } + +function _iterableToArray$3(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$3(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$7(arr); } + +function _arrayLikeToArray$7(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } +var ESCAPED_HTML_CHARS = { + ' ': '\x20', + '&': '&', + '<': '<', + '>': '>' +}; +var regEscapedChars = new RegExp(Object.keys(ESCAPED_HTML_CHARS).map(function (key) { + return "(".concat(key, ")"); +}).join('|'), 'gi'); +/** + * Verifies if node is an HTMLTable element. + * + * @param {Node} element Node to verify if it's an HTMLTable. + * @returns {boolean} + */ + +function isHTMLTable(element) { + return (element && element.nodeName || '') === 'TABLE'; +} +/** + * Converts Handsontable into HTMLTableElement. + * + * @param {Core} instance The Handsontable instance. + * @returns {string} OuterHTML of the HTMLTableElement. + */ + + +function instanceToHTML(instance) { + var hasColumnHeaders = instance.hasColHeaders(); + var hasRowHeaders = instance.hasRowHeaders(); + var coords = [hasColumnHeaders ? -1 : 0, hasRowHeaders ? -1 : 0, instance.countRows() - 1, instance.countCols() - 1]; + var data = instance.getData.apply(instance, coords); + var countRows = data.length; + var countCols = countRows > 0 ? data[0].length : 0; + var TABLE = ['
', '
']; + var THEAD = hasColumnHeaders ? ['', ''] : []; + var TBODY = ['', '']; + var rowModifier = hasRowHeaders ? 1 : 0; + var columnModifier = hasColumnHeaders ? 1 : 0; + + for (var row = 0; row < countRows; row += 1) { + var isColumnHeadersRow = hasColumnHeaders && row === 0; + var CELLS = []; + + for (var column = 0; column < countCols; column += 1) { + var isRowHeadersColumn = !isColumnHeadersRow && hasRowHeaders && column === 0; + var cell = ''; + + if (isColumnHeadersRow) { + cell = "".concat(instance.getColHeader(column - rowModifier), ""); + } else if (isRowHeadersColumn) { + cell = "".concat(instance.getRowHeader(row - columnModifier), ""); + } else { + var cellData = data[row][column]; + + var _instance$getCellMeta = instance.getCellMeta(row - rowModifier, column - columnModifier), + hidden = _instance$getCellMeta.hidden, + rowspan = _instance$getCellMeta.rowspan, + colspan = _instance$getCellMeta.colspan; + + if (!hidden) { + var attrs = []; + + if (rowspan) { + attrs.push("rowspan=\"".concat(rowspan, "\"")); + } + + if (colspan) { + attrs.push("colspan=\"".concat(colspan, "\"")); + } + + if (isEmpty(cellData)) { + cell = ""); + } else { + var value = cellData.toString().replace('<', '<').replace('>', '>').replace(/((\r\n|\n)?|\r\n|\n)/g, '
\r\n').replace(/\x20/gi, ' ').replace(/\t/gi, ' '); + cell = "").concat(value, ""); + } + } + } + + CELLS.push(cell); + } + + var TR = [''].concat(CELLS, ['']).join(''); + + if (isColumnHeadersRow) { + THEAD.splice(1, 0, TR); + } else { + TBODY.splice(-1, 0, TR); + } + } + + TABLE.splice(1, 0, THEAD.join(''), TBODY.join('')); + return TABLE.join(''); +} +/** + * Converts 2D array into HTMLTableElement. + * + * @param {Array} input Input array which will be converted to HTMLTable. + * @returns {string} OuterHTML of the HTMLTableElement. + */ +// eslint-disable-next-line no-restricted-globals + +function _dataToHTML(input) { + var inputLen = input.length; + var result = ['']; + + for (var row = 0; row < inputLen; row += 1) { + var rowData = input[row]; + var columnsLen = rowData.length; + var columnsResult = []; + + if (row === 0) { + result.push(''); + } + + for (var column = 0; column < columnsLen; column += 1) { + var cellData = rowData[column]; + var parsedCellData = isEmpty(cellData) ? '' : cellData.toString().replace(//g, '>').replace(/((\r\n|\n)?|\r\n|\n)/g, '
\r\n').replace(/\x20/gi, ' ').replace(/\t/gi, ' '); + columnsResult.push("")); + } + + result.push.apply(result, [''].concat(columnsResult, [''])); + + if (row + 1 === inputLen) { + result.push(''); + } + } + + result.push('
".concat(parsedCellData, "
'); + return result.join(''); +} +/** + * Converts HTMLTable or string into Handsontable configuration object. + * + * @param {Element|string} element Node element which should contain `...
`. + * @param {Document} [rootDocument] The document window owner. + * @returns {object} Return configuration object. Contains keys as DefaultSettings. + */ +// eslint-disable-next-line no-restricted-globals + +function htmlToGridSettings(element) { + var rootDocument = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document; + var settingsObj = {}; + var fragment = rootDocument.createDocumentFragment(); + var tempElem = rootDocument.createElement('div'); + fragment.appendChild(tempElem); + var checkElement = element; + + if (typeof checkElement === 'string') { + var escapedAdjacentHTML = checkElement.replace(/]*?>([\s\S]*?)<\/\s*td>/g, function (cellFragment) { + var openingTag = cellFragment.match(/]*?>/g)[0]; + var cellValue = cellFragment.substring(openingTag.length, cellFragment.lastIndexOf('<')).replace(/(<(?!br)([^>]+)>)/gi, ''); + var closingTag = ''; + return "".concat(openingTag).concat(cellValue).concat(closingTag); + }); + tempElem.insertAdjacentHTML('afterbegin', "".concat(escapedAdjacentHTML)); + checkElement = tempElem.querySelector('table'); + } + + if (!checkElement || !isHTMLTable(checkElement)) { + return; + } + + var generator = tempElem.querySelector('meta[name$="enerator"]'); + var hasRowHeaders = checkElement.querySelector('tbody th') !== null; + var trElement = checkElement.querySelector('tr'); + var countCols = !trElement ? 0 : Array.from(trElement.cells).reduce(function (cols, cell) { + return cols + cell.colSpan; + }, 0) - (hasRowHeaders ? 1 : 0); + var fixedRowsBottom = checkElement.tFoot && Array.from(checkElement.tFoot.rows) || []; + var fixedRowsTop = []; + var hasColHeaders = false; + var thRowsLen = 0; + var countRows = 0; + + if (checkElement.tHead) { + var thRows = Array.from(checkElement.tHead.rows).filter(function (tr) { + var isDataRow = tr.querySelector('td') !== null; + + if (isDataRow) { + fixedRowsTop.push(tr); + } + + return !isDataRow; + }); + thRowsLen = thRows.length; + hasColHeaders = thRowsLen > 0; + + if (thRowsLen > 1) { + settingsObj.nestedHeaders = Array.from(thRows).reduce(function (rows, row) { + var headersRow = Array.from(row.cells).reduce(function (headers, header, currentIndex) { + if (hasRowHeaders && currentIndex === 0) { + return headers; + } + + var colspan = header.colSpan, + innerHTML = header.innerHTML; + var nextHeader = colspan > 1 ? { + label: innerHTML, + colspan: colspan + } : innerHTML; + headers.push(nextHeader); + return headers; + }, []); + rows.push(headersRow); + return rows; + }, []); + } else if (hasColHeaders) { + settingsObj.colHeaders = Array.from(thRows[0].children).reduce(function (headers, header, index) { + if (hasRowHeaders && index === 0) { + return headers; + } + + headers.push(header.innerHTML); + return headers; + }, []); + } + } + + if (fixedRowsTop.length) { + settingsObj.fixedRowsTop = fixedRowsTop.length; + } + + if (fixedRowsBottom.length) { + settingsObj.fixedRowsBottom = fixedRowsBottom.length; + } + + var dataRows = [].concat(fixedRowsTop, _toConsumableArray$5(Array.from(checkElement.tBodies).reduce(function (sections, section) { + sections.push.apply(sections, _toConsumableArray$5(Array.from(section.rows))); + return sections; + }, [])), _toConsumableArray$5(fixedRowsBottom)); + countRows = dataRows.length; + var dataArr = new Array(countRows); + + for (var r = 0; r < countRows; r++) { + dataArr[r] = new Array(countCols); + } + + var mergeCells = []; + var rowHeaders = []; + + for (var row = 0; row < countRows; row++) { + var tr = dataRows[row]; + var cells = Array.from(tr.cells); + var cellsLen = cells.length; + + for (var cellId = 0; cellId < cellsLen; cellId++) { + var cell = cells[cellId]; + var nodeName = cell.nodeName, + innerHTML = cell.innerHTML, + rowspan = cell.rowSpan, + colspan = cell.colSpan; + var col = dataArr[row].findIndex(function (value) { + return value === void 0; + }); + + if (nodeName === 'TD') { + if (rowspan > 1 || colspan > 1) { + for (var rstart = row; rstart < row + rowspan; rstart++) { + if (rstart < countRows) { + for (var cstart = col; cstart < col + colspan; cstart++) { + dataArr[rstart][cstart] = null; + } + } + } + + var styleAttr = cell.getAttribute('style'); + var ignoreMerge = styleAttr && styleAttr.includes('mso-ignore:colspan'); + + if (!ignoreMerge) { + mergeCells.push({ + col: col, + row: row, + rowspan: rowspan, + colspan: colspan + }); + } + } + + var cellValue = ''; + + if (generator && /excel/gi.test(generator.content)) { + cellValue = innerHTML.replace(/[\r\n][\x20]{0,2}/g, '\x20').replace(/[\r\n]?[\x20]{0,3}/gim, '\r\n'); + } else { + cellValue = innerHTML.replace(/[\r\n]?/gim, '\r\n'); + } + + dataArr[row][col] = cellValue.replace(regEscapedChars, function (match) { + return ESCAPED_HTML_CHARS[match]; + }); + } else { + rowHeaders.push(innerHTML); + } + } + } + + if (mergeCells.length) { + settingsObj.mergeCells = mergeCells; + } + + if (rowHeaders.length) { + settingsObj.rowHeaders = rowHeaders; + } + + if (dataArr.length) { + settingsObj.data = dataArr; + } + + return settingsObj; +} + +var parseTableHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + instanceToHTML: instanceToHTML, + _dataToHTML: _dataToHTML, + htmlToGridSettings: htmlToGridSettings +}); + +function _typeof$o(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$o = function _typeof(obj) { return typeof obj; }; } else { _typeof$o = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$o(obj); } + +/** + * Checks if value of n is a numeric one + * http://jsperf.com/isnan-vs-isnumeric/4. + * + * @param {*} value The value to check. + * @returns {boolean} + */ +function isNumeric(value) { + /* eslint-disable */ + var t = _typeof$o(value); + + return t == 'number' ? !isNaN(value) && isFinite(value) : t == 'string' ? !value.length ? false : value.length == 1 ? /\d/.test(value) : /^\s*[+-]?\s*(?:(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?)|(?:0x[a-f\d]+))\s*$/i.test(value) : t == 'object' ? !!value && typeof value.valueOf() == 'number' && !(value instanceof Date) : false; +} +/** + * A specialized version of `.forEach` defined by ranges. + * + * @param {Number} rangeFrom The number from start iterate. + * @param {Number|Function} rangeTo The number where finish iterate or function as a iteratee. + * @param {Function} [iteratee] The function invoked per iteration. + */ + +function rangeEach(rangeFrom, rangeTo, iteratee) { + var index = -1; + + if (typeof rangeTo === 'function') { + iteratee = rangeTo; + rangeTo = rangeFrom; + } else { + index = rangeFrom - 1; + } + + while (++index <= rangeTo) { + if (iteratee(index) === false) { + break; + } + } +} +/** + * A specialized version of `.forEach` defined by ranges iterable in reverse order. + * + * @param {Number} rangeFrom The number from start iterate. + * @param {Number|Function} rangeTo The number where finish iterate or function as a iteratee. + * @param {Function} [iteratee] The function invoked per iteration. + */ + +function rangeEachReverse(rangeFrom, rangeTo, iteratee) { + var index = rangeFrom + 1; + + if (typeof rangeTo === 'function') { + iteratee = rangeTo; + rangeTo = 0; + } + + while (--index >= rangeTo) { + if (iteratee(index) === false) { + break; + } + } +} +/** + * Calculate value from percent. + * + * @param {Number} value Base value from percent will be calculated. + * @param {String|Number} percent Can be Number or String (eq. `'33%'`). + * @returns {Number} + */ + +function valueAccordingPercent(value, percent) { + percent = parseInt(percent.toString().replace('%', ''), 10); + percent = parseInt(value * percent / 100, 10); + return percent; +} + +var numberHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + isNumeric: isNumeric, + rangeEach: rangeEach, + rangeEachReverse: rangeEachReverse, + valueAccordingPercent: valueAccordingPercent +}); + +function _toConsumableArray$6(arr) { return _arrayWithoutHoles$4(arr) || _iterableToArray$4(arr) || _unsupportedIterableToArray$8(arr) || _nonIterableSpread$4(); } + +function _nonIterableSpread$4() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArray$4(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$4(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$8(arr); } + +function _slicedToArray$5(arr, i) { return _arrayWithHoles$5(arr) || _iterableToArrayLimit$5(arr, i) || _unsupportedIterableToArray$8(arr, i) || _nonIterableRest$5(); } + +function _nonIterableRest$5() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$8(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$8(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$8(o, minLen); } + +function _arrayLikeToArray$8(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$5(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$5(arr) { if (Array.isArray(arr)) return arr; } +var ASC = 'asc'; +var DESC = 'desc'; +var ORDER_MAP = new Map([[ASC, [-1, 1]], [DESC, [1, -1]]]); + +var DEFAULT_ERROR_PRIORITY_EXISTS = function DEFAULT_ERROR_PRIORITY_EXISTS(priority) { + return "The priority '".concat(priority, "' is already declared in a map."); +}; + +var DEFAULT_ERROR_PRIORITY_NAN = function DEFAULT_ERROR_PRIORITY_NAN(priority) { + return "The priority '".concat(priority, "' is not a number."); +}; +/** + * @typedef {object} PriorityMap + * @property {Function} addItem Adds items to the priority map. + * @property {Function} getItems Gets items from the passed map in a ASC or DESC order of priorities. + */ + +/** + * Creates a new priority map. + * + * @param {object} config The config for priority map. + * @param {Function} config.errorPriorityExists The function to generate a custom error message if priority is already taken. + * @param {Function} config.errorPriorityNan The function to generate a custom error message if priority is not a number. + * @returns {PriorityMap} + */ + + +function createPriorityMap() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + errorPriorityExists = _ref.errorPriorityExists, + errorPriorityNaN = _ref.errorPriorityNaN; + + var priorityMap = new Map(); + errorPriorityExists = isFunction(errorPriorityExists) ? errorPriorityExists : DEFAULT_ERROR_PRIORITY_EXISTS; + errorPriorityNaN = isFunction(errorPriorityNaN) ? errorPriorityNaN : DEFAULT_ERROR_PRIORITY_NAN; + /** + * Adds items to priority map. Throws an error if `priority` is not a number or if is already added. + * + * @param {number} priority The priority for adding item. + * @param {*} item The adding item. + */ + + function addItem(priority, item) { + if (!isNumeric(priority)) { + throw new Error(errorPriorityNaN(priority)); + } + + if (priorityMap.has(priority)) { + throw new Error(errorPriorityExists(priority)); + } + + priorityMap.set(priority, item); + } + /** + * Gets items from the passed map in a ASC or DESC order of priorities. + * + * @param {string} [order] The order for getting items. ASC is an default. + * @returns {*} + */ + + + function getItems() { + var order = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ASC; + + var _ref2 = ORDER_MAP.get(order) || ORDER_MAP.get(ASC), + _ref3 = _slicedToArray$5(_ref2, 2), + left = _ref3[0], + right = _ref3[1]; + + return _toConsumableArray$6(priorityMap) // we want to be sure we sort over a priority key + // if we are sure we can remove custom compare function + // then we should replace next line with a default `.sort()` + .sort(function (a, b) { + return a[0] < b[0] ? left : right; + }).map(function (item) { + return item[1]; + }); + } + + return { + addItem: addItem, + getItems: getItems + }; +} + +var $find = arrayIteration.find; + + +var FIND = 'find'; +var SKIPS_HOLES$1 = true; + +// Shouldn't skip holes +if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES$1 = false; }); + +// `Array.prototype.find` method +// https://tc39.es/ecma262/#sec-array.prototype.find +_export({ target: 'Array', proto: true, forced: SKIPS_HOLES$1 }, { + find: function find(callbackfn /* , that = undefined */) { + return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables(FIND); + +function _toConsumableArray$7(arr) { return _arrayWithoutHoles$5(arr) || _iterableToArray$5(arr) || _unsupportedIterableToArray$9(arr) || _nonIterableSpread$5(); } + +function _nonIterableSpread$5() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArray$5(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$5(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$9(arr); } + +function _slicedToArray$6(arr, i) { return _arrayWithHoles$6(arr) || _iterableToArrayLimit$6(arr, i) || _unsupportedIterableToArray$9(arr, i) || _nonIterableRest$6(); } + +function _nonIterableRest$6() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$9(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$9(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$9(o, minLen); } + +function _arrayLikeToArray$9(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$6(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$6(arr) { if (Array.isArray(arr)) return arr; } + +var DEFAULT_ERROR_ID_EXISTS = function DEFAULT_ERROR_ID_EXISTS(id) { + return "The id '".concat(id, "' is already declared in a map."); +}; +/** + * @typedef {object} UniqueMap + * @property {Function} addItem Adds a new item to the unique map. + * @property {Function} clear Clears the map. + * @property {Function} getId Returns ID for the passed item. + * @property {Function} getItem Gets item from the passed ID. + * @property {Function} getItems Gets all items from the map. + * @property {Function} hasItem Verifies if the passed ID exists in a map. + */ + +/** + * Creates a new unique map. + * + * @param {object} config The config for priority queue. + * @param {Function} config.errorItemExists The function to generate custom message. + * @param {Function} config.errorItemNotExists The function to generate custom message. + * @returns {UniqueMap} + */ + + +function createUniqueMap() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + errorIdExists = _ref.errorIdExists; + + var uniqueMap = new Map(); + errorIdExists = isFunction(errorIdExists) ? errorIdExists : DEFAULT_ERROR_ID_EXISTS; + /** + * Adds a new item to the unique map. Throws error if `id` is already added. + * + * @param {*} id The ID of the adding item. + * @param {*} item The adding item. + */ + + function addItem(id, item) { + if (hasItem(id)) { + throw new Error(errorIdExists(id)); + } + + uniqueMap.set(id, item); + } + /** + * Clears the map. + */ + + + function clear() { + uniqueMap.clear(); + } + /** + * Returns ID for the passed item. + * + * @param {*} item The item of the getting ID. + * @returns {*} + */ + + + function getId(item) { + var _ref2 = getItems().find(function (_ref4) { + var _ref5 = _slicedToArray$6(_ref4, 2), + id = _ref5[0], + element = _ref5[1]; + + if (item === element) { + return id; + } + + return false; + }) || [null], + _ref3 = _slicedToArray$6(_ref2, 1), + itemId = _ref3[0]; + + return itemId; + } + /** + * Returns item from the passed ID. + * + * @param {*} id The ID of the getting item. + * @returns {*} + */ + + + function getItem(id) { + return uniqueMap.get(id); + } + /** + * Gets all items from the map. + * + * @returns {Array} + */ + + + function getItems() { + return _toConsumableArray$7(uniqueMap); + } + /** + * Verifies if the passed ID exists in a map. + * + * @param {*} id The ID to check if registered. + * @returns {boolean} + */ + + + function hasItem(id) { + return uniqueMap.has(id); + } + + return { + addItem: addItem, + clear: clear, + getId: getId, + getItem: getItem, + getItems: getItems, + hasItem: hasItem + }; +} + +function _toConsumableArray$8(arr) { return _arrayWithoutHoles$6(arr) || _iterableToArray$6(arr) || _unsupportedIterableToArray$a(arr) || _nonIterableSpread$6(); } + +function _nonIterableSpread$6() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$a(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$a(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$a(o, minLen); } + +function _iterableToArray$6(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$6(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$a(arr); } + +function _arrayLikeToArray$a(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +var DEFAULT_ERROR_ITEM_EXISTS = function DEFAULT_ERROR_ITEM_EXISTS(item) { + return "'".concat(item, "' value is already declared in a unique set."); +}; +/** + * @typedef {object} UniqueSet + * @property {Function} addItem Adds items to the priority set. + * @property {Function} getItems Gets items from the set in order of addition. + */ + +/** + * Creates a new unique set. + * + * @param {object} config The config for priority set. + * @param {Function} config.errorItemExists The function to generate custom error message if item is already in the set. + * @returns {UniqueSet} + */ + + +function createUniqueSet() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + errorItemExists = _ref.errorItemExists; + + var uniqueSet = new Set(); + errorItemExists = isFunction(errorItemExists) ? errorItemExists : DEFAULT_ERROR_ITEM_EXISTS; + /** + * Adds items to the unique set. Throws an error if `item` is already added. + * + * @param {*} item The adding item. + */ + + function addItem(item) { + if (uniqueSet.has(item)) { + throw new Error(errorItemExists(item)); + } + + uniqueSet.add(item); + } + /** + * Gets items from the set in order of addition. + * + * @returns {*} + */ + + + function getItems() { + return _toConsumableArray$8(uniqueSet); + } + + return { + addItem: addItem, + getItems: getItems + }; +} + +function _slicedToArray$7(arr, i) { return _arrayWithHoles$7(arr) || _iterableToArrayLimit$7(arr, i) || _unsupportedIterableToArray$b(arr, i) || _nonIterableRest$7(); } + +function _nonIterableRest$7() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArrayLimit$7(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$7(arr) { if (Array.isArray(arr)) return arr; } + +function _toConsumableArray$9(arr) { return _arrayWithoutHoles$7(arr) || _iterableToArray$7(arr) || _unsupportedIterableToArray$b(arr) || _nonIterableSpread$7(); } + +function _nonIterableSpread$7() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$b(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$b(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$b(o, minLen); } + +function _iterableToArray$7(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$7(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$b(arr); } + +function _arrayLikeToArray$b(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +var ERROR_PLUGIN_REGISTERED = function ERROR_PLUGIN_REGISTERED(pluginName) { + return "There is already registered \"".concat(pluginName, "\" plugin."); +}; + +var ERROR_PRIORITY_REGISTERED = function ERROR_PRIORITY_REGISTERED(priority) { + return "There is already registered plugin on priority \"".concat(priority, "\"."); +}; + +var ERROR_PRIORITY_NAN = function ERROR_PRIORITY_NAN(priority) { + return "The priority \"".concat(priority, "\" is not a number."); +}; +/** + * Stores plugins' names' queue with their priorities. + */ + + +var priorityPluginsQueue = createPriorityMap({ + errorPriorityExists: ERROR_PRIORITY_REGISTERED, + errorPriorityNaN: ERROR_PRIORITY_NAN +}); +/** + * Stores plugins names' queue by registration order. + */ + +var uniquePluginsQueue = createUniqueSet({ + errorItemExists: ERROR_PLUGIN_REGISTERED +}); +/** + * Stores plugins references between their name and class. + */ + +var uniquePluginsList = createUniqueMap({ + errorIdExists: ERROR_PLUGIN_REGISTERED +}); +/** + * Gets registered plugins' names in the following order: + * 1) Plugins registered with a defined priority attribute, in the ascending order of priority. + * 2) Plugins registered without a defined priority attribute, in the registration order. + * + * @returns {string[]} + */ + +function getPluginsNames() { + return [].concat(_toConsumableArray$9(priorityPluginsQueue.getItems()), _toConsumableArray$9(uniquePluginsQueue.getItems())); +} +/** + * Gets registered plugin's class based on the given name. + * + * @param {string} pluginName Plugin's name. + * @returns {BasePlugin} + */ + +function getPlugin(pluginName) { + var unifiedPluginName = toUpperCaseFirst(pluginName); + return uniquePluginsList.getItem(unifiedPluginName); +} +/** + * Checks if the plugin under the name is already registered. + * + * @param {string} pluginName Plugin's name. + * @returns {boolean} + */ + +function hasPlugin(pluginName) { + /* eslint-disable no-unneeded-ternary */ + return getPlugin(pluginName) ? true : false; +} +/** + * Registers plugin under the given name only once. + * + * @param {string|Function} pluginName The plugin name or plugin class. + * @param {Function} [pluginClass] The plugin class. + * @param {number} [priority] The plugin priority. + */ + +function registerPlugin(pluginName, pluginClass, priority) { + var _unifyPluginArguments = unifyPluginArguments(pluginName, pluginClass, priority); + + var _unifyPluginArguments2 = _slicedToArray$7(_unifyPluginArguments, 3); + + pluginName = _unifyPluginArguments2[0]; + pluginClass = _unifyPluginArguments2[1]; + priority = _unifyPluginArguments2[2]; + + if (getPlugin(pluginName) === void 0) { + _registerPlugin(pluginName, pluginClass, priority); + } +} +/** + * Registers plugin under the given name. + * + * @param {string|Function} pluginName The plugin name or plugin class. + * @param {Function} [pluginClass] The plugin class. + * @param {number} [priority] The plugin priority. + */ + +function _registerPlugin(pluginName, pluginClass, priority) { + var unifiedPluginName = toUpperCaseFirst(pluginName); + + if (uniquePluginsList.hasItem(unifiedPluginName)) { + throw new Error(ERROR_PLUGIN_REGISTERED(unifiedPluginName)); + } + + if (priority === void 0) { + uniquePluginsQueue.addItem(unifiedPluginName); + } else { + priorityPluginsQueue.addItem(priority, unifiedPluginName); + } + + uniquePluginsList.addItem(unifiedPluginName, pluginClass); +} +/** + * Unifies arguments to register the plugin. + * + * @param {string|Function} pluginName The plugin name or plugin class. + * @param {Function} [pluginClass] The plugin class. + * @param {number} [priority] The plugin priority. + * @returns {Array} + */ + + +function unifyPluginArguments(pluginName, pluginClass, priority) { + if (typeof pluginName === 'function') { + pluginClass = pluginName; + pluginName = pluginClass.PLUGIN_KEY; + priority = pluginClass.PLUGIN_PRIORITY; + } + + return [pluginName, pluginClass, priority]; +} + +var _staticRegister$1 = staticRegister('renderers'), + register$1 = _staticRegister$1.register, + getItem$1 = _staticRegister$1.getItem, + hasItem$1 = _staticRegister$1.hasItem, + getNames$1 = _staticRegister$1.getNames; +/** + * Retrieve renderer function. + * + * @param {string} name Renderer identification. + * @returns {Function} Returns renderer function. + */ + + +function _getItem$1(name) { + if (typeof name === 'function') { + return name; + } + + if (!hasItem$1(name)) { + throw Error("No registered renderer found under \"".concat(name, "\" name")); + } + + return getItem$1(name); +} +/** + * Register renderer under its alias. + * + * @param {string|Function} name Renderer's alias or renderer function with its descriptor. + * @param {Function} [renderer] Renderer function. + */ + + +function _register$1(name, renderer) { + if (typeof name !== 'string') { + renderer = name; + name = renderer.RENDERER_TYPE; + } + + register$1(name, renderer); +} + +var _staticRegister$2 = staticRegister('validators'), + register$2 = _staticRegister$2.register, + getItem$2 = _staticRegister$2.getItem, + hasItem$2 = _staticRegister$2.hasItem, + getNames$2 = _staticRegister$2.getNames; +/** + * Retrieve validator function. + * + * @param {string} name Validator identification. + * @returns {Function} Returns validator function. + */ + + +function _getItem$2(name) { + if (typeof name === 'function') { + return name; + } + + if (!hasItem$2(name)) { + throw Error("No registered validator found under \"".concat(name, "\" name")); + } + + return getItem$2(name); +} +/** + * Register validator under its alias. + * + * @param {string|Function} name Validator's alias or validator function with its descriptor. + * @param {Function} [validator] Validator function. + */ + + +function _register$2(name, validator) { + if (typeof name !== 'string') { + validator = name; + name = validator.VALIDATOR_TYPE; + } + + register$2(name, validator); +} + +/** + * MouseDown handler. + * + * @param {object} options The handler options. + * @param {boolean} options.isShiftKey The flag which indicates if the shift key is pressed. + * @param {boolean} options.isLeftClick The flag which indicates if the left mouse button is pressed. + * @param {boolean} options.isRightClick The flag which indicates if the right mouse button is pressed. + * @param {CellRange} options.coords The CellCoords object with defined visual coordinates. + * @param {Selection} options.selection The Selection class instance. + * @param {object} options.controller An object with keys `row`, `column`, `cell` which indicate what + * operation will be performed in later selection stages. + */ + +function mouseDown(_ref) { + var isShiftKey = _ref.isShiftKey, + isLeftClick = _ref.isLeftClick, + isRightClick = _ref.isRightClick, + coords = _ref.coords, + selection = _ref.selection, + controller = _ref.controller; + var currentSelection = selection.isSelected() ? selection.getSelectedRange().current() : null; + var selectedCorner = selection.isSelectedByCorner(); + var selectedRow = selection.isSelectedByRowHeader(); + + if (isShiftKey && currentSelection) { + if (coords.row >= 0 && coords.col >= 0 && !controller.cells) { + selection.setRangeEnd(coords); + } else if ((selectedCorner || selectedRow) && coords.row >= 0 && coords.col >= 0 && !controller.cells) { + selection.setRangeEnd(new CellCoords(coords.row, coords.col)); + } else if (selectedCorner && coords.row < 0 && !controller.column) { + selection.setRangeEnd(new CellCoords(currentSelection.to.row, coords.col)); + } else if (selectedRow && coords.col < 0 && !controller.row) { + selection.setRangeEnd(new CellCoords(coords.row, currentSelection.to.col)); + } else if ((!selectedCorner && !selectedRow && coords.col < 0 || selectedCorner && coords.col < 0) && !controller.row) { + selection.selectRows(Math.max(currentSelection.from.row, 0), coords.row); + } else if ((!selectedCorner && !selectedRow && coords.row < 0 || selectedRow && coords.row < 0) && !controller.column) { + selection.selectColumns(Math.max(currentSelection.from.col, 0), coords.col); + } + } else { + var allowRightClickSelection = !selection.inInSelection(coords); + var performSelection = isLeftClick || isRightClick && allowRightClickSelection; // clicked row header and when some column was selected + + if (coords.row < 0 && coords.col >= 0 && !controller.column) { + if (performSelection) { + selection.selectColumns(coords.col); + } // clicked column header and when some row was selected + + } else if (coords.col < 0 && coords.row >= 0 && !controller.row) { + if (performSelection) { + selection.selectRows(coords.row); + } + } else if (coords.col >= 0 && coords.row >= 0 && !controller.cells) { + if (performSelection) { + selection.setRangeStart(coords); + } + } else if (coords.col < 0 && coords.row < 0) { + selection.selectAll(true, true); + } + } +} +/** + * MouseOver handler. + * + * @param {object} options The handler options. + * @param {boolean} options.isLeftClick Indicates that event was fired using the left mouse button. + * @param {CellRange} options.coords The CellCoords object with defined visual coordinates. + * @param {Selection} options.selection The Selection class instance. + * @param {object} options.controller An object with keys `row`, `column`, `cell` which indicate what + * operation will be performed in later selection stages. + */ + +function mouseOver(_ref2) { + var isLeftClick = _ref2.isLeftClick, + coords = _ref2.coords, + selection = _ref2.selection, + controller = _ref2.controller; + + if (!isLeftClick) { + return; + } + + var selectedRow = selection.isSelectedByRowHeader(); + var selectedColumn = selection.isSelectedByColumnHeader(); + var countCols = selection.tableProps.countCols(); + var countRows = selection.tableProps.countRows(); + + if (selectedColumn && !controller.column) { + selection.setRangeEnd(new CellCoords(countRows - 1, coords.col)); + } else if (selectedRow && !controller.row) { + selection.setRangeEnd(new CellCoords(coords.row, countCols - 1)); + } else if (!controller.cell) { + selection.setRangeEnd(coords); + } +} +var handlers = new Map([['mousedown', mouseDown], ['mouseover', mouseOver], ['touchstart', mouseDown]]); +/** + * Mouse handler for selection functionality. + * + * @param {Event} event An native event to handle. + * @param {object} options The handler options. + * @param {CellRange} options.coords The CellCoords object with defined visual coordinates. + * @param {Selection} options.selection The Selection class instance. + * @param {object} options.controller An object with keys `row`, `column`, `cell` which indicate what + * operation will be performed in later selection stages. + */ + +function handleMouseEvent(event, _ref3) { + var coords = _ref3.coords, + selection = _ref3.selection, + controller = _ref3.controller; + handlers.get(event.type)({ + coords: coords, + selection: selection, + controller: controller, + isShiftKey: event.shiftKey, + isLeftClick: isLeftClick(event) || event.type === 'touchstart', + isRightClick: isRightClick(event) + }); +} + +function _slicedToArray$8(arr, i) { return _arrayWithHoles$8(arr) || _iterableToArrayLimit$8(arr, i) || _unsupportedIterableToArray$c(arr, i) || _nonIterableRest$8(); } + +function _nonIterableRest$8() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArrayLimit$8(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$8(arr) { if (Array.isArray(arr)) return arr; } + +function _construct$5(Parent, args, Class) { if (_isNativeReflectConstruct$i()) { _construct$5 = Reflect.construct; } else { _construct$5 = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf$i(instance, Class.prototype); return instance; }; } return _construct$5.apply(null, arguments); } + +function _isNativeReflectConstruct$i() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _setPrototypeOf$i(o, p) { _setPrototypeOf$i = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$i(o, p); } + +function _toConsumableArray$a(arr) { return _arrayWithoutHoles$8(arr) || _iterableToArray$8(arr) || _unsupportedIterableToArray$c(arr) || _nonIterableSpread$8(); } + +function _nonIterableSpread$8() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$c(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$c(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$c(o, minLen); } + +function _iterableToArray$8(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$8(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$c(arr); } + +function _arrayLikeToArray$c(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$K(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$F(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); } } + +function _createClass$F(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$F(Constructor.prototype, protoProps); if (staticProps) _defineProperties$F(Constructor, staticProps); return Constructor; } +var privatePool$3 = new WeakMap(); +/** + * @class TableView + * @private + */ + +var TableView = /*#__PURE__*/function () { + /** + * @param {Hanstontable} instance Instance of {@link Handsontable}. + */ + function TableView(instance) { + _classCallCheck$K(this, TableView); + + /** + * Instance of {@link Handsontable}. + * + * @private + * @type {Handsontable} + */ + this.instance = instance; + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + this.eventManager = new EventManager(instance); + /** + * Current Handsontable's GridSettings object. + * + * @private + * @type {GridSettings} + */ + + this.settings = instance.getSettings(); + /** + * Main element. + * + * @type {HTMLTableSectionElement} + */ + + this.THEAD = void 0; + /** + * Main element. + * + * @type {HTMLTableSectionElement} + */ + + this.TBODY = void 0; + /** + * Main Walkontable instance. + * + * @type {Walkontable} + */ + + this.wt = void 0; + /** + * Main Walkontable instance. + * + * @private + * @type {Walkontable} + */ + + this.activeWt = void 0; + /** + * The flag determines if the `adjustElementsSize` method call was made during + * the render suspending. If true, the method has to be triggered once after render + * resuming. + * + * @private + * @type {boolean} + */ + + this.postponedAdjustElementsSize = false; + privatePool$3.set(this, { + /** + * Defines if the text should be selected during mousemove. + * + * @private + * @type {boolean} + */ + selectionMouseDown: false, + + /** + * @private + * @type {boolean} + */ + mouseDown: void 0, + + /** + * Main element. + * + * @private + * @type {HTMLTableElement} + */ + table: void 0, + + /** + * Cached width of the rootElement. + * + * @type {number} + */ + lastWidth: 0, + + /** + * Cached height of the rootElement. + * + * @type {number} + */ + lastHeight: 0 + }); + this.createElements(); + this.registerEvents(); + this.initializeWalkontable(); + } + /** + * Renders WalkontableUI. + */ + + + _createClass$F(TableView, [{ + key: "render", + value: function render() { + if (!this.instance.isRenderSuspended()) { + if (this.postponedAdjustElementsSize) { + this.postponedAdjustElementsSize = false; + this.adjustElementsSize(true); + } + + this.wt.draw(!this.instance.forceFullRender); + this.instance.forceFullRender = false; + this.instance.renderCall = false; + } + } + /** + * Adjust overlays elements size and master table size. + * + * @param {boolean} [force=false] When `true`, it adjust the DOM nodes sizes for all overlays. + */ + + }, { + key: "adjustElementsSize", + value: function adjustElementsSize() { + var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + if (this.instance.isRenderSuspended()) { + this.postponedAdjustElementsSize = true; + } else { + this.wt.wtOverlays.adjustElementsSize(force); + } + } + /** + * Returns td object given coordinates. + * + * @param {CellCoords} coords Renderable cell coordinates. + * @param {boolean} topmost Indicates whether the cell should be calculated from the topmost. + * @returns {HTMLTableCellElement|null} + */ + + }, { + key: "getCellAtCoords", + value: function getCellAtCoords(coords, topmost) { + var td = this.wt.getCell(coords, topmost); + + if (td < 0) { + // there was an exit code (cell is out of bounds) + return null; + } + + return td; + } + /** + * Scroll viewport to a cell. + * + * @param {CellCoords} coords Renderable cell coordinates. + * @param {boolean} [snapToTop] If `true`, viewport is scrolled to show the cell on the top of the table. + * @param {boolean} [snapToRight] If `true`, viewport is scrolled to show the cell on the right side of the table. + * @param {boolean} [snapToBottom] If `true`, viewport is scrolled to show the cell on the bottom side of the table. + * @param {boolean} [snapToLeft] If `true`, viewport is scrolled to show the cell on the left side of the table. + * @returns {boolean} + */ + + }, { + key: "scrollViewport", + value: function scrollViewport(coords, snapToTop, snapToRight, snapToBottom, snapToLeft) { + return this.wt.scrollViewport(coords, snapToTop, snapToRight, snapToBottom, snapToLeft); + } + /** + * Scroll viewport to a column. + * + * @param {number} column Renderable column index. + * @param {boolean} [snapToRight] If `true`, viewport is scrolled to show the cell on the right side of the table. + * @param {boolean} [snapToLeft] If `true`, viewport is scrolled to show the cell on the left side of the table. + * @returns {boolean} + */ + + }, { + key: "scrollViewportHorizontally", + value: function scrollViewportHorizontally(column, snapToRight, snapToLeft) { + return this.wt.scrollViewportHorizontally(column, snapToRight, snapToLeft); + } + /** + * Scroll viewport to a row. + * + * @param {number} row Renderable row index. + * @param {boolean} [snapToTop] If `true`, viewport is scrolled to show the cell on the top of the table. + * @param {boolean} [snapToBottom] If `true`, viewport is scrolled to show the cell on the bottom side of the table. + * @returns {boolean} + */ + + }, { + key: "scrollViewportVertically", + value: function scrollViewportVertically(row, snapToTop, snapToBottom) { + return this.wt.scrollViewportVertically(row, snapToTop, snapToBottom); + } + /** + * Prepares DOMElements and adds correct className to the root element. + * + * @private + */ + + }, { + key: "createElements", + value: function createElements() { + var priv = privatePool$3.get(this); + var _this$instance = this.instance, + rootElement = _this$instance.rootElement, + rootDocument = _this$instance.rootDocument; + var originalStyle = rootElement.getAttribute('style'); + + if (originalStyle) { + rootElement.setAttribute('data-originalstyle', originalStyle); // needed to retrieve original style in jsFiddle link generator in HT examples. may be removed in future versions + } + + addClass(rootElement, 'handsontable'); + priv.table = rootDocument.createElement('TABLE'); + addClass(priv.table, 'htCore'); + + if (this.instance.getSettings().tableClassName) { + addClass(priv.table, this.instance.getSettings().tableClassName); + } + + this.THEAD = rootDocument.createElement('THEAD'); + priv.table.appendChild(this.THEAD); + this.TBODY = rootDocument.createElement('TBODY'); + priv.table.appendChild(this.TBODY); + this.instance.table = priv.table; + this.instance.container.insertBefore(priv.table, this.instance.container.firstChild); + } + /** + * Attaches necessary listeners. + * + * @private + */ + + }, { + key: "registerEvents", + value: function registerEvents() { + var _this = this; + + var priv = privatePool$3.get(this); + var _this$instance2 = this.instance, + rootElement = _this$instance2.rootElement, + rootDocument = _this$instance2.rootDocument, + selection = _this$instance2.selection; + var documentElement = rootDocument.documentElement; + this.eventManager.addEventListener(rootElement, 'mousedown', function (event) { + priv.selectionMouseDown = true; + + if (!_this.isTextSelectionAllowed(event.target)) { + var rootWindow = _this.instance.rootWindow; + clearTextSelection(rootWindow); + event.preventDefault(); + rootWindow.focus(); // make sure that window that contains HOT is active. Important when HOT is in iframe. + } + }); + this.eventManager.addEventListener(rootElement, 'mouseup', function () { + priv.selectionMouseDown = false; + }); + this.eventManager.addEventListener(rootElement, 'mousemove', function (event) { + if (priv.selectionMouseDown && !_this.isTextSelectionAllowed(event.target)) { + // Clear selection only when fragmentSelection is enabled, otherwise clearing selection breakes the IME editor. + if (_this.settings.fragmentSelection) { + clearTextSelection(_this.instance.rootWindow); + } + + event.preventDefault(); + } + }); + this.eventManager.addEventListener(documentElement, 'keyup', function (event) { + if (selection.isInProgress() && !event.shiftKey) { + selection.finish(); + } + }); + this.eventManager.addEventListener(documentElement, 'mouseup', function (event) { + if (selection.isInProgress() && isLeftClick(event)) { + // is left mouse button + selection.finish(); + } + + priv.mouseDown = false; + + if (isOutsideInput(rootDocument.activeElement) || !selection.isSelected() && !selection.isSelectedByAnyHeader() && !rootElement.contains(event.target) && !isRightClick(event)) { + _this.instance.unlisten(); + } + }); + this.eventManager.addEventListener(documentElement, 'contextmenu', function (event) { + if (selection.isInProgress() && isRightClick(event)) { + selection.finish(); + priv.mouseDown = false; + } + }); + this.eventManager.addEventListener(documentElement, 'touchend', function () { + if (selection.isInProgress()) { + selection.finish(); + } + + priv.mouseDown = false; + }); + this.eventManager.addEventListener(documentElement, 'mousedown', function (event) { + var originalTarget = event.target; + var eventX = event.x || event.clientX; + var eventY = event.y || event.clientY; + var next = event.target; + + if (priv.mouseDown || !rootElement || !_this.instance.view) { + return; // it must have been started in a cell + } // immediate click on "holder" means click on the right side of vertical scrollbar + + + var holder = _this.instance.view.wt.wtTable.holder; + + if (next === holder) { + var scrollbarWidth = getScrollbarWidth(rootDocument); + + if (rootDocument.elementFromPoint(eventX + scrollbarWidth, eventY) !== holder || rootDocument.elementFromPoint(eventX, eventY + scrollbarWidth) !== holder) { + return; + } + } else { + while (next !== documentElement) { + if (next === null) { + if (event.isTargetWebComponent) { + break; + } // click on something that was a row but now is detached (possibly because your click triggered a rerender) + + + return; + } + + if (next === rootElement) { + // click inside container + return; + } + + next = next.parentNode; + } + } // function did not return until here, we have an outside click! + + + var outsideClickDeselects = typeof _this.settings.outsideClickDeselects === 'function' ? _this.settings.outsideClickDeselects(originalTarget) : _this.settings.outsideClickDeselects; + + if (outsideClickDeselects) { + _this.instance.deselectCell(); + } else { + _this.instance.destroyEditor(false, false); + } + }); + this.eventManager.addEventListener(priv.table, 'selectstart', function (event) { + if (_this.settings.fragmentSelection || isInput(event.target)) { + return; + } // https://github.com/handsontable/handsontable/issues/160 + // Prevent text from being selected when performing drag down. + + + event.preventDefault(); + }); + } + /** + * Translate renderable cell coordinates to visual coordinates. + * + * @param {CellCoords} coords The cell coordinates. + * @returns {CellCoords} + */ + + }, { + key: "translateFromRenderableToVisualCoords", + value: function translateFromRenderableToVisualCoords(_ref) { + var row = _ref.row, + col = _ref.col; + // TODO: To consider an idea to reusing the CellCoords instance instead creating new one. + return _construct$5(CellCoords, _toConsumableArray$a(this.translateFromRenderableToVisualIndex(row, col))); + } + /** + * Translate renderable row and column indexes to visual row and column indexes. + * + * @param {number} renderableRow Renderable row index. + * @param {number} renderableColumn Renderable columnIndex. + * @returns {number[]} + */ + + }, { + key: "translateFromRenderableToVisualIndex", + value: function translateFromRenderableToVisualIndex(renderableRow, renderableColumn) { + // TODO: Some helper may be needed. + // We perform translation for indexes (without headers). + var visualRow = renderableRow >= 0 ? this.instance.rowIndexMapper.getVisualFromRenderableIndex(renderableRow) : renderableRow; + var visualColumn = renderableColumn >= 0 ? this.instance.columnIndexMapper.getVisualFromRenderableIndex(renderableColumn) : renderableColumn; + + if (visualRow === null) { + visualRow = renderableRow; + } + + if (visualColumn === null) { + visualColumn = renderableColumn; + } + + return [visualRow, visualColumn]; + } + /** + * Returns the number of renderable columns. + * + * @returns {number} + */ + + }, { + key: "countRenderableColumns", + value: function countRenderableColumns() { + return Math.min(this.instance.columnIndexMapper.getRenderableIndexesLength(), this.settings.maxCols); + } + /** + * Returns the number of renderable rows. + * + * @returns {number} + */ + + }, { + key: "countRenderableRows", + value: function countRenderableRows() { + return Math.min(this.instance.rowIndexMapper.getRenderableIndexesLength(), this.settings.maxRows); + } + /** + * Returns number of not hidden row indexes counting from the passed starting index. + * The counting direction can be controlled by `incrementBy` argument. + * + * @param {number} visualIndex The visual index from which the counting begins. + * @param {number} incrementBy If `-1` then counting is backwards or forward when `1`. + * @returns {number} + */ + + }, { + key: "countNotHiddenRowIndexes", + value: function countNotHiddenRowIndexes(visualIndex, incrementBy) { + return this.countNotHiddenIndexes(visualIndex, incrementBy, this.instance.rowIndexMapper, this.countRenderableRows()); + } + /** + * Returns number of not hidden column indexes counting from the passed starting index. + * The counting direction can be controlled by `incrementBy` argument. + * + * @param {number} visualIndex The visual index from which the counting begins. + * @param {number} incrementBy If `-1` then counting is backwards or forward when `1`. + * @returns {number} + */ + + }, { + key: "countNotHiddenColumnIndexes", + value: function countNotHiddenColumnIndexes(visualIndex, incrementBy) { + return this.countNotHiddenIndexes(visualIndex, incrementBy, this.instance.columnIndexMapper, this.countRenderableColumns()); + } + /** + * Returns number of not hidden indexes counting from the passed starting index. + * The counting direction can be controlled by `incrementBy` argument. + * + * @param {number} visualIndex The visual index from which the counting begins. + * @param {number} incrementBy If `-1` then counting is backwards or forward when `1`. + * @param {IndexMapper} indexMapper The IndexMapper instance for specific axis. + * @param {number} renderableIndexesCount Total count of renderable indexes for specific axis. + * @returns {number} + */ + + }, { + key: "countNotHiddenIndexes", + value: function countNotHiddenIndexes(visualIndex, incrementBy, indexMapper, renderableIndexesCount) { + if (isNaN(visualIndex) || visualIndex < 0) { + return 0; + } + + var firstVisibleIndex = indexMapper.getFirstNotHiddenIndex(visualIndex, incrementBy); + var renderableIndex = indexMapper.getRenderableFromVisualIndex(firstVisibleIndex); + + if (!Number.isInteger(renderableIndex)) { + return 0; + } + + var notHiddenIndexes = 0; + + if (incrementBy < 0) { + // Zero-based numbering for renderable indexes corresponds to a number of not hidden indexes. + notHiddenIndexes = renderableIndex + 1; + } else if (incrementBy > 0) { + notHiddenIndexes = renderableIndexesCount - renderableIndex; + } + + return notHiddenIndexes; + } + /** + * Defines default configuration and initializes WalkOnTable intance. + * + * @private + */ + + }, { + key: "initializeWalkontable", + value: function initializeWalkontable() { + var _this2 = this; + + var priv = privatePool$3.get(this); + var walkontableConfig = { + externalRowCalculator: this.instance.getPlugin('autoRowSize') && this.instance.getPlugin('autoRowSize').isEnabled(), + table: priv.table, + preventOverflow: function preventOverflow() { + return _this2.settings.preventOverflow; + }, + preventWheel: function preventWheel() { + return _this2.settings.preventWheel; + }, + stretchH: function stretchH() { + return _this2.settings.stretchH; + }, + data: function data(renderableRow, renderableColumn) { + var _this2$instance; + + return (_this2$instance = _this2.instance).getDataAtCell.apply(_this2$instance, _toConsumableArray$a(_this2.translateFromRenderableToVisualIndex(renderableRow, renderableColumn))); + }, + totalRows: function totalRows() { + return _this2.countRenderableRows(); + }, + totalColumns: function totalColumns() { + return _this2.countRenderableColumns(); + }, + // Number of renderable columns for the left overlay. + fixedColumnsLeft: function fixedColumnsLeft() { + var countCols = _this2.instance.countCols(); + + var visualFixedColumnsLeft = Math.min(parseInt(_this2.settings.fixedColumnsLeft, 10), countCols) - 1; + return _this2.countNotHiddenColumnIndexes(visualFixedColumnsLeft, -1); + }, + // Number of renderable rows for the top overlay. + fixedRowsTop: function fixedRowsTop() { + var countRows = _this2.instance.countRows(); + + var visualFixedRowsTop = Math.min(parseInt(_this2.settings.fixedRowsTop, 10), countRows) - 1; + return _this2.countNotHiddenRowIndexes(visualFixedRowsTop, -1); + }, + // Number of renderable rows for the bottom overlay. + fixedRowsBottom: function fixedRowsBottom() { + var countRows = _this2.instance.countRows(); + + var visualFixedRowsBottom = Math.max(countRows - parseInt(_this2.settings.fixedRowsBottom, 10), 0); + return _this2.countNotHiddenRowIndexes(visualFixedRowsBottom, 1); + }, + // Enable the left overlay when conditions are met. + shouldRenderLeftOverlay: function shouldRenderLeftOverlay() { + return _this2.settings.fixedColumnsLeft > 0 || walkontableConfig.rowHeaders().length > 0; + }, + // Enable the top overlay when conditions are met. + shouldRenderTopOverlay: function shouldRenderTopOverlay() { + return _this2.settings.fixedRowsTop > 0 || walkontableConfig.columnHeaders().length > 0; + }, + // Enable the bottom overlay when conditions are met. + shouldRenderBottomOverlay: function shouldRenderBottomOverlay() { + return _this2.settings.fixedRowsBottom > 0; + }, + minSpareRows: function minSpareRows() { + return _this2.settings.minSpareRows; + }, + renderAllRows: this.settings.renderAllRows, + rowHeaders: function rowHeaders() { + var headerRenderers = []; + + if (_this2.instance.hasRowHeaders()) { + headerRenderers.push(function (renderableRowIndex, TH) { + // TODO: Some helper may be needed. + // We perform translation for row indexes (without row headers). + var visualRowIndex = renderableRowIndex >= 0 ? _this2.instance.rowIndexMapper.getVisualFromRenderableIndex(renderableRowIndex) : renderableRowIndex; + + _this2.appendRowHeader(visualRowIndex, TH); + }); + } + + _this2.instance.runHooks('afterGetRowHeaderRenderers', headerRenderers); + + return headerRenderers; + }, + columnHeaders: function columnHeaders() { + var headerRenderers = []; + + if (_this2.instance.hasColHeaders()) { + headerRenderers.push(function (renderedColumnIndex, TH) { + // TODO: Some helper may be needed. + // We perform translation for columns indexes (without column headers). + var visualColumnsIndex = renderedColumnIndex >= 0 ? _this2.instance.columnIndexMapper.getVisualFromRenderableIndex(renderedColumnIndex) : renderedColumnIndex; + + _this2.appendColHeader(visualColumnsIndex, TH); + }); + } + + _this2.instance.runHooks('afterGetColumnHeaderRenderers', headerRenderers); + + return headerRenderers; + }, + columnWidth: function columnWidth(renderedColumnIndex) { + var visualIndex = _this2.instance.columnIndexMapper.getVisualFromRenderableIndex(renderedColumnIndex); // It's not a bug that we can't find visual index for some handled by method indexes. The function is called also + // for not displayed indexes (beyond the table boundaries), i.e. when `fixedColumnsLeft` > `startCols` (wrong config?) or + // scrolling and dataset is empty (scroll should handle that?). + + + return _this2.instance.getColWidth(visualIndex === null ? renderedColumnIndex : visualIndex); + }, + rowHeight: function rowHeight(renderedRowIndex) { + var visualIndex = _this2.instance.rowIndexMapper.getVisualFromRenderableIndex(renderedRowIndex); + + return _this2.instance.getRowHeight(visualIndex === null ? renderedRowIndex : visualIndex); + }, + cellRenderer: function cellRenderer(renderedRowIndex, renderedColumnIndex, TD) { + var _this2$translateFromR = _this2.translateFromRenderableToVisualIndex(renderedRowIndex, renderedColumnIndex), + _this2$translateFromR2 = _slicedToArray$8(_this2$translateFromR, 2), + visualRowIndex = _this2$translateFromR2[0], + visualColumnIndex = _this2$translateFromR2[1]; // Coords may be modified. For example, by the `MergeCells` plugin. It should affect cell value and cell meta. + + + var modifiedCellCoords = _this2.instance.runHooks('modifyGetCellCoords', visualRowIndex, visualColumnIndex); + + var visualRowToCheck = visualRowIndex; + var visualColumnToCheck = visualColumnIndex; + + if (Array.isArray(modifiedCellCoords)) { + var _modifiedCellCoords = _slicedToArray$8(modifiedCellCoords, 2); + + visualRowToCheck = _modifiedCellCoords[0]; + visualColumnToCheck = _modifiedCellCoords[1]; + } + + var cellProperties = _this2.instance.getCellMeta(visualRowToCheck, visualColumnToCheck); + + var prop = _this2.instance.colToProp(visualColumnToCheck); + + var value = _this2.instance.getDataAtRowProp(visualRowToCheck, prop); + + if (_this2.instance.hasHook('beforeValueRender')) { + value = _this2.instance.runHooks('beforeValueRender', value, cellProperties); + } + + _this2.instance.runHooks('beforeRenderer', TD, visualRowIndex, visualColumnIndex, prop, value, cellProperties); + + _this2.instance.getCellRenderer(cellProperties)(_this2.instance, TD, visualRowIndex, visualColumnIndex, prop, value, cellProperties); + + _this2.instance.runHooks('afterRenderer', TD, visualRowIndex, visualColumnIndex, prop, value, cellProperties); + }, + selections: this.instance.selection.highlight, + hideBorderOnMouseDownOver: function hideBorderOnMouseDownOver() { + return _this2.settings.fragmentSelection; + }, + onWindowResize: function onWindowResize() { + if (!_this2.instance || _this2.instance.isDestroyed) { + return; + } + + _this2.instance.refreshDimensions(); + }, + onCellMouseDown: function onCellMouseDown(event, coords, TD, wt) { + var visualCoords = _this2.translateFromRenderableToVisualCoords(coords); + + var blockCalculations = { + row: false, + column: false, + cell: false + }; + + _this2.instance.listen(); + + _this2.activeWt = wt; + priv.mouseDown = true; + + _this2.instance.runHooks('beforeOnCellMouseDown', event, visualCoords, TD, blockCalculations); + + if (isImmediatePropagationStopped(event)) { + return; + } + + handleMouseEvent(event, { + coords: visualCoords, + selection: _this2.instance.selection, + controller: blockCalculations + }); + + _this2.instance.runHooks('afterOnCellMouseDown', event, visualCoords, TD); + + _this2.activeWt = _this2.wt; + }, + onCellContextMenu: function onCellContextMenu(event, coords, TD, wt) { + var visualCoords = _this2.translateFromRenderableToVisualCoords(coords); + + _this2.activeWt = wt; + priv.mouseDown = false; + + if (_this2.instance.selection.isInProgress()) { + _this2.instance.selection.finish(); + } + + _this2.instance.runHooks('beforeOnCellContextMenu', event, visualCoords, TD); + + if (isImmediatePropagationStopped(event)) { + return; + } + + _this2.instance.runHooks('afterOnCellContextMenu', event, visualCoords, TD); + + _this2.activeWt = _this2.wt; + }, + onCellMouseOut: function onCellMouseOut(event, coords, TD, wt) { + var visualCoords = _this2.translateFromRenderableToVisualCoords(coords); + + _this2.activeWt = wt; + + _this2.instance.runHooks('beforeOnCellMouseOut', event, visualCoords, TD); + + if (isImmediatePropagationStopped(event)) { + return; + } + + _this2.instance.runHooks('afterOnCellMouseOut', event, visualCoords, TD); + + _this2.activeWt = _this2.wt; + }, + onCellMouseOver: function onCellMouseOver(event, coords, TD, wt) { + var visualCoords = _this2.translateFromRenderableToVisualCoords(coords); + + var blockCalculations = { + row: false, + column: false, + cell: false + }; + _this2.activeWt = wt; + + _this2.instance.runHooks('beforeOnCellMouseOver', event, visualCoords, TD, blockCalculations); + + if (isImmediatePropagationStopped(event)) { + return; + } + + if (priv.mouseDown) { + handleMouseEvent(event, { + coords: visualCoords, + selection: _this2.instance.selection, + controller: blockCalculations + }); + } + + _this2.instance.runHooks('afterOnCellMouseOver', event, visualCoords, TD); + + _this2.activeWt = _this2.wt; + }, + onCellMouseUp: function onCellMouseUp(event, coords, TD, wt) { + var visualCoords = _this2.translateFromRenderableToVisualCoords(coords); + + _this2.activeWt = wt; + + _this2.instance.runHooks('beforeOnCellMouseUp', event, visualCoords, TD); + + if (isImmediatePropagationStopped(event)) { + return; + } + + _this2.instance.runHooks('afterOnCellMouseUp', event, visualCoords, TD); + + _this2.activeWt = _this2.wt; + }, + onCellCornerMouseDown: function onCellCornerMouseDown(event) { + event.preventDefault(); + + _this2.instance.runHooks('afterOnCellCornerMouseDown', event); + }, + onCellCornerDblClick: function onCellCornerDblClick(event) { + event.preventDefault(); + + _this2.instance.runHooks('afterOnCellCornerDblClick', event); + }, + beforeDraw: function beforeDraw(force, skipRender) { + return _this2.beforeRender(force, skipRender); + }, + onDraw: function onDraw(force) { + return _this2.onDraw(force); + }, + onScrollVertically: function onScrollVertically() { + return _this2.instance.runHooks('afterScrollVertically'); + }, + onScrollHorizontally: function onScrollHorizontally() { + return _this2.instance.runHooks('afterScrollHorizontally'); + }, + onBeforeRemoveCellClassNames: function onBeforeRemoveCellClassNames() { + return _this2.instance.runHooks('beforeRemoveCellClassNames'); + }, + onAfterDrawSelection: function onAfterDrawSelection(currentRow, currentColumn, layerLevel) { + var cornersOfSelection; + + var _this2$translateFromR3 = _this2.translateFromRenderableToVisualIndex(currentRow, currentColumn), + _this2$translateFromR4 = _slicedToArray$8(_this2$translateFromR3, 2), + visualRowIndex = _this2$translateFromR4[0], + visualColumnIndex = _this2$translateFromR4[1]; + + var selectedRange = _this2.instance.selection.getSelectedRange(); + + var selectionRangeSize = selectedRange.size(); + + if (selectionRangeSize > 0) { + // Selection layers are stored from the "oldest" to the "newest". We should calculate the offset. + // Please look at the `SelectedRange` class and it's method for getting selection's layer for more information. + var selectionOffset = (layerLevel !== null && layerLevel !== void 0 ? layerLevel : 0) + 1 - selectionRangeSize; + var selectionForLayer = selectedRange.peekByIndex(selectionOffset); + cornersOfSelection = [selectionForLayer.from.row, selectionForLayer.from.col, selectionForLayer.to.row, selectionForLayer.to.col]; + } + + return _this2.instance.runHooks('afterDrawSelection', visualRowIndex, visualColumnIndex, cornersOfSelection, layerLevel); + }, + onBeforeDrawBorders: function onBeforeDrawBorders(corners, borderClassName) { + var _corners = _slicedToArray$8(corners, 4), + startRenderableRow = _corners[0], + startRenderableColumn = _corners[1], + endRenderableRow = _corners[2], + endRenderableColumn = _corners[3]; + + var visualCorners = [_this2.instance.rowIndexMapper.getVisualFromRenderableIndex(startRenderableRow), _this2.instance.columnIndexMapper.getVisualFromRenderableIndex(startRenderableColumn), _this2.instance.rowIndexMapper.getVisualFromRenderableIndex(endRenderableRow), _this2.instance.columnIndexMapper.getVisualFromRenderableIndex(endRenderableColumn)]; + return _this2.instance.runHooks('beforeDrawBorders', visualCorners, borderClassName); + }, + onBeforeTouchScroll: function onBeforeTouchScroll() { + return _this2.instance.runHooks('beforeTouchScroll'); + }, + onAfterMomentumScroll: function onAfterMomentumScroll() { + return _this2.instance.runHooks('afterMomentumScroll'); + }, + onBeforeStretchingColumnWidth: function onBeforeStretchingColumnWidth(stretchedWidth, renderedColumnIndex) { + var visualColumnIndex = _this2.instance.columnIndexMapper.getVisualFromRenderableIndex(renderedColumnIndex); + + return _this2.instance.runHooks('beforeStretchingColumnWidth', stretchedWidth, visualColumnIndex); + }, + onModifyRowHeaderWidth: function onModifyRowHeaderWidth(rowHeaderWidth) { + return _this2.instance.runHooks('modifyRowHeaderWidth', rowHeaderWidth); + }, + onModifyGetCellCoords: function onModifyGetCellCoords(renderableRowIndex, renderableColumnIndex, topmost) { + var rowMapper = _this2.instance.rowIndexMapper; + var columnMapper = _this2.instance.columnIndexMapper; // Callback handle also headers. We shouldn't translate them. + + var visualColumnIndex = renderableColumnIndex >= 0 ? columnMapper.getVisualFromRenderableIndex(renderableColumnIndex) : renderableColumnIndex; + var visualRowIndex = renderableRowIndex >= 0 ? rowMapper.getVisualFromRenderableIndex(renderableRowIndex) : renderableRowIndex; + + var visualIndexes = _this2.instance.runHooks('modifyGetCellCoords', visualRowIndex, visualColumnIndex, topmost); + + if (Array.isArray(visualIndexes)) { + var _visualIndexes = _slicedToArray$8(visualIndexes, 4), + visualRowFrom = _visualIndexes[0], + visualColumnFrom = _visualIndexes[1], + visualRowTo = _visualIndexes[2], + visualColumnTo = _visualIndexes[3]; // Result of the hook is handled by the Walkontable (renderable indexes). + + + return [visualRowFrom >= 0 ? rowMapper.getRenderableFromVisualIndex(rowMapper.getFirstNotHiddenIndex(visualRowFrom, 1)) : visualRowFrom, visualColumnFrom >= 0 ? columnMapper.getRenderableFromVisualIndex(columnMapper.getFirstNotHiddenIndex(visualColumnFrom, 1)) : visualColumnFrom, visualRowTo >= 0 ? rowMapper.getRenderableFromVisualIndex(rowMapper.getFirstNotHiddenIndex(visualRowTo, -1)) : visualRowTo, visualColumnTo >= 0 ? columnMapper.getRenderableFromVisualIndex(columnMapper.getFirstNotHiddenIndex(visualColumnTo, -1)) : visualColumnTo]; + } + }, + viewportRowCalculatorOverride: function viewportRowCalculatorOverride(calc) { + var viewportOffset = _this2.settings.viewportRowRenderingOffset; + + if (viewportOffset === 'auto' && _this2.settings.fixedRowsTop) { + viewportOffset = 10; + } + + if (viewportOffset > 0 || viewportOffset === 'auto') { + var rows = _this2.countRenderableRows(); + + if (typeof viewportOffset === 'number') { + calc.startRow = Math.max(calc.startRow - viewportOffset, 0); + calc.endRow = Math.min(calc.endRow + viewportOffset, rows - 1); + } else if (viewportOffset === 'auto') { + var center = calc.startRow + calc.endRow - calc.startRow; + var offset = Math.ceil(center / rows * 12); + calc.startRow = Math.max(calc.startRow - offset, 0); + calc.endRow = Math.min(calc.endRow + offset, rows - 1); + } + } + + _this2.instance.runHooks('afterViewportRowCalculatorOverride', calc); + }, + viewportColumnCalculatorOverride: function viewportColumnCalculatorOverride(calc) { + var viewportOffset = _this2.settings.viewportColumnRenderingOffset; + + if (viewportOffset === 'auto' && _this2.settings.fixedColumnsLeft) { + viewportOffset = 10; + } + + if (viewportOffset > 0 || viewportOffset === 'auto') { + var cols = _this2.countRenderableColumns(); + + if (typeof viewportOffset === 'number') { + calc.startColumn = Math.max(calc.startColumn - viewportOffset, 0); + calc.endColumn = Math.min(calc.endColumn + viewportOffset, cols - 1); + } + + if (viewportOffset === 'auto') { + var center = calc.startColumn + calc.endColumn - calc.startColumn; + var offset = Math.ceil(center / cols * 12); + calc.startRow = Math.max(calc.startColumn - offset, 0); + calc.endColumn = Math.min(calc.endColumn + offset, cols - 1); + } + } + + _this2.instance.runHooks('afterViewportColumnCalculatorOverride', calc); + }, + rowHeaderWidth: function rowHeaderWidth() { + return _this2.settings.rowHeaderWidth; + }, + columnHeaderHeight: function columnHeaderHeight() { + var columnHeaderHeight = _this2.instance.runHooks('modifyColumnHeaderHeight'); + + return _this2.settings.columnHeaderHeight || columnHeaderHeight; + } + }; + this.instance.runHooks('beforeInitWalkontable', walkontableConfig); + this.wt = new Walkontable(walkontableConfig); + this.activeWt = this.wt; + var spreader = this.wt.wtTable.spreader; // We have to cache width and height after Walkontable initialization. + + var _this$instance$rootEl = this.instance.rootElement.getBoundingClientRect(), + width = _this$instance$rootEl.width, + height = _this$instance$rootEl.height; + + this.setLastSize(width, height); + this.eventManager.addEventListener(spreader, 'mousedown', function (event) { + // right mouse button exactly on spreader means right click on the right hand side of vertical scrollbar + if (event.target === spreader && event.which === 3) { + event.stopPropagation(); + } + }); + this.eventManager.addEventListener(spreader, 'contextmenu', function (event) { + // right mouse button exactly on spreader means right click on the right hand side of vertical scrollbar + if (event.target === spreader && event.which === 3) { + event.stopPropagation(); + } + }); + this.eventManager.addEventListener(this.instance.rootDocument.documentElement, 'click', function () { + if (_this2.settings.observeDOMVisibility) { + if (_this2.wt.drawInterrupted) { + _this2.instance.forceFullRender = true; + + _this2.render(); + } + } + }); + } + /** + * Checks if it's possible to create text selection in element. + * + * @private + * @param {HTMLElement} el The element to check. + * @returns {boolean} + */ + + }, { + key: "isTextSelectionAllowed", + value: function isTextSelectionAllowed(el) { + if (isInput(el)) { + return true; + } + + var isChildOfTableBody = isChildOf(el, this.instance.view.wt.wtTable.spreader); + + if (this.settings.fragmentSelection === true && isChildOfTableBody) { + return true; + } + + if (this.settings.fragmentSelection === 'cell' && this.isSelectedOnlyCell() && isChildOfTableBody) { + return true; + } + + if (!this.settings.fragmentSelection && this.isCellEdited() && this.isSelectedOnlyCell()) { + return true; + } + + return false; + } + /** + * Checks if user's been called mousedown. + * + * @private + * @returns {boolean} + */ + + }, { + key: "isMouseDown", + value: function isMouseDown() { + return privatePool$3.get(this).mouseDown; + } + /** + * Check if selected only one cell. + * + * @private + * @returns {boolean} + */ + + }, { + key: "isSelectedOnlyCell", + value: function isSelectedOnlyCell() { + var _this$instance$getSel, _this$instance$getSel2; + + return (_this$instance$getSel = (_this$instance$getSel2 = this.instance.getSelectedRangeLast()) === null || _this$instance$getSel2 === void 0 ? void 0 : _this$instance$getSel2.isSingle()) !== null && _this$instance$getSel !== void 0 ? _this$instance$getSel : false; + } + /** + * Checks if active cell is editing. + * + * @private + * @returns {boolean} + */ + + }, { + key: "isCellEdited", + value: function isCellEdited() { + var activeEditor = this.instance.getActiveEditor(); + return activeEditor && activeEditor.isOpened(); + } + /** + * `beforeDraw` callback. + * + * @private + * @param {boolean} force If `true` rendering was triggered by a change of settings or data or `false` if + * rendering was triggered by scrolling or moving selection. + * @param {boolean} skipRender Indicates whether the rendering is skipped. + */ + + }, { + key: "beforeRender", + value: function beforeRender(force, skipRender) { + if (force) { + // this.instance.forceFullRender = did Handsontable request full render? + this.instance.runHooks('beforeRender', this.instance.forceFullRender, skipRender); + } + } + /** + * `onDraw` callback. + * + * @private + * @param {boolean} force If `true` rendering was triggered by a change of settings or data or `false` if + * rendering was triggered by scrolling or moving selection. + */ + + }, { + key: "onDraw", + value: function onDraw(force) { + if (force) { + // this.instance.forceFullRender = did Handsontable request full render? + this.instance.runHooks('afterRender', this.instance.forceFullRender); + } + } + /** + * Append row header to a TH element. + * + * @private + * @param {number} visualRowIndex The visual row index. + * @param {HTMLTableHeaderCellElement} TH The table header element. + */ + + }, { + key: "appendRowHeader", + value: function appendRowHeader(visualRowIndex, TH) { + if (TH.firstChild) { + var container = TH.firstChild; + + if (!hasClass(container, 'relative')) { + empty(TH); + this.appendRowHeader(visualRowIndex, TH); + return; + } + + this.updateCellHeader(container.querySelector('.rowHeader'), visualRowIndex, this.instance.getRowHeader); + } else { + var _this$instance3 = this.instance, + rootDocument = _this$instance3.rootDocument, + getRowHeader = _this$instance3.getRowHeader; + var div = rootDocument.createElement('div'); + var span = rootDocument.createElement('span'); + div.className = 'relative'; + span.className = 'rowHeader'; + this.updateCellHeader(span, visualRowIndex, getRowHeader); + div.appendChild(span); + TH.appendChild(div); + } + + this.instance.runHooks('afterGetRowHeader', visualRowIndex, TH); + } + /** + * Append column header to a TH element. + * + * @private + * @param {number} visualColumnIndex Visual column index. + * @param {HTMLTableHeaderCellElement} TH The table header element. + */ + + }, { + key: "appendColHeader", + value: function appendColHeader(visualColumnIndex, TH) { + if (TH.firstChild) { + var container = TH.firstChild; + + if (hasClass(container, 'relative')) { + this.updateCellHeader(container.querySelector('.colHeader'), visualColumnIndex, this.instance.getColHeader); + } else { + empty(TH); + this.appendColHeader(visualColumnIndex, TH); + } + } else { + var rootDocument = this.instance.rootDocument; + var div = rootDocument.createElement('div'); + var span = rootDocument.createElement('span'); + div.className = 'relative'; + span.className = 'colHeader'; + this.updateCellHeader(span, visualColumnIndex, this.instance.getColHeader); + div.appendChild(span); + TH.appendChild(div); + } + + this.instance.runHooks('afterGetColHeader', visualColumnIndex, TH); + } + /** + * Updates header cell content. + * + * @since 0.15.0-beta4 + * @param {HTMLElement} element Element to update. + * @param {number} index Row index or column index. + * @param {Function} content Function which should be returns content for this cell. + */ + + }, { + key: "updateCellHeader", + value: function updateCellHeader(element, index, content) { + var renderedIndex = index; + var parentOverlay = this.wt.wtOverlays.getParentOverlay(element) || this.wt; // prevent wrong calculations from SampleGenerator + + if (element.parentNode) { + if (hasClass(element, 'colHeader')) { + renderedIndex = parentOverlay.wtTable.columnFilter.sourceToRendered(index); + } else if (hasClass(element, 'rowHeader')) { + renderedIndex = parentOverlay.wtTable.rowFilter.sourceToRendered(index); + } + } + + if (renderedIndex > -1) { + fastInnerHTML(element, content(index)); + } else { + // workaround for https://github.com/handsontable/handsontable/issues/1946 + fastInnerText(element, String.fromCharCode(160)); + addClass(element, 'cornerHeader'); + } + } + /** + * Given a element's left position relative to the viewport, returns maximum element width until the right + * edge of the viewport (before scrollbar). + * + * @private + * @param {number} leftOffset The left offset. + * @returns {number} + */ + + }, { + key: "maximumVisibleElementWidth", + value: function maximumVisibleElementWidth(leftOffset) { + var workspaceWidth = this.wt.wtViewport.getWorkspaceWidth(); + var maxWidth = workspaceWidth - leftOffset; + return maxWidth > 0 ? maxWidth : 0; + } + /** + * Given a element's top position relative to the viewport, returns maximum element height until the bottom + * edge of the viewport (before scrollbar). + * + * @private + * @param {number} topOffset The top offset. + * @returns {number} + */ + + }, { + key: "maximumVisibleElementHeight", + value: function maximumVisibleElementHeight(topOffset) { + var workspaceHeight = this.wt.wtViewport.getWorkspaceHeight(); + var maxHeight = workspaceHeight - topOffset; + return maxHeight > 0 ? maxHeight : 0; + } + /** + * Sets new dimensions of the container. + * + * @param {number} width The table width. + * @param {number} height The table height. + */ + + }, { + key: "setLastSize", + value: function setLastSize(width, height) { + var priv = privatePool$3.get(this); + var _ref2 = [width, height]; + priv.lastWidth = _ref2[0]; + priv.lastHeight = _ref2[1]; + } + /** + * Returns cached dimensions. + * + * @returns {object} + */ + + }, { + key: "getLastSize", + value: function getLastSize() { + var priv = privatePool$3.get(this); + return { + width: priv.lastWidth, + height: priv.lastHeight + }; + } + /** + * Checks if master overlay is active. + * + * @private + * @returns {boolean} + */ + + }, { + key: "mainViewIsActive", + value: function mainViewIsActive() { + return this.wt === this.activeWt; + } + /** + * Destroyes internal WalkOnTable's instance. Detaches all of the bonded listeners. + * + * @private + */ + + }, { + key: "destroy", + value: function destroy() { + this.wt.destroy(); + this.eventManager.destroy(); + } + }]); + + return TableView; +}(); + +var _staticRegister$3 = staticRegister('cellTypes'), + register$3 = _staticRegister$3.register, + getItem$3 = _staticRegister$3.getItem, + hasItem$3 = _staticRegister$3.hasItem, + getNames$3 = _staticRegister$3.getNames; +/** + * Retrieve cell type object. + * + * @param {string} name Cell type identification. + * @returns {object} Returns cell type object. + */ + + +function _getItem$3(name) { + if (!hasItem$3(name)) { + throw Error("You declared cell type \"".concat(name, "\" as a string that is not mapped to a known object.\n Cell type must be an object or a string mapped to an object registered by\n \"Handsontable.cellTypes.registerCellType\" method")); + } + + return getItem$3(name); +} +/** + * Register cell type under specified name. + * + * @param {string} name Cell type identification. + * @param {object} type An object with contains keys (eq: `editor`, `renderer`, `validator`) which describes specified behaviour of the cell. + */ + + +function _register$3(name, type) { + if (typeof name !== 'string') { + type = name; + name = type.CELL_TYPE; + } + + var _type = type, + editor = _type.editor, + renderer = _type.renderer, + validator = _type.validator; + + if (editor) { + _register(name, editor); + } + + if (renderer) { + _register$1(name, renderer); + } + + if (validator) { + _register$2(name, validator); + } + + register$3(name, type); +} + +var COLUMN_LABEL_BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; +var COLUMN_LABEL_BASE_LENGTH = COLUMN_LABEL_BASE.length; +/** + * Generates spreadsheet-like column names: A, B, C, ..., Z, AA, AB, etc. + * + * @param {number} index Column index. + * @returns {string} + */ + +function spreadsheetColumnLabel(index) { + var dividend = index + 1; + var columnLabel = ''; + var modulo; + + while (dividend > 0) { + modulo = (dividend - 1) % COLUMN_LABEL_BASE_LENGTH; + columnLabel = String.fromCharCode(65 + modulo) + columnLabel; + dividend = parseInt((dividend - modulo) / COLUMN_LABEL_BASE_LENGTH, 10); + } + + return columnLabel; +} +/** + * Generates spreadsheet-like column index from theirs labels: A, B, C ...., Z, AA, AB, etc. + * + * @param {string} label Column label. + * @returns {number} + */ + +function spreadsheetColumnIndex(label) { + var result = 0; + + if (label) { + for (var i = 0, j = label.length - 1; i < label.length; i += 1, j -= 1) { + result += Math.pow(COLUMN_LABEL_BASE_LENGTH, j) * (COLUMN_LABEL_BASE.indexOf(label[i]) + 1); + } + } + + result -= 1; + return result; +} +/** + * Creates 2D array of Excel-like values "A1", "A2", ... + * + * @param {number} rows Number of rows to generate. + * @param {number} columns Number of columns to generate. + * @returns {Array} + */ + +function createSpreadsheetData() { + var rows = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100; + var columns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4; + var _rows = []; + var i; + var j; + + for (i = 0; i < rows; i++) { + var row = []; + + for (j = 0; j < columns; j++) { + row.push(spreadsheetColumnLabel(j) + (i + 1)); + } + + _rows.push(row); + } + + return _rows; +} +/** + * Creates 2D array of Excel-like values "A1", "A2", as an array of objects. + * + * @param {number} rows Number of rows to generate. + * @param {number} colCount Number of columns to generate. + * @returns {Array} + */ + +function createSpreadsheetObjectData() { + var rows = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100; + var colCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 4; + var _rows = []; + var i; + var j; + + for (i = 0; i < rows; i++) { + var row = {}; + + for (j = 0; j < colCount; j++) { + row["prop".concat(j)] = spreadsheetColumnLabel(j) + (i + 1); + } + + _rows.push(row); + } + + return _rows; +} +/** + * Generates an empty data object. + * + * @param {number} rows Number of rows to generate. + * @param {number} columns Number of columns to generate. + * @returns {Array} + */ + +function createEmptySpreadsheetData(rows, columns) { + var data = []; + var row; + + for (var i = 0; i < rows; i++) { + row = []; + + for (var j = 0; j < columns; j++) { + row.push(''); + } + + data.push(row); + } + + return data; +} +/** + * @param {Array} input The data to translate. + * @returns {Array} + */ + +function translateRowsToColumns(input) { + var output = []; + var i; + var ilen; + var j; + var jlen; + var olen = 0; + + for (i = 0, ilen = input.length; i < ilen; i++) { + for (j = 0, jlen = input[i].length; j < jlen; j++) { + if (j === olen) { + output.push([]); + olen += 1; + } + + output[j].push(input[i][j]); + } + } + + return output; +} +/** + * Factory that produces a function for searching methods (or any properties) which could be defined directly in + * table configuration or implicitly, within cell type definition. + * + * For example: renderer can be defined explicitly using "renderer" property in column configuration or it can be + * defined implicitly using "type" property. + * + * Methods/properties defined explicitly always takes precedence over those defined through "type". + * + * If the method/property is not found in an object, searching is continued recursively through prototype chain, until + * it reaches the Object.prototype. + * + * + * @param {string} methodName Name of the method/property to search (i.e. 'renderer', 'validator', 'copyable'). + * @param {boolean} [allowUndefined] If `false`, the search is continued if methodName has not been found in cell "type". + * @returns {Function} + */ + +function cellMethodLookupFactory(methodName, allowUndefined) { + var isUndefinedAllowed = typeof allowUndefined === 'undefined' ? true : allowUndefined; + return function cellMethodLookup(row, col) { + return function getMethodFromProperties(properties) { + if (!properties) { + return; // method or property not found + } + + if (hasOwnProperty$1(properties, methodName) && properties[methodName] !== void 0) { + // check if it is own and is not empty + return properties[methodName]; // method defined directly + } else if (hasOwnProperty$1(properties, 'type') && properties.type) { + // check if it is own and is not empty + if (typeof properties.type !== 'string') { + throw new Error('Cell "type" must be a string'); + } + + var type = _getItem$3(properties.type); + + if (hasOwnProperty$1(type, methodName)) { + return type[methodName]; // method defined in type. + } else if (isUndefinedAllowed) { + return; // method does not defined in type (eg. validator), returns undefined + } + } + + return getMethodFromProperties(Object.getPrototypeOf(properties)); + }(typeof row === 'number' ? this.getCellMeta(row, col) : row); + }; +} +/** + * Transform a data row (either an array or an object) or an array of data rows to array of changes in a form of `[row, prop/col, value]`. + * Convenient to use with `setDataAtRowProp` and `setSourceDataAtCell` methods. + * + * @param {Array|object} dataRow Object of row data, array of row data or an array of either. + * @param {number} rowOffset Row offset to be passed to the resulting change list. Defaults to `0`. + * @returns {Array} Array of changes (in a form of an array). + */ + +function dataRowToChangesArray(dataRow) { + var rowOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + var dataRows = dataRow; + var changesArray = []; + + if (!Array.isArray(dataRow) || !Array.isArray(dataRow[0])) { + dataRows = [dataRow]; + } + + dataRows.forEach(function (row, rowIndex) { + if (Array.isArray(row)) { + row.forEach(function (value, column) { + changesArray.push([rowIndex + rowOffset, column, value]); + }); + } else { + Object.keys(row).forEach(function (propName) { + changesArray.push([rowIndex + rowOffset, propName, row[propName]]); + }); + } + }); + return changesArray; +} +/** + * Count the number of keys (or, basically, columns when the data is an array or arrays) in the first row of the provided dataset. + * + * @param {Array} data The dataset. + * @returns {number} Number of keys in the first row of the dataset. + */ + +function countFirstRowKeys(data) { + var result = 0; + + if (Array.isArray(data)) { + if (data[0] && Array.isArray(data[0])) { + result = data[0].length; + } else if (data[0] && isObject$1(data[0])) { + result = deepObjectSize(data[0]); + } + } + + return result; +} + +var dataHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + spreadsheetColumnLabel: spreadsheetColumnLabel, + spreadsheetColumnIndex: spreadsheetColumnIndex, + createSpreadsheetData: createSpreadsheetData, + createSpreadsheetObjectData: createSpreadsheetObjectData, + createEmptySpreadsheetData: createEmptySpreadsheetData, + translateRowsToColumns: translateRowsToColumns, + cellMethodLookupFactory: cellMethodLookupFactory, + dataRowToChangesArray: dataRowToChangesArray, + countFirstRowKeys: countFirstRowKeys +}); + +function _classCallCheck$L(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$G(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); } } + +function _createClass$G(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$G(Constructor.prototype, protoProps); if (staticProps) _defineProperties$G(Constructor, staticProps); return Constructor; } +/** + * @class DataSource + * @private + */ + +var DataSource = /*#__PURE__*/function () { + function DataSource(hotInstance) { + var dataSource = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + + _classCallCheck$L(this, DataSource); + + /** + * Instance of Handsontable. + * + * @type {Handsontable} + */ + this.hot = hotInstance; + /** + * Data source. + * + * @type {Array} + */ + + this.data = dataSource; + /** + * Type of data source. + * + * @type {string} + * @default 'array' + */ + + this.dataType = 'array'; + + this.colToProp = function () {}; + + this.propToCol = function () {}; + } + /** + * Run the `modifyRowData` hook and return either the modified or the source data for the provided row. + * + * @private + * @param {number} rowIndex Row index. + * @returns {Array|object} Source or modified row of data. + */ + + + _createClass$G(DataSource, [{ + key: "modifyRowData", + value: function modifyRowData(rowIndex) { + var modifyRowData; + + if (this.hot.hasHook('modifyRowData')) { + modifyRowData = this.hot.runHooks('modifyRowData', rowIndex); + } + + return modifyRowData !== void 0 && !Number.isInteger(modifyRowData) ? modifyRowData : this.data[rowIndex]; + } + /** + * Get all data. + * + * @param {boolean} [toArray=false] If `true` return source data as an array of arrays even when source data was provided + * in another format. + * @returns {Array} + */ + + }, { + key: "getData", + value: function getData() { + var toArray = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + if (!this.data || this.data.length === 0) { + return this.data; + } + + return this.getByRange(null, null, toArray); + } + /** + * Set new data source. + * + * @param {Array} data The new data. + */ + + }, { + key: "setData", + value: function setData(data) { + this.data = data; + } + /** + * Returns array of column values from the data source. `column` is the index of the row in the data source. + * + * @param {number} column Visual column index. + * @returns {Array} + */ + + }, { + key: "getAtColumn", + value: function getAtColumn(column) { + var _this = this; + + var result = []; + arrayEach(this.data, function (row, rowIndex) { + var value = _this.getAtCell(rowIndex, column); + + result.push(value); + }); + return result; + } + /** + * Returns a single row of the data or a subset of its columns. If a column range or `toArray` arguments are provided, it + * operates only on the columns declared by the `columns` setting or the data schema. + * + * @param {number} row Physical row index. + * @param {number} [startColumn] Starting index for the column range (optional). + * @param {number} [endColumn] Ending index for the column range (optional). + * @param {boolean} [toArray=false] `true` if the returned value should be forced to be presented as an array. + * @returns {Array|object} + */ + + }, { + key: "getAtRow", + value: function getAtRow(row, startColumn, endColumn) { + var _this2 = this; + + var toArray = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + var getAllProps = startColumn === void 0 && endColumn === void 0; + var dataRow = null; + var newDataRow = null; + dataRow = this.modifyRowData(row); + + if (Array.isArray(dataRow)) { + newDataRow = []; + + if (getAllProps) { + dataRow.forEach(function (cell, column) { + newDataRow[column] = _this2.getAtPhysicalCell(row, column, dataRow); + }); + } else { + // Only the columns from the provided range + rangeEach(startColumn, endColumn, function (column) { + newDataRow[column - startColumn] = _this2.getAtPhysicalCell(row, column, dataRow); + }); + } + } else if (isObject$1(dataRow) || isFunction(dataRow)) { + if (toArray) { + newDataRow = []; + } else { + newDataRow = {}; + } + + if (!getAllProps || toArray) { + var rangeStart = 0; + var rangeEnd = this.countFirstRowKeys() - 1; + rangeEach(rangeStart, rangeEnd, function (column) { + var prop = _this2.colToProp(column); + + if (column >= (startColumn || rangeStart) && column <= (endColumn || rangeEnd) && !Number.isInteger(prop)) { + var cellValue = _this2.getAtPhysicalCell(row, prop, dataRow); + + if (toArray) { + newDataRow.push(cellValue); + } else { + setProperty(newDataRow, prop, cellValue); + } + } + }); + } else { + objectEach(dataRow, function (value, prop) { + setProperty(newDataRow, prop, _this2.getAtPhysicalCell(row, prop, dataRow)); + }); + } + } + + return newDataRow; + } + /** + * Set the provided value in the source data set at the provided coordinates. + * + * @param {number} row Physical row index. + * @param {number|string} column Property name / physical column index. + * @param {*} value The value to be set at the provided coordinates. + */ + + }, { + key: "setAtCell", + value: function setAtCell(row, column, value) { + if (row >= this.countRows() || column >= this.countFirstRowKeys()) { + // Not enough rows and/or columns. + return; + } + + if (this.hot.hasHook('modifySourceData')) { + var valueHolder = createObjectPropListener(value); + this.hot.runHooks('modifySourceData', row, this.propToCol(column), valueHolder, 'set'); + + if (valueHolder.isTouched()) { + value = valueHolder.value; + } + } + + if (!Number.isInteger(column)) { + // column argument is the prop name + setProperty(this.data[row], column, value); + } else { + this.data[row][column] = value; + } + } + /** + * Get data from the source data set using the physical indexes. + * + * @private + * @param {number} row Physical row index. + * @param {string|number|Function} column Physical column index / property / function. + * @param {Array|object} dataRow A representation of a data row. + * @returns {*} Value at the provided coordinates. + */ + + }, { + key: "getAtPhysicalCell", + value: function getAtPhysicalCell(row, column, dataRow) { + var result = null; + + if (dataRow) { + if (typeof column === 'string') { + result = getProperty(dataRow, column); + } else if (typeof column === 'function') { + result = column(dataRow); + } else { + result = dataRow[column]; + } + } + + if (this.hot.hasHook('modifySourceData')) { + var valueHolder = createObjectPropListener(result); + this.hot.runHooks('modifySourceData', row, this.colToProp(column), valueHolder, 'get'); + + if (valueHolder.isTouched()) { + result = valueHolder.value; + } + } + + return result; + } + /** + * Returns a single value from the data. + * + * @param {number} row Physical row index. + * @param {number} column Visual column index. + * @returns {*} + */ + + }, { + key: "getAtCell", + value: function getAtCell(row, column) { + var dataRow = this.modifyRowData(row); + return this.getAtPhysicalCell(row, this.colToProp(column), dataRow); + } + /** + * Returns source data by passed range. + * + * @param {object} [start] Object with physical `row` and `col` keys (or visual column index, if data type is an array of objects). + * @param {object} [end] Object with physical `row` and `col` keys (or visual column index, if data type is an array of objects). + * @param {boolean} [toArray=false] If `true` return source data as an array of arrays even when source data was provided + * in another format. + * @returns {Array} + */ + + }, { + key: "getByRange", + value: function getByRange() { + var _this3 = this; + + var start = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + var end = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var toArray = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var getAllProps = false; + var startRow = null; + var startCol = null; + var endRow = null; + var endCol = null; + + if (start === null || end === null) { + getAllProps = true; + startRow = 0; + endRow = this.countRows() - 1; + } else { + startRow = Math.min(start.row, end.row); + startCol = Math.min(start.col, end.col); + endRow = Math.max(start.row, end.row); + endCol = Math.max(start.col, end.col); + } + + var result = []; + rangeEach(startRow, endRow, function (currentRow) { + result.push(getAllProps ? _this3.getAtRow(currentRow, void 0, void 0, toArray) : _this3.getAtRow(currentRow, startCol, endCol, toArray)); + }); + return result; + } + /** + * Count number of rows. + * + * @returns {number} + */ + + }, { + key: "countRows", + value: function countRows() { + if (this.hot.hasHook('modifySourceLength')) { + var modifiedSourceLength = this.hot.runHooks('modifySourceLength'); + + if (Number.isInteger(modifiedSourceLength)) { + return modifiedSourceLength; + } + } + + return this.data.length; + } + /** + * Count number of columns. + * + * @returns {number} + */ + + }, { + key: "countFirstRowKeys", + value: function countFirstRowKeys$1() { + return countFirstRowKeys(this.data); + } + /** + * Destroy instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.data = null; + this.hot = null; + } + }]); + + return DataSource; +}(); + +// `Array.prototype.fill` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.fill +var arrayFill = function fill(value /* , start = 0, end = @length */) { + var O = toObject(this); + var length = toLength(O.length); + var argumentsLength = arguments.length; + var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length); + var end = argumentsLength > 2 ? arguments[2] : undefined; + var endPos = end === undefined ? length : toAbsoluteIndex(end, length); + while (endPos > index) O[index++] = value; + return O; +}; + +// `Array.prototype.fill` method +// https://tc39.es/ecma262/#sec-array.prototype.fill +_export({ target: 'Array', proto: true }, { + fill: arrayFill +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('fill'); + +var $some = arrayIteration.some; + + +var STRICT_METHOD$6 = arrayMethodIsStrict('some'); + +// `Array.prototype.some` method +// https://tc39.es/ecma262/#sec-array.prototype.some +_export({ target: 'Array', proto: true, forced: !STRICT_METHOD$6 }, { + some: function some(callbackfn /* , thisArg */) { + return $some(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +function _toConsumableArray$b(arr) { return _arrayWithoutHoles$9(arr) || _iterableToArray$9(arr) || _unsupportedIterableToArray$d(arr) || _nonIterableSpread$9(); } + +function _nonIterableSpread$9() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$d(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$d(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$d(o, minLen); } + +function _iterableToArray$9(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$9(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$d(arr); } + +function _arrayLikeToArray$d(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } +/** + * Insert new items to the list. + * + * @private + * @param {Array} indexedValues List of values for particular indexes. + * @param {number} insertionIndex Position inside the actual list. + * @param {Array} insertedIndexes List of inserted indexes. + * @returns {Array} List with new mappings. + */ + +function getListWithInsertedItems(indexedValues, insertionIndex, insertedIndexes) { + return [].concat(_toConsumableArray$b(indexedValues.slice(0, insertionIndex)), _toConsumableArray$b(insertedIndexes), _toConsumableArray$b(indexedValues.slice(insertionIndex))); +} +/** + * Filter items from the list. + * + * @private + * @param {Array} indexedValues List of values for particular indexes. + * @param {Array} removedIndexes List of removed indexes. + * @returns {Array} Reduced list of mappings. + */ + +function getListWithRemovedItems(indexedValues, removedIndexes) { + return arrayFilter(indexedValues, function (index) { + return removedIndexes.includes(index) === false; + }); +} + +var MIXIN_NAME$6 = 'localHooks'; +/** + * Mixin object to extend objects functionality for local hooks. + * + * @type {object} + */ + +var localHooks = { + /** + * Internal hooks storage. + */ + _localHooks: Object.create(null), + + /** + * Add hook to the collection. + * + * @param {string} key The hook name. + * @param {Function} callback The hook callback. + * @returns {object} + */ + addLocalHook: function addLocalHook(key, callback) { + if (!this._localHooks[key]) { + this._localHooks[key] = []; + } + + this._localHooks[key].push(callback); + + return this; + }, + + /** + * Run hooks. + * + * @param {string} key The hook name. + * @param {*} params Additional parameters passed to callback function. + */ + runLocalHooks: function runLocalHooks(key) { + var _this = this; + + for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + params[_key - 1] = arguments[_key]; + } + + if (this._localHooks[key]) { + arrayEach(this._localHooks[key], function (callback) { + return callback.apply(_this, params); + }); + } + }, + + /** + * Clear all added hooks. + * + * @returns {object} + */ + clearLocalHooks: function clearLocalHooks() { + this._localHooks = {}; + return this; + } +}; +defineGetter(localHooks, 'MIXIN_NAME', MIXIN_NAME$6, { + writable: false, + enumerable: false +}); + +function _classCallCheck$M(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$H(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); } } + +function _createClass$H(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$H(Constructor.prototype, protoProps); if (staticProps) _defineProperties$H(Constructor, staticProps); return Constructor; } +/** + * Map for storing mappings from an index to a value. + */ + +var IndexMap = /*#__PURE__*/function () { + function IndexMap() { + var initValueOrFn = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + _classCallCheck$M(this, IndexMap); + + /** + * List of values for particular indexes. + * + * @private + * @type {Array} + */ + this.indexedValues = []; + /** + * Initial value or function for each existing index. + * + * @private + * @type {*} + */ + + this.initValueOrFn = initValueOrFn; + } + /** + * Get full list of values for particular indexes. + * + * @returns {Array} + */ + + + _createClass$H(IndexMap, [{ + key: "getValues", + value: function getValues() { + return this.indexedValues; + } + /** + * Get value for the particular index. + * + * @param {number} index Index for which value is got. + * @returns {*} + */ + + }, { + key: "getValueAtIndex", + value: function getValueAtIndex(index) { + var values = this.indexedValues; + + if (index < values.length) { + return values[index]; + } + } + /** + * Set new values for particular indexes. + * + * Note: Please keep in mind that `change` hook triggered by the method may not update cache of a collection immediately. + * + * @param {Array} values List of set values. + */ + + }, { + key: "setValues", + value: function setValues(values) { + this.indexedValues = values.slice(); + this.runLocalHooks('change'); + } + /** + * Set new value for the particular index. + * + * @param {number} index The index. + * @param {*} value The value to save. + * + * Note: Please keep in mind that it is not possible to set value beyond the map (not respecting already set + * map's size). Please use the `setValues` method when you would like to extend the map. + * Note: Please keep in mind that `change` hook triggered by the method may not update cache of a collection immediately. + * + * @returns {boolean} + */ + + }, { + key: "setValueAtIndex", + value: function setValueAtIndex(index, value) { + if (index < this.indexedValues.length) { + this.indexedValues[index] = value; + this.runLocalHooks('change'); + return true; + } + + return false; + } + /** + * Clear all values to the defaults. + */ + + }, { + key: "clear", + value: function clear() { + this.setDefaultValues(); + } + /** + * Get length of the index map. + * + * @returns {number} + */ + + }, { + key: "getLength", + value: function getLength() { + return this.getValues().length; + } + /** + * Set default values for elements from `0` to `n`, where `n` is equal to the handled variable. + * + * Note: Please keep in mind that `change` hook triggered by the method may not update cache of a collection immediately. + * + * @private + * @param {number} [length] Length of list. + */ + + }, { + key: "setDefaultValues", + value: function setDefaultValues() { + var _this = this; + + var length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.indexedValues.length; + this.indexedValues.length = 0; + + if (isFunction(this.initValueOrFn)) { + rangeEach(length - 1, function (index) { + return _this.indexedValues.push(_this.initValueOrFn(index)); + }); + } else { + rangeEach(length - 1, function () { + return _this.indexedValues.push(_this.initValueOrFn); + }); + } + + this.runLocalHooks('change'); + } + /** + * Initialize list with default values for particular indexes. + * + * @private + * @param {number} length New length of indexed list. + * @returns {IndexMap} + */ + + }, { + key: "init", + value: function init(length) { + this.setDefaultValues(length); + this.runLocalHooks('init'); + return this; + } + /** + * Add values to the list. + * + * Note: Please keep in mind that `change` hook triggered by the method may not update cache of a collection immediately. + * + * @private + */ + + }, { + key: "insert", + value: function insert() { + this.runLocalHooks('change'); + } + /** + * Remove values from the list. + * + * Note: Please keep in mind that `change` hook triggered by the method may not update cache of a collection immediately. + * + * @private + */ + + }, { + key: "remove", + value: function remove() { + this.runLocalHooks('change'); + } + }]); + + return IndexMap; +}(); + +mixin(IndexMap, localHooks); + +/** + * Transform mappings after removal. + * + * @private + * @param {Array} indexedValues List of values for particular indexes. + * @param {Array} removedIndexes List of removed indexes. + * @returns {Array} List with decreased indexes. + */ + +function getDecreasedIndexes(indexedValues, removedIndexes) { + return arrayMap(indexedValues, function (index) { + return index - removedIndexes.filter(function (removedIndex) { + return removedIndex < index; + }).length; + }); +} +/** + * Transform mappings after insertion. + * + * @private + * @param {Array} indexedValues List of values for particular indexes. + * @param {Array} insertedIndexes List of inserted indexes. + * @returns {Array} List with increased indexes. + */ + +function getIncreasedIndexes(indexedValues, insertedIndexes) { + var firstInsertedIndex = insertedIndexes[0]; + var amountOfIndexes = insertedIndexes.length; + return arrayMap(indexedValues, function (index) { + if (index >= firstInsertedIndex) { + return index + amountOfIndexes; + } + + return index; + }); +} + +function _toConsumableArray$c(arr) { return _arrayWithoutHoles$a(arr) || _iterableToArray$a(arr) || _unsupportedIterableToArray$e(arr) || _nonIterableSpread$a(); } + +function _nonIterableSpread$a() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$e(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$e(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$e(o, minLen); } + +function _iterableToArray$a(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$a(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$e(arr); } + +function _arrayLikeToArray$e(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } +/** + * Insert new items to the list. + * + * @private + * @param {Array} indexedValues List of values for particular indexes. + * @param {number} insertionIndex Position inside the actual list. + * @param {Array} insertedIndexes List of inserted indexes. + * @param {*} insertedValuesMapping Mapping which may provide value or function returning value for the specific parameters. + * @returns {Array} List with new mappings. + */ + +function getListWithInsertedItems$1(indexedValues, insertionIndex, insertedIndexes, insertedValuesMapping) { + var firstInsertedIndex = insertedIndexes.length ? insertedIndexes[0] : void 0; + return [].concat(_toConsumableArray$c(indexedValues.slice(0, firstInsertedIndex)), _toConsumableArray$c(insertedIndexes.map(function (insertedIndex, ordinalNumber) { + if (isFunction(insertedValuesMapping)) { + return insertedValuesMapping(insertedIndex, ordinalNumber); + } + + return insertedValuesMapping; + })), _toConsumableArray$c(firstInsertedIndex === void 0 ? [] : indexedValues.slice(firstInsertedIndex))); +} +/** + * Filter items from the list. + * + * @private + * @param {Array} indexedValues List of values for particular indexes. + * @param {Array} removedIndexes List of removed indexes. + * @returns {Array} Reduced list of mappings. + */ + +function getListWithRemovedItems$1(indexedValues, removedIndexes) { + return arrayFilter(indexedValues, function (_, index) { + return removedIndexes.includes(index) === false; + }); +} + +var alterStrategies = new Map([['indexesSequence', { + getListWithInsertedItems: getListWithInsertedItems, + getListWithRemovedItems: getListWithRemovedItems +}], ['physicallyIndexed', { + getListWithInsertedItems: getListWithInsertedItems$1, + getListWithRemovedItems: getListWithRemovedItems$1 +}]]); + +var alterUtilsFactory = function alterUtilsFactory(indexationStrategy) { + if (alterStrategies.has(indexationStrategy) === false) { + throw new Error("Alter strategy with ID '".concat(indexationStrategy, "' does not exist.")); + } + + return alterStrategies.get(indexationStrategy); +}; + +function _typeof$p(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$p = function _typeof(obj) { return typeof obj; }; } else { _typeof$p = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$p(obj); } + +function _classCallCheck$N(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$I(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); } } + +function _createClass$I(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$I(Constructor.prototype, protoProps); if (staticProps) _defineProperties$I(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$i(object); if (object === null) break; } return object; } + +function _inherits$i(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$j(subClass, superClass); } + +function _setPrototypeOf$j(o, p) { _setPrototypeOf$j = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$j(o, p); } + +function _createSuper$i(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$j(); return function _createSuperInternal() { var Super = _getPrototypeOf$i(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$i(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$i(this, result); }; } + +function _possibleConstructorReturn$i(self, call) { if (call && (_typeof$p(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$i(self); } + +function _assertThisInitialized$i(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$j() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$i(o) { _getPrototypeOf$i = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$i(o); } +/** + * Map for storing mappings from an index to a physical index. + * + * It also updates the physical indexes (remaining in the map) on remove/add row or column action. + */ + +var IndexesSequence = /*#__PURE__*/function (_IndexMap) { + _inherits$i(IndexesSequence, _IndexMap); + + var _super = _createSuper$i(IndexesSequence); + + function IndexesSequence() { + _classCallCheck$N(this, IndexesSequence); + + // Not handling custom init function or init value. + return _super.call(this, function (index) { + return index; + }); + } + /** + * Add values to list and reorganize. + * + * @private + * @param {number} insertionIndex Position inside the list. + * @param {Array} insertedIndexes List of inserted indexes. + */ + + + _createClass$I(IndexesSequence, [{ + key: "insert", + value: function insert(insertionIndex, insertedIndexes) { + var listAfterUpdate = getIncreasedIndexes(this.indexedValues, insertedIndexes); + this.indexedValues = getListWithInsertedItems(listAfterUpdate, insertionIndex, insertedIndexes); + + _get(_getPrototypeOf$i(IndexesSequence.prototype), "insert", this).call(this, insertionIndex, insertedIndexes); + } + /** + * Remove values from the list and reorganize. + * + * @private + * @param {Array} removedIndexes List of removed indexes. + */ + + }, { + key: "remove", + value: function remove(removedIndexes) { + var listAfterUpdate = getListWithRemovedItems(this.indexedValues, removedIndexes); + this.indexedValues = getDecreasedIndexes(listAfterUpdate, removedIndexes); + + _get(_getPrototypeOf$i(IndexesSequence.prototype), "remove", this).call(this, removedIndexes); + } + }]); + + return IndexesSequence; +}(IndexMap); + +function _typeof$q(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$q = function _typeof(obj) { return typeof obj; }; } else { _typeof$q = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$q(obj); } + +function _classCallCheck$O(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$J(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); } } + +function _createClass$J(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$J(Constructor.prototype, protoProps); if (staticProps) _defineProperties$J(Constructor, staticProps); return Constructor; } + +function _get$1(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$1 = Reflect.get; } else { _get$1 = function _get(target, property, receiver) { var base = _superPropBase$1(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$1(target, property, receiver || target); } + +function _superPropBase$1(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$j(object); if (object === null) break; } return object; } + +function _inherits$j(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$k(subClass, superClass); } + +function _setPrototypeOf$k(o, p) { _setPrototypeOf$k = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$k(o, p); } + +function _createSuper$j(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$k(); return function _createSuperInternal() { var Super = _getPrototypeOf$j(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$j(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$j(this, result); }; } + +function _possibleConstructorReturn$j(self, call) { if (call && (_typeof$q(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$j(self); } + +function _assertThisInitialized$j(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$k() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$j(o) { _getPrototypeOf$j = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$j(o); } +/** + * Map for storing mappings from an physical index to a value. + * + * Does not update stored values on remove/add row or column action. + */ + +var PhysicalIndexToValueMap = /*#__PURE__*/function (_IndexMap) { + _inherits$j(PhysicalIndexToValueMap, _IndexMap); + + var _super = _createSuper$j(PhysicalIndexToValueMap); + + function PhysicalIndexToValueMap() { + _classCallCheck$O(this, PhysicalIndexToValueMap); + + return _super.apply(this, arguments); + } + + _createClass$J(PhysicalIndexToValueMap, [{ + key: "insert", + value: + /** + * Add values to list and reorganize. + * + * @private + * @param {number} insertionIndex Position inside the list. + * @param {Array} insertedIndexes List of inserted indexes. + */ + function insert(insertionIndex, insertedIndexes) { + this.indexedValues = getListWithInsertedItems$1(this.indexedValues, insertionIndex, insertedIndexes, this.initValueOrFn); + + _get$1(_getPrototypeOf$j(PhysicalIndexToValueMap.prototype), "insert", this).call(this, insertionIndex, insertedIndexes); + } + /** + * Remove values from the list and reorganize. + * + * @private + * @param {Array} removedIndexes List of removed indexes. + */ + + }, { + key: "remove", + value: function remove(removedIndexes) { + this.indexedValues = getListWithRemovedItems$1(this.indexedValues, removedIndexes); + + _get$1(_getPrototypeOf$j(PhysicalIndexToValueMap.prototype), "remove", this).call(this, removedIndexes); + } + }]); + + return PhysicalIndexToValueMap; +}(IndexMap); + +function _typeof$r(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$r = function _typeof(obj) { return typeof obj; }; } else { _typeof$r = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$r(obj); } + +function _classCallCheck$P(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$K(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); } } + +function _createClass$K(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$K(Constructor.prototype, protoProps); if (staticProps) _defineProperties$K(Constructor, staticProps); return Constructor; } + +function _inherits$k(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$l(subClass, superClass); } + +function _setPrototypeOf$l(o, p) { _setPrototypeOf$l = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$l(o, p); } + +function _createSuper$k(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$l(); return function _createSuperInternal() { var Super = _getPrototypeOf$k(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$k(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$k(this, result); }; } + +function _possibleConstructorReturn$k(self, call) { if (call && (_typeof$r(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$k(self); } + +function _assertThisInitialized$k(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$l() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$k(o) { _getPrototypeOf$k = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$k(o); } +/** + * Map for storing mappings from an physical index to a boolean value. It stores information whether physical index is + * NOT included in a dataset and skipped in the process of rendering. + */ + +var TrimmingMap = /*#__PURE__*/function (_PhysicalIndexToValue) { + _inherits$k(TrimmingMap, _PhysicalIndexToValue); + + var _super = _createSuper$k(TrimmingMap); + + function TrimmingMap() { + var initValueOrFn = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + _classCallCheck$P(this, TrimmingMap); + + return _super.call(this, initValueOrFn); + } + /** + * Get physical indexes which are trimmed. + * + * Note: Indexes marked as trimmed aren't included in a {@link DataMap} and aren't rendered. + * + * @returns {Array} + */ + + + _createClass$K(TrimmingMap, [{ + key: "getTrimmedIndexes", + value: function getTrimmedIndexes() { + return arrayReduce(this.getValues(), function (indexesList, isTrimmed, physicalIndex) { + if (isTrimmed) { + indexesList.push(physicalIndex); + } + + return indexesList; + }, []); + } + }]); + + return TrimmingMap; +}(PhysicalIndexToValueMap); + +function _typeof$s(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$s = function _typeof(obj) { return typeof obj; }; } else { _typeof$s = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$s(obj); } + +function _classCallCheck$Q(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$L(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); } } + +function _createClass$L(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$L(Constructor.prototype, protoProps); if (staticProps) _defineProperties$L(Constructor, staticProps); return Constructor; } + +function _inherits$l(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$m(subClass, superClass); } + +function _setPrototypeOf$m(o, p) { _setPrototypeOf$m = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$m(o, p); } + +function _createSuper$l(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$m(); return function _createSuperInternal() { var Super = _getPrototypeOf$l(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$l(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$l(this, result); }; } + +function _possibleConstructorReturn$l(self, call) { if (call && (_typeof$s(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$l(self); } + +function _assertThisInitialized$l(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$m() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$l(o) { _getPrototypeOf$l = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$l(o); } +/** + * Map for storing mappings from an physical index to a boolean value. It stores information whether physical index is + * included in a dataset, but skipped in the process of rendering. + */ + +var HidingMap = /*#__PURE__*/function (_PhysicalIndexToValue) { + _inherits$l(HidingMap, _PhysicalIndexToValue); + + var _super = _createSuper$l(HidingMap); + + function HidingMap() { + var initValueOrFn = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + _classCallCheck$Q(this, HidingMap); + + return _super.call(this, initValueOrFn); + } + /** + * Get physical indexes which are hidden. + * + * Note: Indexes marked as hidden are included in a {@link DataMap}, but aren't rendered. + * + * @returns {Array} + */ + + + _createClass$L(HidingMap, [{ + key: "getHiddenIndexes", + value: function getHiddenIndexes() { + return arrayReduce(this.getValues(), function (indexesList, isHidden, physicalIndex) { + if (isHidden) { + indexesList.push(physicalIndex); + } + + return indexesList; + }, []); + } + }]); + + return HidingMap; +}(PhysicalIndexToValueMap); + +function _classCallCheck$R(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$M(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); } } + +function _createClass$M(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$M(Constructor.prototype, protoProps); if (staticProps) _defineProperties$M(Constructor, staticProps); return Constructor; } + +var registeredMaps = 0; +/** + * Collection of index maps having unique names. It allow us to perform bulk operations such as init, remove, insert on all index maps that have been registered in the collection. + */ + +var MapCollection = /*#__PURE__*/function () { + function MapCollection() { + _classCallCheck$R(this, MapCollection); + + /** + * Collection of index maps. + * + * @type {Map} + */ + this.collection = new Map(); + } + /** + * Register custom index map. + * + * @param {string} uniqueName Unique name of the index map. + * @param {IndexMap} indexMap Index map containing miscellaneous (i.e. Meta data, indexes sequence), updated after remove and insert data actions. + */ + + + _createClass$M(MapCollection, [{ + key: "register", + value: function register(uniqueName, indexMap) { + var _this = this; + + if (this.collection.has(uniqueName) === false) { + this.collection.set(uniqueName, indexMap); + indexMap.addLocalHook('change', function () { + return _this.runLocalHooks('change', indexMap); + }); + registeredMaps += 1; + } + } + /** + * Unregister custom index map. + * + * @param {string} name Name of the index map. + */ + + }, { + key: "unregister", + value: function unregister(name) { + var indexMap = this.collection.get(name); + + if (isDefined(indexMap)) { + indexMap.clearLocalHooks(); + this.collection.delete(name); + this.runLocalHooks('change', indexMap); + registeredMaps -= 1; + } + } + /** + * Get index map for the provided name. + * + * @param {string} [name] Name of the index map. + * @returns {Array|IndexMap} + */ + + }, { + key: "get", + value: function get(name) { + if (isUndefined(name)) { + return Array.from(this.collection.values()); + } + + return this.collection.get(name); + } + /** + * Get collection size. + * + * @returns {number} + */ + + }, { + key: "getLength", + value: function getLength() { + return this.collection.size; + } + /** + * Remove some indexes and corresponding mappings and update values of the others within all collection's index maps. + * + * @private + * @param {Array} removedIndexes List of removed indexes. + */ + + }, { + key: "removeFromEvery", + value: function removeFromEvery(removedIndexes) { + this.collection.forEach(function (indexMap) { + indexMap.remove(removedIndexes); + }); + } + /** + * Insert new indexes and corresponding mapping and update values of the others all collection's index maps. + * + * @private + * @param {number} insertionIndex Position inside the actual list. + * @param {Array} insertedIndexes List of inserted indexes. + */ + + }, { + key: "insertToEvery", + value: function insertToEvery(insertionIndex, insertedIndexes) { + this.collection.forEach(function (indexMap) { + indexMap.insert(insertionIndex, insertedIndexes); + }); + } + /** + * Set default values to index maps within collection. + * + * @param {number} length Destination length for all stored maps. + */ + + }, { + key: "initEvery", + value: function initEvery(length) { + this.collection.forEach(function (indexMap) { + indexMap.init(length); + }); + } + }]); + + return MapCollection; +}(); + +mixin(MapCollection, localHooks); +/** + * @returns {number} + */ + +function getRegisteredMapsCounter() { + return registeredMaps; +} + +function _typeof$t(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$t = function _typeof(obj) { return typeof obj; }; } else { _typeof$t = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$t(obj); } + +function _classCallCheck$S(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$N(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); } } + +function _createClass$N(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$N(Constructor.prototype, protoProps); if (staticProps) _defineProperties$N(Constructor, staticProps); return Constructor; } + +function _inherits$m(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$n(subClass, superClass); } + +function _setPrototypeOf$n(o, p) { _setPrototypeOf$n = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$n(o, p); } + +function _createSuper$m(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$n(); return function _createSuperInternal() { var Super = _getPrototypeOf$m(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$m(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$m(this, result); }; } + +function _possibleConstructorReturn$m(self, call) { if (call && (_typeof$t(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$m(self); } + +function _assertThisInitialized$m(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$n() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$m(o) { _getPrototypeOf$m = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$m(o); } +/** + * Collection of maps. This collection aggregate maps with the same type of values. Values from the registered maps + * can be used to calculate a single result for particular index. + */ + +var AggregatedCollection = /*#__PURE__*/function (_MapCollection) { + _inherits$m(AggregatedCollection, _MapCollection); + + var _super = _createSuper$m(AggregatedCollection); + + function AggregatedCollection(aggregationFunction, fallbackValue) { + var _this; + + _classCallCheck$S(this, AggregatedCollection); + + _this = _super.call(this); + /** + * List of merged values. Value for each index is calculated using values inside registered maps. + * + * @type {Array} + */ + + _this.mergedValuesCache = []; + /** + * Function which do aggregation on the values for particular index. + */ + + _this.aggregationFunction = aggregationFunction; + /** + * Fallback value when there is no calculated value for particular index. + */ + + _this.fallbackValue = fallbackValue; + return _this; + } + /** + * Get merged values for all indexes. + * + * @param {boolean} [readFromCache=true] Determine if read results from the cache. + * @returns {Array} + */ + + + _createClass$N(AggregatedCollection, [{ + key: "getMergedValues", + value: function getMergedValues() { + var readFromCache = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + if (readFromCache === true) { + return this.mergedValuesCache; + } + + if (this.getLength() === 0) { + return []; + } // Below variable stores values for every particular map. Example describing situation when we have 2 registered maps, + // with length equal to 5. + // + // +---------+---------------------------------------------+ + // | | indexes | + // +---------+---------------------------------------------+ + // | maps | 0 | 1 | 2 | 3 | 4 | + // +---------+----------+-------+-------+-------+----------+ + // | 0 | [[ value, value, value, value, value ], | + // | 1 | [ value, value, value, value, value ]] | + // +---------+----------+-------+-------+-------+----------+ + + + var mapsValuesMatrix = arrayMap(this.get(), function (map) { + return map.getValues(); + }); // Below variable stores values for every particular index. Example describing situation when we have 2 registered maps, + // with length equal to 5. + // + // +---------+---------------------+ + // | | maps | + // +---------+---------------------+ + // | indexes | 0 | 1 | + // +---------+----------+----------+ + // | 0 | [[ value, value ], | + // | 1 | [ value, value ], | + // | 2 | [ value, value ], | + // | 3 | [ value, value ], | + // | 4 | [ value, value ]] | + // +---------+----------+----------+ + + var indexesValuesMatrix = []; + var mapsLength = isDefined(mapsValuesMatrix[0]) && mapsValuesMatrix[0].length || 0; + + for (var index = 0; index < mapsLength; index += 1) { + var valuesForIndex = []; + + for (var mapIndex = 0; mapIndex < this.getLength(); mapIndex += 1) { + valuesForIndex.push(mapsValuesMatrix[mapIndex][index]); + } + + indexesValuesMatrix.push(valuesForIndex); + } + + return arrayMap(indexesValuesMatrix, this.aggregationFunction); + } + /** + * Get merged value for particular index. + * + * @param {number} index Index for which we calculate single result. + * @param {boolean} [readFromCache=true] Determine if read results from the cache. + * @returns {*} + */ + + }, { + key: "getMergedValueAtIndex", + value: function getMergedValueAtIndex(index, readFromCache) { + var valueAtIndex = this.getMergedValues(readFromCache)[index]; + return isDefined(valueAtIndex) ? valueAtIndex : this.fallbackValue; + } + /** + * Rebuild cache for the collection. + */ + + }, { + key: "updateCache", + value: function updateCache() { + this.mergedValuesCache = this.getMergedValues(false); + } + }]); + + return AggregatedCollection; +}(MapCollection); + +function _toConsumableArray$d(arr) { return _arrayWithoutHoles$b(arr) || _iterableToArray$b(arr) || _unsupportedIterableToArray$f(arr) || _nonIterableSpread$b(); } + +function _nonIterableSpread$b() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$f(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$f(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$f(o, minLen); } + +function _iterableToArray$b(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$b(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$f(arr); } + +function _arrayLikeToArray$f(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$T(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$O(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); } } + +function _createClass$O(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$O(Constructor.prototype, protoProps); if (staticProps) _defineProperties$O(Constructor, staticProps); return Constructor; } +/** + * Index mapper stores, registers and manages the indexes on the basis of calculations collected from the subsidiary maps. + * It should be seen as a single source of truth (regarding row and column indexes, for example, their sequence, information if they are skipped in the process of rendering (hidden or trimmed), values linked to them) + * for any operation that considers CRUD actions such as **insertion**, **movement**, **removal** etc, and is used to properly calculate physical and visual indexes translations in both ways. + * It has a built-in cache that is updated only when the data or structure changes. + * + * **Physical index** is a type of an index from the sequence of indexes assigned to the data source rows or columns + * (from 0 to n, where n is number of the cells on the axis of data set). + * **Visual index** is a type of an index from the sequence of indexes assigned to rows or columns existing in {@link DataMap} (from 0 to n, where n is number of the cells on the axis of data set). + * **Renderable index** is a type of an index from the sequence of indexes assigned to rows or columns whose may be rendered (when they are in a viewport; from 0 to n, where n is number of the cells renderable on the axis). + * + * There are different kinds of index maps which may be registered in the collections and can be used by a reference. + * They also expose public API and trigger two local hooks such as `init` (on initialization) and `change` (on change). + * + * These are: {@link to IndexesSequence}, {@link to PhysicalIndexToValueMap}, {@link to HidingMap}, and {@link to TrimmingMap}. + */ + +var IndexMapper = /*#__PURE__*/function () { + function IndexMapper() { + var _this = this; + + _classCallCheck$T(this, IndexMapper); + + /** + * Map for storing the sequence of indexes. + * + * It is registered by default and may be used from API methods. + * + * @private + * @type {IndexesSequence} + */ + this.indexesSequence = new IndexesSequence(); + /** + * Collection for different trimming maps. Indexes marked as trimmed in any map WILL NOT be included in + * the {@link DataMap} and won't be rendered. + * + * @private + * @type {MapCollection} + */ + + this.trimmingMapsCollection = new AggregatedCollection(function (valuesForIndex) { + return valuesForIndex.some(function (value) { + return value === true; + }); + }, false); + /** + * Collection for different hiding maps. Indexes marked as hidden in any map WILL be included in the {@link DataMap}, + * but won't be rendered. + * + * @private + * @type {MapCollection} + */ + + this.hidingMapsCollection = new AggregatedCollection(function (valuesForIndex) { + return valuesForIndex.some(function (value) { + return value === true; + }); + }, false); + /** + * Collection for another kind of maps. There are stored mappings from indexes (visual or physical) to values. + * + * @private + * @type {MapCollection} + */ + + this.variousMapsCollection = new MapCollection(); + /** + * Cache for list of not trimmed indexes, respecting the indexes sequence (physical indexes). + * + * Note: Please keep in mind that trimmed index can be also hidden. + * + * @private + * @type {Array} + */ + + this.notTrimmedIndexesCache = []; + /** + * Cache for list of not hidden indexes, respecting the indexes sequence (physical indexes). + * + * Note: Please keep in mind that hidden index can be also trimmed. + * + * @private + * @type {Array} + */ + + this.notHiddenIndexesCache = []; + /** + * Flag determining whether actions performed on index mapper have been batched. It's used for cache management. + * + * @private + * @type {boolean} + */ + + this.isBatched = false; + /** + * Flag determining whether any action on indexes sequence has been performed. It's used for cache management. + * + * @private + * @type {boolean} + */ + + this.indexesSequenceChanged = false; + /** + * Flag determining whether any action on trimmed indexes has been performed. It's used for cache management. + * + * @private + * @type {boolean} + */ + + this.trimmedIndexesChanged = false; + /** + * Flag determining whether any action on hidden indexes has been performed. It's used for cache management. + * + * @private + * @type {boolean} + */ + + this.hiddenIndexesChanged = false; + /** + * Physical indexes (respecting the sequence of indexes) which may be rendered (when they are in a viewport). + * + * @private + * @type {Array} + */ + + this.renderablePhysicalIndexesCache = []; + /** + * Visual indexes (native map's value) corresponding to physical indexes (native map's index). + * + * @private + * @type {Map} + */ + + this.fromPhysicalToVisualIndexesCache = new Map(); + /** + * Visual indexes (native map's value) corresponding to physical indexes (native map's index). + * + * @private + * @type {Map} + */ + + this.fromVisualToRenderableIndexesCache = new Map(); + this.indexesSequence.addLocalHook('change', function () { + _this.indexesSequenceChanged = true; // Sequence of stored indexes might change. + + _this.updateCache(); + + _this.runLocalHooks('change', _this.indexesSequence, null); + }); + this.trimmingMapsCollection.addLocalHook('change', function (changedMap) { + _this.trimmedIndexesChanged = true; // Number of trimmed indexes might change. + + _this.updateCache(); + + _this.runLocalHooks('change', changedMap, _this.trimmingMapsCollection); + }); + this.hidingMapsCollection.addLocalHook('change', function (changedMap) { + _this.hiddenIndexesChanged = true; // Number of hidden indexes might change. + + _this.updateCache(); + + _this.runLocalHooks('change', changedMap, _this.hidingMapsCollection); + }); + this.variousMapsCollection.addLocalHook('change', function (changedMap) { + _this.runLocalHooks('change', changedMap, _this.variousMapsCollection); + }); + } + /** + * Suspends the cache update for this map. The method is helpful to group multiple + * operations, which affects the cache. In this case, the cache will be updated once after + * calling the `resumeOperations` method. + */ + + + _createClass$O(IndexMapper, [{ + key: "suspendOperations", + value: function suspendOperations() { + this.isBatched = true; + } + /** + * Resumes the cache update for this map. It recalculates the cache and restores the + * default behavior where each map modification updates the cache. + */ + + }, { + key: "resumeOperations", + value: function resumeOperations() { + this.isBatched = false; + this.updateCache(); + } + /** + * Register map which provide some index mappings. Type of map determining to which collection it will be added. + * + * @param {string} uniqueName Name of the index map. It should be unique. + * @param {IndexMap} indexMap Registered index map updated on items removal and insertion. + * @returns {IndexMap} + */ + + }, { + key: "registerMap", + value: function registerMap(uniqueName, indexMap) { + if (this.trimmingMapsCollection.get(uniqueName) || this.hidingMapsCollection.get(uniqueName) || this.variousMapsCollection.get(uniqueName)) { + throw Error("Map with name \"".concat(uniqueName, "\" has been already registered.")); + } + + if (indexMap instanceof TrimmingMap) { + this.trimmingMapsCollection.register(uniqueName, indexMap); + } else if (indexMap instanceof HidingMap) { + this.hidingMapsCollection.register(uniqueName, indexMap); + } else { + this.variousMapsCollection.register(uniqueName, indexMap); + } + + var numberOfIndexes = this.getNumberOfIndexes(); + /* + We initialize map ony when we have full information about number of indexes and the dataset is not empty. + Otherwise it's unnecessary. Initialization of empty array would not give any positive changes. After initializing + it with number of indexes equal to 0 the map would be still empty. What's more there would be triggered + not needed hook (no real change have occurred). Number of indexes is known after loading data (the `loadData` + function from the `Core`). + */ + + if (numberOfIndexes > 0) { + indexMap.init(numberOfIndexes); + } + + return indexMap; + } + /** + * Unregister a map with given name. + * + * @param {string} name Name of the index map. + */ + + }, { + key: "unregisterMap", + value: function unregisterMap(name) { + this.trimmingMapsCollection.unregister(name); + this.hidingMapsCollection.unregister(name); + this.variousMapsCollection.unregister(name); + } + /** + * Get a physical index corresponding to the given visual index. + * + * @param {number} visualIndex Visual index. + * @returns {number|null} Returns translated index mapped by passed visual index. + */ + + }, { + key: "getPhysicalFromVisualIndex", + value: function getPhysicalFromVisualIndex(visualIndex) { + // Index in the table boundaries provided by the `DataMap`. + var physicalIndex = this.notTrimmedIndexesCache[visualIndex]; + + if (isDefined(physicalIndex)) { + return physicalIndex; + } + + return null; + } + /** + * Get a physical index corresponding to the given renderable index. + * + * @param {number} renderableIndex Renderable index. + * @returns {null|number} + */ + + }, { + key: "getPhysicalFromRenderableIndex", + value: function getPhysicalFromRenderableIndex(renderableIndex) { + var physicalIndex = this.renderablePhysicalIndexesCache[renderableIndex]; // Index in the renderable table boundaries. + + if (isDefined(physicalIndex)) { + return physicalIndex; + } + + return null; + } + /** + * Get a visual index corresponding to the given physical index. + * + * @param {number} physicalIndex Physical index to search. + * @returns {number|null} Returns a visual index of the index mapper. + */ + + }, { + key: "getVisualFromPhysicalIndex", + value: function getVisualFromPhysicalIndex(physicalIndex) { + var visualIndex = this.fromPhysicalToVisualIndexesCache.get(physicalIndex); // Index in the table boundaries provided by the `DataMap`. + + if (isDefined(visualIndex)) { + return visualIndex; + } + + return null; + } + /** + * Get a visual index corresponding to the given renderable index. + * + * @param {number} renderableIndex Renderable index. + * @returns {null|number} + */ + + }, { + key: "getVisualFromRenderableIndex", + value: function getVisualFromRenderableIndex(renderableIndex) { + return this.getVisualFromPhysicalIndex(this.getPhysicalFromRenderableIndex(renderableIndex)); + } + /** + * Get a renderable index corresponding to the given visual index. + * + * @param {number} visualIndex Visual index. + * @returns {null|number} + */ + + }, { + key: "getRenderableFromVisualIndex", + value: function getRenderableFromVisualIndex(visualIndex) { + var renderableIndex = this.fromVisualToRenderableIndexesCache.get(visualIndex); // Index in the renderable table boundaries. + + if (isDefined(renderableIndex)) { + return renderableIndex; + } + + return null; + } + /** + * Search for the first visible, not hidden index (represented by a visual index). + * + * @param {number} fromVisualIndex Visual start index. Starting point for finding destination index. Start point may be destination + * point when handled index is NOT hidden. + * @param {number} incrementBy We are searching for a next visible indexes by increasing (to be precise, or decreasing) indexes. + * This variable represent indexes shift. We are looking for an index: + * - for rows: from the left to the right (increasing indexes, then variable should have value 1) or + * other way around (decreasing indexes, then variable should have the value -1) + * - for columns: from the top to the bottom (increasing indexes, then variable should have value 1) + * or other way around (decreasing indexes, then variable should have the value -1). + * @param {boolean} searchAlsoOtherWayAround The argument determine if an additional other way around search should be + * performed, when the search in the first direction had no effect in finding visual index. + * @param {number} indexForNextSearch Visual index for next search, when the flag is truthy. + * + * @returns {number|null} Visual column index or `null`. + */ + + }, { + key: "getFirstNotHiddenIndex", + value: function getFirstNotHiddenIndex(fromVisualIndex, incrementBy) { + var searchAlsoOtherWayAround = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var indexForNextSearch = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : fromVisualIndex - incrementBy; + var physicalIndex = this.getPhysicalFromVisualIndex(fromVisualIndex); // First or next (it may be end of the table) index is beyond the table boundaries. + + if (physicalIndex === null) { + // Looking for the next index in the opposite direction. This conditional won't be fulfilled when we STARTED + // the search from the index beyond the table boundaries. + if (searchAlsoOtherWayAround === true && indexForNextSearch !== fromVisualIndex - incrementBy) { + return this.getFirstNotHiddenIndex(indexForNextSearch, -incrementBy, false, indexForNextSearch); + } + + return null; + } + + if (this.isHidden(physicalIndex) === false) { + return fromVisualIndex; + } // Looking for the next index, as the current isn't visible. + + + return this.getFirstNotHiddenIndex(fromVisualIndex + incrementBy, incrementBy, searchAlsoOtherWayAround, indexForNextSearch); + } + /** + * Set default values for all indexes in registered index maps. + * + * @param {number} [length] Destination length for all stored index maps. + */ + + }, { + key: "initToLength", + value: function initToLength() { + var length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getNumberOfIndexes(); + this.notTrimmedIndexesCache = _toConsumableArray$d(new Array(length).keys()); + this.notHiddenIndexesCache = _toConsumableArray$d(new Array(length).keys()); + this.suspendOperations(); + this.indexesSequence.init(length); + this.trimmingMapsCollection.initEvery(length); + this.resumeOperations(); // We move initialization of hidden collection to next batch for purpose of working on sequence of already trimmed indexes. + + this.suspendOperations(); + this.hidingMapsCollection.initEvery(length); // It shouldn't reset the cache. + + this.variousMapsCollection.initEvery(length); + this.resumeOperations(); + this.runLocalHooks('init'); + } + /** + * Get sequence of indexes. + * + * @returns {Array} Physical indexes. + */ + + }, { + key: "getIndexesSequence", + value: function getIndexesSequence() { + return this.indexesSequence.getValues(); + } + /** + * Set completely new indexes sequence. + * + * @param {Array} indexes Physical indexes. + */ + + }, { + key: "setIndexesSequence", + value: function setIndexesSequence(indexes) { + this.indexesSequence.setValues(indexes); + } + /** + * Get all NOT trimmed indexes. + * + * Note: Indexes marked as trimmed aren't included in a {@link DataMap} and aren't rendered. + * + * @param {boolean} [readFromCache=true] Determine if read indexes from cache. + * @returns {Array} List of physical indexes. Index of this native array is a "visual index", + * value of this native array is a "physical index". + */ + + }, { + key: "getNotTrimmedIndexes", + value: function getNotTrimmedIndexes() { + var _this2 = this; + + var readFromCache = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + if (readFromCache === true) { + return this.notTrimmedIndexesCache; + } + + var indexesSequence = this.getIndexesSequence(); + return indexesSequence.filter(function (physicalIndex) { + return _this2.isTrimmed(physicalIndex) === false; + }); + } + /** + * Get length of all NOT trimmed indexes. + * + * Note: Indexes marked as trimmed aren't included in a {@link DataMap} and aren't rendered. + * + * @returns {number} + */ + + }, { + key: "getNotTrimmedIndexesLength", + value: function getNotTrimmedIndexesLength() { + return this.getNotTrimmedIndexes().length; + } + /** + * Get all NOT hidden indexes. + * + * Note: Indexes marked as hidden are included in a {@link DataMap}, but aren't rendered. + * + * @param {boolean} [readFromCache=true] Determine if read indexes from cache. + * @returns {Array} List of physical indexes. Please keep in mind that index of this native array IS NOT a "visual index". + */ + + }, { + key: "getNotHiddenIndexes", + value: function getNotHiddenIndexes() { + var _this3 = this; + + var readFromCache = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + if (readFromCache === true) { + return this.notHiddenIndexesCache; + } + + var indexesSequence = this.getIndexesSequence(); + return indexesSequence.filter(function (physicalIndex) { + return _this3.isHidden(physicalIndex) === false; + }); + } + /** + * Get length of all NOT hidden indexes. + * + * Note: Indexes marked as hidden are included in a {@link DataMap}, but aren't rendered. + * + * @returns {number} + */ + + }, { + key: "getNotHiddenIndexesLength", + value: function getNotHiddenIndexesLength() { + return this.getNotHiddenIndexes().length; + } + /** + * Get list of physical indexes (respecting the sequence of indexes) which may be rendered (when they are in a viewport). + * + * @param {boolean} [readFromCache=true] Determine if read indexes from cache. + * @returns {Array} List of physical indexes. Index of this native array is a "renderable index", + * value of this native array is a "physical index". + */ + + }, { + key: "getRenderableIndexes", + value: function getRenderableIndexes() { + var _this4 = this; + + var readFromCache = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + if (readFromCache === true) { + return this.renderablePhysicalIndexesCache; + } + + var notTrimmedIndexes = this.getNotTrimmedIndexes(); + return notTrimmedIndexes.filter(function (physicalIndex) { + return _this4.isHidden(physicalIndex) === false; + }); + } + /** + * Get length of all NOT trimmed and NOT hidden indexes. + * + * @returns {number} + */ + + }, { + key: "getRenderableIndexesLength", + value: function getRenderableIndexesLength() { + return this.getRenderableIndexes().length; + } + /** + * Get number of all indexes. + * + * @returns {number} + */ + + }, { + key: "getNumberOfIndexes", + value: function getNumberOfIndexes() { + return this.getIndexesSequence().length; + } + /** + * Move indexes in the index mapper. + * + * @param {number|Array} movedIndexes Visual index(es) to move. + * @param {number} finalIndex Visual index being a start index for the moved elements. + */ + + }, { + key: "moveIndexes", + value: function moveIndexes(movedIndexes, finalIndex) { + var _this5 = this; + + if (typeof movedIndexes === 'number') { + movedIndexes = [movedIndexes]; + } + + var physicalMovedIndexes = arrayMap(movedIndexes, function (visualIndex) { + return _this5.getPhysicalFromVisualIndex(visualIndex); + }); + var notTrimmedIndexesLength = this.getNotTrimmedIndexesLength(); + var movedIndexesLength = movedIndexes.length; // Removing indexes without re-indexing. + + var listWithRemovedItems = getListWithRemovedItems(this.getIndexesSequence(), physicalMovedIndexes); // When item(s) are moved after the last visible item we assign the last possible index. + + var destinationPosition = notTrimmedIndexesLength - movedIndexesLength; // Otherwise, we find proper index for inserted item(s). + + if (finalIndex + movedIndexesLength < notTrimmedIndexesLength) { + // Physical index at final index position. + var physicalIndex = listWithRemovedItems.filter(function (index) { + return _this5.isTrimmed(index) === false; + })[finalIndex]; + destinationPosition = listWithRemovedItems.indexOf(physicalIndex); + } // Adding indexes without re-indexing. + + + this.setIndexesSequence(getListWithInsertedItems(listWithRemovedItems, destinationPosition, physicalMovedIndexes)); + } + /** + * Get whether index is trimmed. Index marked as trimmed isn't included in a {@link DataMap} and isn't rendered. + * + * @param {number} physicalIndex Physical index. + * @returns {boolean} + */ + + }, { + key: "isTrimmed", + value: function isTrimmed(physicalIndex) { + return this.trimmingMapsCollection.getMergedValueAtIndex(physicalIndex); + } + /** + * Get whether index is hidden. Index marked as hidden is included in a {@link DataMap}, but isn't rendered. + * + * @param {number} physicalIndex Physical index. + * @returns {boolean} + */ + + }, { + key: "isHidden", + value: function isHidden(physicalIndex) { + return this.hidingMapsCollection.getMergedValueAtIndex(physicalIndex); + } + /** + * Insert new indexes and corresponding mapping and update values of the others, for all stored index maps. + * + * @private + * @param {number} firstInsertedVisualIndex First inserted visual index. + * @param {number} amountOfIndexes Amount of inserted indexes. + */ + + }, { + key: "insertIndexes", + value: function insertIndexes(firstInsertedVisualIndex, amountOfIndexes) { + var nthVisibleIndex = this.getNotTrimmedIndexes()[firstInsertedVisualIndex]; + var firstInsertedPhysicalIndex = isDefined(nthVisibleIndex) ? nthVisibleIndex : this.getNumberOfIndexes(); + var insertionIndex = this.getIndexesSequence().includes(nthVisibleIndex) ? this.getIndexesSequence().indexOf(nthVisibleIndex) : this.getNumberOfIndexes(); + var insertedIndexes = arrayMap(new Array(amountOfIndexes).fill(firstInsertedPhysicalIndex), function (nextIndex, stepsFromStart) { + return nextIndex + stepsFromStart; + }); + this.suspendOperations(); + this.indexesSequence.insert(insertionIndex, insertedIndexes); + this.trimmingMapsCollection.insertToEvery(insertionIndex, insertedIndexes); + this.hidingMapsCollection.insertToEvery(insertionIndex, insertedIndexes); + this.variousMapsCollection.insertToEvery(insertionIndex, insertedIndexes); + this.resumeOperations(); + } + /** + * Remove some indexes and corresponding mappings and update values of the others, for all stored index maps. + * + * @private + * @param {Array} removedIndexes List of removed indexes. + */ + + }, { + key: "removeIndexes", + value: function removeIndexes(removedIndexes) { + this.suspendOperations(); + this.indexesSequence.remove(removedIndexes); + this.trimmingMapsCollection.removeFromEvery(removedIndexes); + this.hidingMapsCollection.removeFromEvery(removedIndexes); + this.variousMapsCollection.removeFromEvery(removedIndexes); + this.resumeOperations(); + } + /** + * Rebuild cache for some indexes. Every action on indexes sequence or indexes skipped in the process of rendering + * by default reset cache, thus batching some index maps actions is recommended. + * + * @private + * @param {boolean} [force=false] Determine if force cache update. + */ + + }, { + key: "updateCache", + value: function updateCache() { + var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var anyCachedIndexChanged = this.indexesSequenceChanged || this.trimmedIndexesChanged || this.hiddenIndexesChanged; + + if (force === true || this.isBatched === false && anyCachedIndexChanged === true) { + this.trimmingMapsCollection.updateCache(); + this.hidingMapsCollection.updateCache(); + this.notTrimmedIndexesCache = this.getNotTrimmedIndexes(false); + this.notHiddenIndexesCache = this.getNotHiddenIndexes(false); + this.renderablePhysicalIndexesCache = this.getRenderableIndexes(false); + this.cacheFromPhysicalToVisualIndexes(); + this.cacheFromVisualToRenderabIendexes(); + this.runLocalHooks('cacheUpdated', this.indexesSequenceChanged, this.trimmedIndexesChanged, this.hiddenIndexesChanged); + this.indexesSequenceChanged = false; + this.trimmedIndexesChanged = false; + this.hiddenIndexesChanged = false; + } + } + /** + * Update cache for translations from physical to visual indexes. + * + * @private + */ + + }, { + key: "cacheFromPhysicalToVisualIndexes", + value: function cacheFromPhysicalToVisualIndexes() { + var nrOfNotTrimmedIndexes = this.getNotTrimmedIndexesLength(); + this.fromPhysicalToVisualIndexesCache.clear(); + + for (var visualIndex = 0; visualIndex < nrOfNotTrimmedIndexes; visualIndex += 1) { + var physicalIndex = this.getPhysicalFromVisualIndex(visualIndex); // Every visual index have corresponding physical index, but some physical indexes may don't have + // corresponding visual indexes (physical indexes may represent trimmed indexes, beyond the table boundaries) + + this.fromPhysicalToVisualIndexesCache.set(physicalIndex, visualIndex); + } + } + /** + * Update cache for translations from visual to renderable indexes. + * + * @private + */ + + }, { + key: "cacheFromVisualToRenderabIendexes", + value: function cacheFromVisualToRenderabIendexes() { + var nrOfRenderableIndexes = this.getRenderableIndexesLength(); + this.fromVisualToRenderableIndexesCache.clear(); + + for (var renderableIndex = 0; renderableIndex < nrOfRenderableIndexes; renderableIndex += 1) { + // Can't use getRenderableFromVisualIndex here because we're building the cache here + var physicalIndex = this.getPhysicalFromRenderableIndex(renderableIndex); + var visualIndex = this.getVisualFromPhysicalIndex(physicalIndex); + this.fromVisualToRenderableIndexesCache.set(visualIndex, renderableIndex); + } + } + }]); + + return IndexMapper; +}(); + +mixin(IndexMapper, localHooks); + +function _typeof$u(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$u = function _typeof(obj) { return typeof obj; }; } else { _typeof$u = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$u(obj); } + +function _toConsumableArray$e(arr) { return _arrayWithoutHoles$c(arr) || _iterableToArray$c(arr) || _unsupportedIterableToArray$g(arr) || _nonIterableSpread$c(); } + +function _nonIterableSpread$c() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$g(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$g(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$g(o, minLen); } + +function _iterableToArray$c(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$c(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$g(arr); } + +function _arrayLikeToArray$g(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$U(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$P(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); } } + +function _createClass$P(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$P(Constructor.prototype, protoProps); if (staticProps) _defineProperties$P(Constructor, staticProps); return Constructor; } + +function _get$2(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$2 = Reflect.get; } else { _get$2 = function _get(target, property, receiver) { var base = _superPropBase$2(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$2(target, property, receiver || target); } + +function _superPropBase$2(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$n(object); if (object === null) break; } return object; } + +function _inherits$n(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$o(subClass, superClass); } + +function _setPrototypeOf$o(o, p) { _setPrototypeOf$o = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$o(o, p); } + +function _createSuper$n(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$o(); return function _createSuperInternal() { var Super = _getPrototypeOf$n(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$n(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$n(this, result); }; } + +function _possibleConstructorReturn$n(self, call) { if (call && (_typeof$u(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$n(self); } + +function _assertThisInitialized$n(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$o() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$n(o) { _getPrototypeOf$n = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$n(o); } + +function _defineProperty$3(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +/** + * Map for storing mappings from an physical index to a value. Those entries are linked and stored in a certain order. + * + * It does not update stored values on remove/add row or column action. Otherwise, order of entries is updated after + * such changes. + */ + +var LinkedPhysicalIndexToValueMap = /*#__PURE__*/function (_IndexMap) { + _inherits$n(LinkedPhysicalIndexToValueMap, _IndexMap); + + var _super = _createSuper$n(LinkedPhysicalIndexToValueMap); + + function LinkedPhysicalIndexToValueMap() { + var _this; + + _classCallCheck$U(this, LinkedPhysicalIndexToValueMap); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty$3(_assertThisInitialized$n(_this), "orderOfIndexes", []); + + return _this; + } + + _createClass$P(LinkedPhysicalIndexToValueMap, [{ + key: "getValues", + value: + /** + * Get full list of ordered values for particular indexes. + * + * @returns {Array} + */ + function getValues() { + var _this2 = this; + + return this.orderOfIndexes.map(function (physicalIndex) { + return _this2.indexedValues[physicalIndex]; + }); + } + /** + * Set new values for particular indexes. Entries are linked and stored in a certain order. + * + * Note: Please keep in mind that `change` hook triggered by the method may not update cache of a collection immediately. + * + * @param {Array} values List of set values. + */ + + }, { + key: "setValues", + value: function setValues(values) { + this.orderOfIndexes = _toConsumableArray$e(Array(values.length).keys()); + + _get$2(_getPrototypeOf$n(LinkedPhysicalIndexToValueMap.prototype), "setValues", this).call(this, values); + } + /** + * Set value at index and add it to the linked list of entries. Entries are stored in a certain order. + * + * Note: Value will be added at the end of the queue. + * + * @param {number} index The index. + * @param {*} value The value to save. + * @param {number} position Position to which entry will be added. + * + * @returns {boolean} + */ + + }, { + key: "setValueAtIndex", + value: function setValueAtIndex(index, value) { + var position = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.orderOfIndexes.length; + + if (index < this.indexedValues.length) { + this.indexedValues[index] = value; + + if (this.orderOfIndexes.includes(index) === false) { + this.orderOfIndexes.splice(position, 0, index); + } + + this.runLocalHooks('change'); + return true; + } + + return false; + } + /** + * Clear value for particular index. + * + * @param {number} physicalIndex Physical index. + */ + + }, { + key: "clearValue", + value: function clearValue(physicalIndex) { + this.orderOfIndexes = getListWithRemovedItems(this.orderOfIndexes, [physicalIndex]); + + if (isFunction(this.initValueOrFn)) { + _get$2(_getPrototypeOf$n(LinkedPhysicalIndexToValueMap.prototype), "setValueAtIndex", this).call(this, physicalIndex, this.initValueOrFn(physicalIndex)); + } else { + _get$2(_getPrototypeOf$n(LinkedPhysicalIndexToValueMap.prototype), "setValueAtIndex", this).call(this, physicalIndex, this.initValueOrFn); + } + } + /** + * Get length of the index map. + * + * @returns {number} + */ + + }, { + key: "getLength", + value: function getLength() { + return this.orderOfIndexes.length; + } + /** + * Set default values for elements from `0` to `n`, where `n` is equal to the handled variable. + * + * Note: Please keep in mind that `change` hook triggered by the method may not update cache of a collection immediately. + * + * @private + * @param {number} [length] Length of list. + */ + + }, { + key: "setDefaultValues", + value: function setDefaultValues() { + var length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.indexedValues.length; + this.orderOfIndexes.length = 0; + + _get$2(_getPrototypeOf$n(LinkedPhysicalIndexToValueMap.prototype), "setDefaultValues", this).call(this, length); + } + /** + * Add values to list and reorganize. It updates list of indexes related to ordered values. + * + * @private + * @param {number} insertionIndex Position inside the list. + * @param {Array} insertedIndexes List of inserted indexes. + */ + + }, { + key: "insert", + value: function insert(insertionIndex, insertedIndexes) { + this.indexedValues = getListWithInsertedItems$1(this.indexedValues, insertionIndex, insertedIndexes, this.initValueOrFn); + this.orderOfIndexes = getIncreasedIndexes(this.orderOfIndexes, insertedIndexes); + + _get$2(_getPrototypeOf$n(LinkedPhysicalIndexToValueMap.prototype), "insert", this).call(this, insertionIndex, insertedIndexes); + } + /** + * Remove values from the list and reorganize. It updates list of indexes related to ordered values. + * + * @private + * @param {Array} removedIndexes List of removed indexes. + */ + + }, { + key: "remove", + value: function remove(removedIndexes) { + this.indexedValues = getListWithRemovedItems$1(this.indexedValues, removedIndexes); + this.orderOfIndexes = getListWithRemovedItems(this.orderOfIndexes, removedIndexes); + this.orderOfIndexes = getDecreasedIndexes(this.orderOfIndexes, removedIndexes); + + _get$2(_getPrototypeOf$n(LinkedPhysicalIndexToValueMap.prototype), "remove", this).call(this, removedIndexes); + } + /** + * Get every entry containing index and value, respecting order of indexes. + * + * @returns {Array} + */ + + }, { + key: "getEntries", + value: function getEntries() { + var _this3 = this; + + return this.orderOfIndexes.map(function (physicalIndex) { + return [physicalIndex, _this3.getValueAtIndex(physicalIndex)]; + }); + } + }]); + + return LinkedPhysicalIndexToValueMap; +}(IndexMap); + +var holder = new WeakMap(); +var rootInstanceSymbol = Symbol('rootInstance'); +/** + * Register an object as a root instance. + * + * @param {object} object An object to associate with root instance flag. + */ + +function registerAsRootInstance(object) { + holder.set(object, true); +} +/** + * Check if the source of the root indication call is valid. + * + * @param {symbol} rootSymbol A symbol as a source of truth. + * @returns {boolean} + */ + +function hasValidParameter(rootSymbol) { + return rootSymbol === rootInstanceSymbol; +} +/** + * Check if passed an object was flagged as a root instance. + * + * @param {object} object An object to check. + * @returns {boolean} + */ + +function isRootInstance(object) { + return holder.has(object); +} + +var _templateObject$3; + +function _taggedTemplateLiteral$3(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } +/** + * Perform shallow extend of a target object with only this extension's properties which doesn't exist in the target. + * + * TODO: Maybe it should be moved to global helpers? It's changed `extend` function. + * + * @param {object} target An object that will receive the new properties. + * @param {object} extension An object containing additional properties to merge into the target. + * @returns {object} + */ + +function extendNotExistingKeys(target, extension) { + objectEach(extension, function (value, key) { + if (isUndefined(target[key])) { + target[key] = value; + } + }); + return target; +} +/** + * Normalize language code. It takes handled languageCode proposition and change it to proper languageCode. + * For example, when it takes `eN-us` as parameter it return `en-US`. + * + * @param {string} languageCode Language code for specific language i.e. 'en-US', 'pt-BR', 'de-DE'. + * @returns {string} + */ + +function normalizeLanguageCode(languageCode) { + var languageCodePattern = /^([a-zA-Z]{2})-([a-zA-Z]{2})$/; + var partsOfLanguageCode = languageCodePattern.exec(languageCode); + + if (partsOfLanguageCode) { + return "".concat(partsOfLanguageCode[1].toLowerCase(), "-").concat(partsOfLanguageCode[2].toUpperCase()); + } + + return languageCode; +} +/** + * + * Warn user if there is no registered language. + * + * @param {string} languageCode Language code for specific language i.e. 'en-US', 'pt-BR', 'de-DE'. + */ + +function warnUserAboutLanguageRegistration(languageCode) { + if (isDefined(languageCode)) { + error(toSingleLine(_templateObject$3 || (_templateObject$3 = _taggedTemplateLiteral$3(["Language with code \"", "\" was not found. You should register particular language \n before using it. Read more about this issue at: https://docs.handsontable.com/i18n/missing-language-code."], ["Language with code \"", "\" was not found. You should register particular language\\x20\n before using it. Read more about this issue at: https://docs.handsontable.com/i18n/missing-language-code."])), languageCode)); + } +} + +/** + * Try to choose plural form from available phrase propositions. + * + * @param {Array} phrasePropositions List of phrases propositions. + * @param {number} pluralForm Number determining which phrase form should be used. + * + * @returns {string|Array} One particular phrase if it's possible, list of unchanged phrase propositions otherwise. + */ +function pluralize(phrasePropositions, pluralForm) { + var isPluralizable = Array.isArray(phrasePropositions) && Number.isInteger(pluralForm); + + if (isPluralizable) { + return phrasePropositions[pluralForm]; + } + + return phrasePropositions; +} + +var _staticRegister$4 = staticRegister('phraseFormatters'), + registerGloballyPhraseFormatter = _staticRegister$4.register, + getGlobalPhraseFormatters = _staticRegister$4.getValues; +/** + * Register phrase formatter. + * + * @param {string} name Name of formatter. + * @param {Function} formatterFn Function which will be applied on phrase propositions. It will transform them if it's possible. + */ + + +function register$4(name, formatterFn) { + registerGloballyPhraseFormatter(name, formatterFn); +} +/** + * Get all registered previously formatters. + * + * @returns {Array} + */ + +function getAll() { + return getGlobalPhraseFormatters(); +} +register$4('pluralize', pluralize); + +/** + * Constants for parts of translation. + */ +var CONTEXT_MENU_ITEMS_NAMESPACE = 'ContextMenu:items'; +var CONTEXTMENU_ITEMS_NO_ITEMS = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".noItems"); +var CONTEXTMENU_ITEMS_ROW_ABOVE = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".insertRowAbove"); +var CONTEXTMENU_ITEMS_ROW_BELOW = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".insertRowBelow"); +var CONTEXTMENU_ITEMS_INSERT_LEFT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".insertColumnOnTheLeft"); +var CONTEXTMENU_ITEMS_INSERT_RIGHT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".insertColumnOnTheRight"); +var CONTEXTMENU_ITEMS_REMOVE_ROW = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".removeRow"); +var CONTEXTMENU_ITEMS_REMOVE_COLUMN = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".removeColumn"); +var CONTEXTMENU_ITEMS_UNDO = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".undo"); +var CONTEXTMENU_ITEMS_REDO = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".redo"); +var CONTEXTMENU_ITEMS_READ_ONLY = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".readOnly"); +var CONTEXTMENU_ITEMS_CLEAR_COLUMN = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".clearColumn"); +var CONTEXTMENU_ITEMS_COPY = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".copy"); +var CONTEXTMENU_ITEMS_CUT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".cut"); +var CONTEXTMENU_ITEMS_FREEZE_COLUMN = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".freezeColumn"); +var CONTEXTMENU_ITEMS_UNFREEZE_COLUMN = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".unfreezeColumn"); +var CONTEXTMENU_ITEMS_MERGE_CELLS = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".mergeCells"); +var CONTEXTMENU_ITEMS_UNMERGE_CELLS = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".unmergeCells"); +var CONTEXTMENU_ITEMS_ADD_COMMENT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".addComment"); +var CONTEXTMENU_ITEMS_EDIT_COMMENT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".editComment"); +var CONTEXTMENU_ITEMS_REMOVE_COMMENT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".removeComment"); +var CONTEXTMENU_ITEMS_READ_ONLY_COMMENT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".readOnlyComment"); +var CONTEXTMENU_ITEMS_ALIGNMENT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".align"); +var CONTEXTMENU_ITEMS_ALIGNMENT_LEFT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".align.left"); +var CONTEXTMENU_ITEMS_ALIGNMENT_CENTER = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".align.center"); +var CONTEXTMENU_ITEMS_ALIGNMENT_RIGHT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".align.right"); +var CONTEXTMENU_ITEMS_ALIGNMENT_JUSTIFY = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".align.justify"); +var CONTEXTMENU_ITEMS_ALIGNMENT_TOP = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".align.top"); +var CONTEXTMENU_ITEMS_ALIGNMENT_MIDDLE = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".align.middle"); +var CONTEXTMENU_ITEMS_ALIGNMENT_BOTTOM = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".align.bottom"); +var CONTEXTMENU_ITEMS_BORDERS = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".borders"); +var CONTEXTMENU_ITEMS_BORDERS_TOP = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".borders.top"); +var CONTEXTMENU_ITEMS_BORDERS_RIGHT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".borders.right"); +var CONTEXTMENU_ITEMS_BORDERS_BOTTOM = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".borders.bottom"); +var CONTEXTMENU_ITEMS_BORDERS_LEFT = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".borders.left"); +var CONTEXTMENU_ITEMS_REMOVE_BORDERS = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".borders.remove"); +var CONTEXTMENU_ITEMS_NESTED_ROWS_INSERT_CHILD = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".nestedHeaders.insertChildRow"); // eslint-disable-line max-len + +var CONTEXTMENU_ITEMS_NESTED_ROWS_DETACH_CHILD = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".nestedHeaders.detachFromParent"); // eslint-disable-line max-len + +var CONTEXTMENU_ITEMS_HIDE_COLUMN = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".hideColumn"); +var CONTEXTMENU_ITEMS_SHOW_COLUMN = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".showColumn"); +var CONTEXTMENU_ITEMS_HIDE_ROW = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".hideRow"); +var CONTEXTMENU_ITEMS_SHOW_ROW = "".concat(CONTEXT_MENU_ITEMS_NAMESPACE, ".showRow"); +var FILTERS_NAMESPACE = 'Filters:'; +var FILTERS_CONDITIONS_NAMESPACE = "".concat(FILTERS_NAMESPACE, "conditions"); +var FILTERS_CONDITIONS_NONE = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".none"); +var FILTERS_CONDITIONS_EMPTY = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".isEmpty"); +var FILTERS_CONDITIONS_NOT_EMPTY = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".isNotEmpty"); +var FILTERS_CONDITIONS_EQUAL = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".isEqualTo"); +var FILTERS_CONDITIONS_NOT_EQUAL = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".isNotEqualTo"); +var FILTERS_CONDITIONS_BEGINS_WITH = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".beginsWith"); +var FILTERS_CONDITIONS_ENDS_WITH = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".endsWith"); +var FILTERS_CONDITIONS_CONTAINS = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".contains"); +var FILTERS_CONDITIONS_NOT_CONTAIN = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".doesNotContain"); +var FILTERS_CONDITIONS_BY_VALUE = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".byValue"); +var FILTERS_CONDITIONS_GREATER_THAN = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".greaterThan"); +var FILTERS_CONDITIONS_GREATER_THAN_OR_EQUAL = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".greaterThanOrEqualTo"); +var FILTERS_CONDITIONS_LESS_THAN = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".lessThan"); +var FILTERS_CONDITIONS_LESS_THAN_OR_EQUAL = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".lessThanOrEqualTo"); +var FILTERS_CONDITIONS_BETWEEN = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".isBetween"); +var FILTERS_CONDITIONS_NOT_BETWEEN = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".isNotBetween"); +var FILTERS_CONDITIONS_AFTER = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".after"); +var FILTERS_CONDITIONS_BEFORE = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".before"); +var FILTERS_CONDITIONS_TODAY = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".today"); +var FILTERS_CONDITIONS_TOMORROW = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".tomorrow"); +var FILTERS_CONDITIONS_YESTERDAY = "".concat(FILTERS_CONDITIONS_NAMESPACE, ".yesterday"); +var FILTERS_DIVS_FILTER_BY_CONDITION = "".concat(FILTERS_NAMESPACE, "labels.filterByCondition"); +var FILTERS_DIVS_FILTER_BY_VALUE = "".concat(FILTERS_NAMESPACE, "labels.filterByValue"); +var FILTERS_LABELS_CONJUNCTION = "".concat(FILTERS_NAMESPACE, "labels.conjunction"); +var FILTERS_LABELS_DISJUNCTION = "".concat(FILTERS_NAMESPACE, "labels.disjunction"); +var FILTERS_VALUES_BLANK_CELLS = "".concat(FILTERS_NAMESPACE, "values.blankCells"); +var FILTERS_BUTTONS_SELECT_ALL = "".concat(FILTERS_NAMESPACE, "buttons.selectAll"); +var FILTERS_BUTTONS_CLEAR = "".concat(FILTERS_NAMESPACE, "buttons.clear"); +var FILTERS_BUTTONS_OK = "".concat(FILTERS_NAMESPACE, "buttons.ok"); +var FILTERS_BUTTONS_CANCEL = "".concat(FILTERS_NAMESPACE, "buttons.cancel"); +var FILTERS_BUTTONS_PLACEHOLDER_SEARCH = "".concat(FILTERS_NAMESPACE, "buttons.placeholder.search"); +var FILTERS_BUTTONS_PLACEHOLDER_VALUE = "".concat(FILTERS_NAMESPACE, "buttons.placeholder.value"); +var FILTERS_BUTTONS_PLACEHOLDER_SECOND_VALUE = "".concat(FILTERS_NAMESPACE, "buttons.placeholder.secondValue"); + +var dictionaryKeys = /*#__PURE__*/Object.freeze({ + __proto__: null, + CONTEXT_MENU_ITEMS_NAMESPACE: CONTEXT_MENU_ITEMS_NAMESPACE, + CONTEXTMENU_ITEMS_NO_ITEMS: CONTEXTMENU_ITEMS_NO_ITEMS, + CONTEXTMENU_ITEMS_ROW_ABOVE: CONTEXTMENU_ITEMS_ROW_ABOVE, + CONTEXTMENU_ITEMS_ROW_BELOW: CONTEXTMENU_ITEMS_ROW_BELOW, + CONTEXTMENU_ITEMS_INSERT_LEFT: CONTEXTMENU_ITEMS_INSERT_LEFT, + CONTEXTMENU_ITEMS_INSERT_RIGHT: CONTEXTMENU_ITEMS_INSERT_RIGHT, + CONTEXTMENU_ITEMS_REMOVE_ROW: CONTEXTMENU_ITEMS_REMOVE_ROW, + CONTEXTMENU_ITEMS_REMOVE_COLUMN: CONTEXTMENU_ITEMS_REMOVE_COLUMN, + CONTEXTMENU_ITEMS_UNDO: CONTEXTMENU_ITEMS_UNDO, + CONTEXTMENU_ITEMS_REDO: CONTEXTMENU_ITEMS_REDO, + CONTEXTMENU_ITEMS_READ_ONLY: CONTEXTMENU_ITEMS_READ_ONLY, + CONTEXTMENU_ITEMS_CLEAR_COLUMN: CONTEXTMENU_ITEMS_CLEAR_COLUMN, + CONTEXTMENU_ITEMS_COPY: CONTEXTMENU_ITEMS_COPY, + CONTEXTMENU_ITEMS_CUT: CONTEXTMENU_ITEMS_CUT, + CONTEXTMENU_ITEMS_FREEZE_COLUMN: CONTEXTMENU_ITEMS_FREEZE_COLUMN, + CONTEXTMENU_ITEMS_UNFREEZE_COLUMN: CONTEXTMENU_ITEMS_UNFREEZE_COLUMN, + CONTEXTMENU_ITEMS_MERGE_CELLS: CONTEXTMENU_ITEMS_MERGE_CELLS, + CONTEXTMENU_ITEMS_UNMERGE_CELLS: CONTEXTMENU_ITEMS_UNMERGE_CELLS, + CONTEXTMENU_ITEMS_ADD_COMMENT: CONTEXTMENU_ITEMS_ADD_COMMENT, + CONTEXTMENU_ITEMS_EDIT_COMMENT: CONTEXTMENU_ITEMS_EDIT_COMMENT, + CONTEXTMENU_ITEMS_REMOVE_COMMENT: CONTEXTMENU_ITEMS_REMOVE_COMMENT, + CONTEXTMENU_ITEMS_READ_ONLY_COMMENT: CONTEXTMENU_ITEMS_READ_ONLY_COMMENT, + CONTEXTMENU_ITEMS_ALIGNMENT: CONTEXTMENU_ITEMS_ALIGNMENT, + CONTEXTMENU_ITEMS_ALIGNMENT_LEFT: CONTEXTMENU_ITEMS_ALIGNMENT_LEFT, + CONTEXTMENU_ITEMS_ALIGNMENT_CENTER: CONTEXTMENU_ITEMS_ALIGNMENT_CENTER, + CONTEXTMENU_ITEMS_ALIGNMENT_RIGHT: CONTEXTMENU_ITEMS_ALIGNMENT_RIGHT, + CONTEXTMENU_ITEMS_ALIGNMENT_JUSTIFY: CONTEXTMENU_ITEMS_ALIGNMENT_JUSTIFY, + CONTEXTMENU_ITEMS_ALIGNMENT_TOP: CONTEXTMENU_ITEMS_ALIGNMENT_TOP, + CONTEXTMENU_ITEMS_ALIGNMENT_MIDDLE: CONTEXTMENU_ITEMS_ALIGNMENT_MIDDLE, + CONTEXTMENU_ITEMS_ALIGNMENT_BOTTOM: CONTEXTMENU_ITEMS_ALIGNMENT_BOTTOM, + CONTEXTMENU_ITEMS_BORDERS: CONTEXTMENU_ITEMS_BORDERS, + CONTEXTMENU_ITEMS_BORDERS_TOP: CONTEXTMENU_ITEMS_BORDERS_TOP, + CONTEXTMENU_ITEMS_BORDERS_RIGHT: CONTEXTMENU_ITEMS_BORDERS_RIGHT, + CONTEXTMENU_ITEMS_BORDERS_BOTTOM: CONTEXTMENU_ITEMS_BORDERS_BOTTOM, + CONTEXTMENU_ITEMS_BORDERS_LEFT: CONTEXTMENU_ITEMS_BORDERS_LEFT, + CONTEXTMENU_ITEMS_REMOVE_BORDERS: CONTEXTMENU_ITEMS_REMOVE_BORDERS, + CONTEXTMENU_ITEMS_NESTED_ROWS_INSERT_CHILD: CONTEXTMENU_ITEMS_NESTED_ROWS_INSERT_CHILD, + CONTEXTMENU_ITEMS_NESTED_ROWS_DETACH_CHILD: CONTEXTMENU_ITEMS_NESTED_ROWS_DETACH_CHILD, + CONTEXTMENU_ITEMS_HIDE_COLUMN: CONTEXTMENU_ITEMS_HIDE_COLUMN, + CONTEXTMENU_ITEMS_SHOW_COLUMN: CONTEXTMENU_ITEMS_SHOW_COLUMN, + CONTEXTMENU_ITEMS_HIDE_ROW: CONTEXTMENU_ITEMS_HIDE_ROW, + CONTEXTMENU_ITEMS_SHOW_ROW: CONTEXTMENU_ITEMS_SHOW_ROW, + FILTERS_NAMESPACE: FILTERS_NAMESPACE, + FILTERS_CONDITIONS_NAMESPACE: FILTERS_CONDITIONS_NAMESPACE, + FILTERS_CONDITIONS_NONE: FILTERS_CONDITIONS_NONE, + FILTERS_CONDITIONS_EMPTY: FILTERS_CONDITIONS_EMPTY, + FILTERS_CONDITIONS_NOT_EMPTY: FILTERS_CONDITIONS_NOT_EMPTY, + FILTERS_CONDITIONS_EQUAL: FILTERS_CONDITIONS_EQUAL, + FILTERS_CONDITIONS_NOT_EQUAL: FILTERS_CONDITIONS_NOT_EQUAL, + FILTERS_CONDITIONS_BEGINS_WITH: FILTERS_CONDITIONS_BEGINS_WITH, + FILTERS_CONDITIONS_ENDS_WITH: FILTERS_CONDITIONS_ENDS_WITH, + FILTERS_CONDITIONS_CONTAINS: FILTERS_CONDITIONS_CONTAINS, + FILTERS_CONDITIONS_NOT_CONTAIN: FILTERS_CONDITIONS_NOT_CONTAIN, + FILTERS_CONDITIONS_BY_VALUE: FILTERS_CONDITIONS_BY_VALUE, + FILTERS_CONDITIONS_GREATER_THAN: FILTERS_CONDITIONS_GREATER_THAN, + FILTERS_CONDITIONS_GREATER_THAN_OR_EQUAL: FILTERS_CONDITIONS_GREATER_THAN_OR_EQUAL, + FILTERS_CONDITIONS_LESS_THAN: FILTERS_CONDITIONS_LESS_THAN, + FILTERS_CONDITIONS_LESS_THAN_OR_EQUAL: FILTERS_CONDITIONS_LESS_THAN_OR_EQUAL, + FILTERS_CONDITIONS_BETWEEN: FILTERS_CONDITIONS_BETWEEN, + FILTERS_CONDITIONS_NOT_BETWEEN: FILTERS_CONDITIONS_NOT_BETWEEN, + FILTERS_CONDITIONS_AFTER: FILTERS_CONDITIONS_AFTER, + FILTERS_CONDITIONS_BEFORE: FILTERS_CONDITIONS_BEFORE, + FILTERS_CONDITIONS_TODAY: FILTERS_CONDITIONS_TODAY, + FILTERS_CONDITIONS_TOMORROW: FILTERS_CONDITIONS_TOMORROW, + FILTERS_CONDITIONS_YESTERDAY: FILTERS_CONDITIONS_YESTERDAY, + FILTERS_DIVS_FILTER_BY_CONDITION: FILTERS_DIVS_FILTER_BY_CONDITION, + FILTERS_DIVS_FILTER_BY_VALUE: FILTERS_DIVS_FILTER_BY_VALUE, + FILTERS_LABELS_CONJUNCTION: FILTERS_LABELS_CONJUNCTION, + FILTERS_LABELS_DISJUNCTION: FILTERS_LABELS_DISJUNCTION, + FILTERS_VALUES_BLANK_CELLS: FILTERS_VALUES_BLANK_CELLS, + FILTERS_BUTTONS_SELECT_ALL: FILTERS_BUTTONS_SELECT_ALL, + FILTERS_BUTTONS_CLEAR: FILTERS_BUTTONS_CLEAR, + FILTERS_BUTTONS_OK: FILTERS_BUTTONS_OK, + FILTERS_BUTTONS_CANCEL: FILTERS_BUTTONS_CANCEL, + FILTERS_BUTTONS_PLACEHOLDER_SEARCH: FILTERS_BUTTONS_PLACEHOLDER_SEARCH, + FILTERS_BUTTONS_PLACEHOLDER_VALUE: FILTERS_BUTTONS_PLACEHOLDER_VALUE, + FILTERS_BUTTONS_PLACEHOLDER_SECOND_VALUE: FILTERS_BUTTONS_PLACEHOLDER_SECOND_VALUE +}); + +var _dictionary; + +function _defineProperty$4(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +var dictionary = (_dictionary = { + languageCode: 'en-US' +}, _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_NO_ITEMS, 'No available options'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ROW_ABOVE, 'Insert row above'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ROW_BELOW, 'Insert row below'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_INSERT_LEFT, 'Insert column left'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_INSERT_RIGHT, 'Insert column right'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_REMOVE_ROW, ['Remove row', 'Remove rows']), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_REMOVE_COLUMN, ['Remove column', 'Remove columns']), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_UNDO, 'Undo'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_REDO, 'Redo'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_READ_ONLY, 'Read only'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_CLEAR_COLUMN, 'Clear column'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ALIGNMENT, 'Alignment'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ALIGNMENT_LEFT, 'Left'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ALIGNMENT_CENTER, 'Center'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ALIGNMENT_RIGHT, 'Right'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ALIGNMENT_JUSTIFY, 'Justify'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ALIGNMENT_TOP, 'Top'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ALIGNMENT_MIDDLE, 'Middle'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ALIGNMENT_BOTTOM, 'Bottom'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_FREEZE_COLUMN, 'Freeze column'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_UNFREEZE_COLUMN, 'Unfreeze column'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_BORDERS, 'Borders'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_BORDERS_TOP, 'Top'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_BORDERS_RIGHT, 'Right'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_BORDERS_BOTTOM, 'Bottom'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_BORDERS_LEFT, 'Left'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_REMOVE_BORDERS, 'Remove border(s)'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_ADD_COMMENT, 'Add comment'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_EDIT_COMMENT, 'Edit comment'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_REMOVE_COMMENT, 'Delete comment'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_READ_ONLY_COMMENT, 'Read-only comment'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_MERGE_CELLS, 'Merge cells'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_UNMERGE_CELLS, 'Unmerge cells'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_COPY, 'Copy'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_CUT, 'Cut'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_NESTED_ROWS_INSERT_CHILD, 'Insert child row'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_NESTED_ROWS_DETACH_CHILD, 'Detach from parent'), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_HIDE_COLUMN, ['Hide column', 'Hide columns']), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_SHOW_COLUMN, ['Show column', 'Show columns']), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_HIDE_ROW, ['Hide row', 'Hide rows']), _defineProperty$4(_dictionary, CONTEXTMENU_ITEMS_SHOW_ROW, ['Show row', 'Show rows']), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_NONE, 'None'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_EMPTY, 'Is empty'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_NOT_EMPTY, 'Is not empty'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_EQUAL, 'Is equal to'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_NOT_EQUAL, 'Is not equal to'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_BEGINS_WITH, 'Begins with'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_ENDS_WITH, 'Ends with'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_CONTAINS, 'Contains'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_NOT_CONTAIN, 'Does not contain'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_GREATER_THAN, 'Greater than'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_GREATER_THAN_OR_EQUAL, 'Greater than or equal to'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_LESS_THAN, 'Less than'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_LESS_THAN_OR_EQUAL, 'Less than or equal to'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_BETWEEN, 'Is between'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_NOT_BETWEEN, 'Is not between'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_AFTER, 'After'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_BEFORE, 'Before'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_TODAY, 'Today'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_TOMORROW, 'Tomorrow'), _defineProperty$4(_dictionary, FILTERS_CONDITIONS_YESTERDAY, 'Yesterday'), _defineProperty$4(_dictionary, FILTERS_VALUES_BLANK_CELLS, 'Blank cells'), _defineProperty$4(_dictionary, FILTERS_DIVS_FILTER_BY_CONDITION, 'Filter by condition'), _defineProperty$4(_dictionary, FILTERS_DIVS_FILTER_BY_VALUE, 'Filter by value'), _defineProperty$4(_dictionary, FILTERS_LABELS_CONJUNCTION, 'And'), _defineProperty$4(_dictionary, FILTERS_LABELS_DISJUNCTION, 'Or'), _defineProperty$4(_dictionary, FILTERS_BUTTONS_SELECT_ALL, 'Select all'), _defineProperty$4(_dictionary, FILTERS_BUTTONS_CLEAR, 'Clear'), _defineProperty$4(_dictionary, FILTERS_BUTTONS_OK, 'OK'), _defineProperty$4(_dictionary, FILTERS_BUTTONS_CANCEL, 'Cancel'), _defineProperty$4(_dictionary, FILTERS_BUTTONS_PLACEHOLDER_SEARCH, 'Search'), _defineProperty$4(_dictionary, FILTERS_BUTTONS_PLACEHOLDER_VALUE, 'Value'), _defineProperty$4(_dictionary, FILTERS_BUTTONS_PLACEHOLDER_SECOND_VALUE, 'Second value'), _dictionary); + +var DEFAULT_LANGUAGE_CODE = dictionary.languageCode; + +var _staticRegister$5 = staticRegister('languagesDictionaries'), + registerGloballyLanguageDictionary = _staticRegister$5.register, + getGlobalLanguageDictionary = _staticRegister$5.getItem, + hasGlobalLanguageDictionary = _staticRegister$5.hasItem, + getGlobalLanguagesDictionaries = _staticRegister$5.getValues; +/** + * Register automatically the default language dictionary. + */ + + +registerLanguageDictionary(dictionary); +/** + * Register language dictionary for specific language code. + * + * @param {string|object} languageCodeOrDictionary Language code for specific language i.e. 'en-US', 'pt-BR', 'de-DE' or object representing dictionary. + * @param {object} dictionary Dictionary for specific language (optional if first parameter has already dictionary). + * @returns {object} + */ + +function registerLanguageDictionary(languageCodeOrDictionary, dictionary) { + var languageCode = languageCodeOrDictionary; + var dictionaryObject = dictionary; // Dictionary passed as first argument. + + if (isObject$1(languageCodeOrDictionary)) { + dictionaryObject = languageCodeOrDictionary; + languageCode = dictionaryObject.languageCode; + } + + extendLanguageDictionary(languageCode, dictionaryObject); + registerGloballyLanguageDictionary(languageCode, deepClone(dictionaryObject)); // We do not allow user to work with dictionary by reference, it can cause lot of bugs. + + return deepClone(dictionaryObject); +} +/** + * Extend handled dictionary by default language dictionary. As result, if any dictionary key isn't defined for specific language, it will be filled with default language value ("dictionary gaps" are supplemented). + * + * @private + * @param {string} languageCode Language code. + * @param {object} dictionary Dictionary which is extended. + */ + +function extendLanguageDictionary(languageCode, dictionary) { + if (languageCode !== DEFAULT_LANGUAGE_CODE) { + extendNotExistingKeys(dictionary, getGlobalLanguageDictionary(DEFAULT_LANGUAGE_CODE)); + } +} +/** + * Get language dictionary for specific language code. + * + * @param {string} languageCode Language code. + * @returns {object} Object with constants representing identifiers for translation (as keys) and corresponding translation phrases (as values). + */ + + +function getLanguageDictionary(languageCode) { + if (!hasLanguageDictionary(languageCode)) { + return null; + } + + return deepClone(getGlobalLanguageDictionary(languageCode)); +} +/** + * + * Get if language with specified language code was registered. + * + * @param {string} languageCode Language code for specific language i.e. 'en-US', 'pt-BR', 'de-DE'. + * @returns {boolean} + */ + +function hasLanguageDictionary(languageCode) { + return hasGlobalLanguageDictionary(languageCode); +} +/** + * Get registered language dictionaries. + * + * @returns {Array} + */ + +function getLanguagesDictionaries() { + return getGlobalLanguagesDictionaries(); +} +/** + * Get phrase for specified dictionary key. + * + * @param {string} languageCode Language code for specific language i.e. 'en-US', 'pt-BR', 'de-DE'. + * @param {string} dictionaryKey Constant which is dictionary key. + * @param {*} argumentsForFormatters Arguments which will be handled by formatters. + * + * @returns {string} + */ + +function getTranslatedPhrase(languageCode, dictionaryKey, argumentsForFormatters) { + var languageDictionary = getLanguageDictionary(languageCode); + + if (languageDictionary === null) { + return null; + } + + var phrasePropositions = languageDictionary[dictionaryKey]; + + if (isUndefined(phrasePropositions)) { + return null; + } + + var formattedPhrase = getFormattedPhrase(phrasePropositions, argumentsForFormatters); + + if (Array.isArray(formattedPhrase)) { + return formattedPhrase[0]; + } + + return formattedPhrase; +} +/** + * Get formatted phrase from phrases propositions for specified dictionary key. + * + * @private + * @param {Array|string} phrasePropositions List of phrase propositions. + * @param {*} argumentsForFormatters Arguments which will be handled by formatters. + * + * @returns {Array|string} + */ + +function getFormattedPhrase(phrasePropositions, argumentsForFormatters) { + var formattedPhrasePropositions = phrasePropositions; + arrayEach(getAll(), function (formatter) { + formattedPhrasePropositions = formatter(phrasePropositions, argumentsForFormatters); + }); + return formattedPhrasePropositions; +} +/** + * Returns valid language code. If the passed language code doesn't exist default one will be used. + * + * @param {string} languageCode Language code for specific language i.e. 'en-US', 'pt-BR', 'de-DE'. + * @returns {string} + */ + + +function getValidLanguageCode(languageCode) { + var normalizedLanguageCode = normalizeLanguageCode(languageCode); + + if (!hasLanguageDictionary(normalizedLanguageCode)) { + normalizedLanguageCode = DEFAULT_LANGUAGE_CODE; + warnUserAboutLanguageRegistration(languageCode); + } + + return normalizedLanguageCode; +} + +var eventManager = new EventManager(); +var pressedKeys = new Set(); +var refCount = 0; +/** + * Begins observing keyboard keys states. + * + * @param {Document} rootDocument The document owner. + */ + +function startObserving(rootDocument) { + if (refCount === 0) { + eventManager.addEventListener(rootDocument, 'keydown', function (event) { + if (!pressedKeys.has(event.keyCode)) { + pressedKeys.add(event.keyCode); + } + }); + eventManager.addEventListener(rootDocument, 'keyup', function (event) { + if (pressedKeys.has(event.keyCode)) { + pressedKeys.delete(event.keyCode); + } + }); + eventManager.addEventListener(rootDocument, 'visibilitychange', function () { + if (rootDocument.hidden) { + pressedKeys.clear(); + } + }); + eventManager.addEventListener(rootDocument.defaultView, 'blur', function () { + pressedKeys.clear(); + }); + } + + refCount += 1; +} +/** + * Stops observing keyboard keys states and clear all previously saved states. + */ + + +function stopObserving() { + if (refCount > 0) { + refCount -= 1; + } + + if (refCount === 0) { + _resetState(); + } +} +/** + * Remove all listeners attached to the DOM and clear all previously saved states. + */ + + +function _resetState() { + eventManager.clearEvents(); + pressedKeys.clear(); + refCount = 0; +} +/** + * Checks if ctrl keys are pressed. + * + * @returns {boolean} + */ + + +function isPressedCtrlKey() { + var values = Array.from(pressedKeys.values()); + return values.some(function (_keyCode) { + return isCtrlMetaKey(_keyCode); + }); +} + +function _typeof$v(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$v = function _typeof(obj) { return typeof obj; }; } else { _typeof$v = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$v(obj); } + +function _slicedToArray$9(arr, i) { return _arrayWithHoles$9(arr) || _iterableToArrayLimit$9(arr, i) || _unsupportedIterableToArray$h(arr, i) || _nonIterableRest$9(); } + +function _nonIterableRest$9() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$h(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$h(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$h(o, minLen); } + +function _arrayLikeToArray$h(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$9(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$9(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$V(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$Q(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); } } + +function _createClass$Q(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$Q(Constructor.prototype, protoProps); if (staticProps) _defineProperties$Q(Constructor, staticProps); return Constructor; } + +function _get$3(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$3 = Reflect.get; } else { _get$3 = function _get(target, property, receiver) { var base = _superPropBase$3(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$3(target, property, receiver || target); } + +function _superPropBase$3(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$o(object); if (object === null) break; } return object; } + +function _inherits$o(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$p(subClass, superClass); } + +function _setPrototypeOf$p(o, p) { _setPrototypeOf$p = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$p(o, p); } + +function _createSuper$o(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$p(); return function _createSuperInternal() { var Super = _getPrototypeOf$o(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$o(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$o(this, result); }; } + +function _possibleConstructorReturn$o(self, call) { if (call && (_typeof$v(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$o(self); } + +function _assertThisInitialized$o(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$p() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$o(o) { _getPrototypeOf$o = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$o(o); } + +var VisualSelection = /*#__PURE__*/function (_Selection) { + _inherits$o(VisualSelection, _Selection); + + var _super = _createSuper$o(VisualSelection); + + function VisualSelection(settings, visualCellRange) { + var _this; + + _classCallCheck$V(this, VisualSelection); + + _this = _super.call(this, settings, null); + /** + * Range of selection visually. Visual representation may have representation in a rendered selection. + * + * @type {null|CellRange} + */ + + _this.visualCellRange = visualCellRange || null; + + _this.commit(); + + return _this; + } + /** + * Adds a cell coords to the selection. + * + * @param {CellCoords} coords Visual coordinates of a cell. + * @returns {VisualSelection} + */ + + + _createClass$Q(VisualSelection, [{ + key: "add", + value: function add(coords) { + if (this.visualCellRange === null) { + this.visualCellRange = new CellRange(coords); + } else { + this.visualCellRange.expand(coords); + } + + return this; + } + /** + * Clears visual and renderable selection. + * + * @returns {VisualSelection} + */ + + }, { + key: "clear", + value: function clear() { + this.visualCellRange = null; + return _get$3(_getPrototypeOf$o(VisualSelection.prototype), "clear", this).call(this); + } + /** + * Search for the first visible coordinates in the range as range may start and/or end with the hidden index. + * + * @private + * @param {CellCoords} startCoords Visual start coordinates for the range. Starting point for finding destination coordinates + * with visible coordinates (we are going from the starting coordinates to the end coordinates until the criteria are met). + * @param {CellCoords} endCoords Visual end coordinates for the range. + * @param {number} incrementByRow We are searching for a next visible rows by increasing (to be precise, or decreasing) indexes. + * This variable represent indexes shift. We are looking for an index: + * - for rows: from the left to the right (increasing indexes, then variable should have value 1) or + * other way around (decreasing indexes, then variable should have the value -1) + * - for columns: from the top to the bottom (increasing indexes, then variable should have value 1) + * or other way around (decreasing indexes, then variable should have the value -1). + * @param {number} incrementByColumn As above, just indexes shift for columns. + * @returns {null|CellCoords} Visual cell coordinates. + */ + + }, { + key: "findVisibleCoordsInRange", + value: function findVisibleCoordsInRange(startCoords, endCoords, incrementByRow) { + var incrementByColumn = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : incrementByRow; + var nextVisibleRow = this.findVisibleCoordsInRowsRange(startCoords.row, endCoords.row, incrementByRow); // There are no more visual rows in the range. + + if (nextVisibleRow === null) { + return null; + } + + var nextVisibleColumn = this.findVisibleCoordsInColumnsRange(startCoords.col, endCoords.col, incrementByColumn); // There are no more visual columns in the range. + + if (nextVisibleColumn === null) { + return null; + } + + return new CellCoords(nextVisibleRow, nextVisibleColumn); + } + /** + * Searches the nearest visible row index, which is not hidden (is renderable). + * + * @private + * @param {CellCoords} startVisibleRow Visual row index which starts the range. Starting point for finding + * destination coordinates with visible coordinates (we are going from the starting coordinates to the end + * coordinates until the criteria are met). + * @param {CellCoords} endVisibleRow Visual row index which ends the range. + * @param {number} incrementBy We are searching for a next visible rows by increasing (to be precise, or decreasing) + * indexes. This variable represent indexes shift. From the left to the right (increasing indexes, then variable + * should have value 1) or other way around (decreasing indexes, then variable should have the value -1). + * @returns {number|null} The visual row index. + */ + + }, { + key: "findVisibleCoordsInRowsRange", + value: function findVisibleCoordsInRowsRange(startVisibleRow, endVisibleRow, incrementBy) { + var _this$settings$visual = this.settings.visualToRenderableCoords({ + row: startVisibleRow, + col: -1 + }), + startRowRenderable = _this$settings$visual.row; // There are no more visual rows in the range. + + + if (endVisibleRow === startVisibleRow && startRowRenderable === null) { + return null; + } // We are looking for a next visible row in the range. + + + if (startRowRenderable === null) { + return this.findVisibleCoordsInRowsRange(startVisibleRow + incrementBy, endVisibleRow, incrementBy); + } // We found visible row index in the range. + + + return startVisibleRow; + } + /** + * Searches the nearest visible column index, which is not hidden (is renderable). + * + * @private + * @param {CellCoords} startVisibleColumn Visual column index which starts the range. Starting point for finding + * destination coordinates with visible coordinates (we are going from the starting coordinates to the end + * coordinates until the criteria are met). + * @param {CellCoords} endVisibleColumn Visual column index which ends the range. + * @param {number} incrementBy We are searching for a next visible columns by increasing (to be precise, or decreasing) + * indexes. This variable represent indexes shift. From the top to the bottom (increasing indexes, then variable + * should have value 1) or other way around (decreasing indexes, then variable should have the value -1). + * @returns {number|null} The visual column index. + */ + + }, { + key: "findVisibleCoordsInColumnsRange", + value: function findVisibleCoordsInColumnsRange(startVisibleColumn, endVisibleColumn, incrementBy) { + var _this$settings$visual2 = this.settings.visualToRenderableCoords({ + row: -1, + col: startVisibleColumn + }), + startColumnRenderable = _this$settings$visual2.col; // There are no more visual columns in the range. + + + if (endVisibleColumn === startVisibleColumn && startColumnRenderable === null) { + return null; + } // We are looking for a next visible column in the range. + + + if (startColumnRenderable === null) { + return this.findVisibleCoordsInColumnsRange(startVisibleColumn + incrementBy, endVisibleColumn, incrementBy); + } // We found visible column index in the range. + + + return startVisibleColumn; + } + /** + * Searches the nearest visible column and row index, which is not hidden (is renderable). If one + * of the axes' range is entirely hidden, then created CellCoords object will hold the `null` value + * under a specific axis. For example, when we select the hidden column, then the calculated `col` + * prop will be `null`. In that case, rows are calculated further (regardless of the column result) + * to make rows header highlightable. + * + * @private + * @param {CellCoords} visualFromCoords Visual start coordinates for the range. Starting point for finding destination coordinates + * with visible coordinates (we are going from the starting coordinates to the end coordinates until the criteria are met). + * @param {CellCoords} visualToCoords Visual end coordinates for the range. + * @param {number} incrementByRow We are searching for a next visible rows by increasing (to be precise, or decreasing) indexes. + * This variable represent indexes shift. We are looking for an index: + * - for rows: from the left to the right (increasing indexes, then variable should have value 1) or + * other way around (decreasing indexes, then variable should have the value -1) + * - for columns: from the top to the bottom (increasing indexes, then variable should have value 1) + * or other way around (decreasing indexes, then variable should have the value -1). + * @param {number} incrementByColumn As above, just indexes shift for columns. + * @returns {CellCoords[]|null} Visual cell coordinates. + */ + + }, { + key: "findVisibleHeaderRange", + value: function findVisibleHeaderRange(visualFromCoords, visualToCoords, incrementByRow, incrementByColumn) { + var fromRangeVisualRow = this.findVisibleCoordsInRowsRange(visualFromCoords.row, visualToCoords.row, incrementByRow); + var toRangeVisualRow = this.findVisibleCoordsInRowsRange(visualToCoords.row, visualFromCoords.row, -incrementByRow); + var fromRangeVisualColumn = this.findVisibleCoordsInColumnsRange(visualFromCoords.col, visualToCoords.col, incrementByColumn); + var toRangeVisualColumn = this.findVisibleCoordsInColumnsRange(visualToCoords.col, visualFromCoords.col, -incrementByColumn); // All rows and columns ranges are hidden. + + if (fromRangeVisualRow === null && toRangeVisualRow === null && fromRangeVisualColumn === null && toRangeVisualColumn === null) { + return null; + } + + return [new CellCoords(fromRangeVisualRow, fromRangeVisualColumn), new CellCoords(toRangeVisualRow, toRangeVisualColumn)]; + } + /** + * Override internally stored visual indexes added by the Selection's `add` function. It should be executed + * at the end of process of adding visual selection coordinates. + * + * @returns {VisualSelection} + */ + + }, { + key: "commit", + value: function commit() { + // There is no information about visual ranges, thus no selection may be displayed. + if (this.visualCellRange === null) { + return this; + } + + var _this$visualCellRange = this.visualCellRange, + visualFromCoords = _this$visualCellRange.from, + visualToCoords = _this$visualCellRange.to; // We may move in two different directions while searching for visible rows and visible columns. + + var incrementByRow = this.getRowSearchDirection(this.visualCellRange); + var incrementByColumn = this.getColumnSearchDirection(this.visualCellRange); + var fromRangeVisual = this.findVisibleCoordsInRange(visualFromCoords, visualToCoords, incrementByRow, incrementByColumn); + var toRangeVisual = this.findVisibleCoordsInRange(visualToCoords, visualFromCoords, -incrementByRow, -incrementByColumn); // There is no visual start point (and also visual end point) in the range. + // We are looking for the first visible cell in a broader range. + + if (fromRangeVisual === null || toRangeVisual === null) { + var isHeaderSelectionType = this.settings.type === 'header'; + var cellRange = null; // For the "header" selection type, find rows and column indexes, which should be + // highlighted, although one of the axes is completely hidden. + + if (isHeaderSelectionType) { + var _this$findVisibleHead = this.findVisibleHeaderRange(visualFromCoords, visualToCoords, incrementByRow, incrementByColumn), + _this$findVisibleHead2 = _slicedToArray$9(_this$findVisibleHead, 2), + fromRangeVisualHeader = _this$findVisibleHead2[0], + toRangeVisualHeader = _this$findVisibleHead2[1]; + + cellRange = this.createRenderableCellRange(fromRangeVisualHeader, toRangeVisualHeader); + } + + this.cellRange = cellRange; + } else { + this.cellRange = this.createRenderableCellRange(fromRangeVisual, toRangeVisual); + } + + return this; + } + /** + * Some selection may be a part of broader cell range. This function adjusting coordinates of current selection + * and the broader cell range when needed (current selection can't be presented visually). + * + * @param {CellRange} broaderCellRange Visual range. Actual cell range may be contained in the broader cell range. + * When there is no way to represent some cell range visually we try to find range containing just the first visible cell. + * + * Warn: Please keep in mind that this function may change coordinates of the handled broader range. + * + * @returns {VisualSelection} + */ + + }, { + key: "adjustCoordinates", + value: function adjustCoordinates(broaderCellRange) { + // We may move in two different directions while searching for visible rows and visible columns. + var incrementByRow = this.getRowSearchDirection(broaderCellRange); + var incrementByColumn = this.getColumnSearchDirection(broaderCellRange); + var normFromCoords = broaderCellRange.from.clone().normalize(); + var normToCoords = broaderCellRange.to.clone().normalize(); + var singleCellRangeVisual = this.findVisibleCoordsInRange(normFromCoords, normToCoords, incrementByRow, incrementByColumn); + + if (singleCellRangeVisual !== null) { + // We can't show selection visually now, but we found fist visible range in the broader cell range. + if (this.cellRange === null) { + var singleCellRangeRenderable = this.settings.visualToRenderableCoords(singleCellRangeVisual); + this.cellRange = new CellRange(singleCellRangeRenderable); + } // We set new highlight as it might change (for example, when showing/hiding some cells from the broader selection range) + // TODO: It is also handled by the `MergeCells` plugin while adjusting already modified coordinates. Should it? + + + broaderCellRange.setHighlight(singleCellRangeVisual); + return this; + } // Fallback to the start of the range. It resets the previous highlight (for example, when all columns have been hidden). + + + broaderCellRange.setHighlight(broaderCellRange.from); + return this; + } + /** + * Returns the top left (TL) and bottom right (BR) selection coordinates (renderable indexes). + * The method overwrites the original method to support header selection for hidden cells. + * To make the header selection working, the CellCoords and CellRange have to support not + * complete coordinates (`null` values for example, `row: null`, `col: 2`). + * + * @returns {Array} Returns array of coordinates for example `[1, 1, 5, 5]`. + */ + + }, { + key: "getCorners", + value: function getCorners() { + var _this$cellRange = this.cellRange, + from = _this$cellRange.from, + to = _this$cellRange.to; + var isRowUndefined = from.row === null || to.row === null; + var isColumnUndefined = from.col === null || to.col === null; + var topLeftCorner = new CellCoords(isRowUndefined ? null : Math.min(from.row, to.row), isColumnUndefined ? null : Math.min(from.col, to.col)); + var bottomRightCorner = new CellCoords(isRowUndefined ? null : Math.max(from.row, to.row), isColumnUndefined ? null : Math.max(from.col, to.col)); + return [topLeftCorner.row, topLeftCorner.col, bottomRightCorner.row, bottomRightCorner.col]; + } + /** + * Returns the top left (TL) and bottom right (BR) selection coordinates (visual indexes). + * + * @returns {Array} Returns array of coordinates for example `[1, 1, 5, 5]`. + */ + + }, { + key: "getVisualCorners", + value: function getVisualCorners() { + var topLeft = this.settings.renderableToVisualCoords(this.cellRange.getTopLeftCorner()); + var bottomRight = this.settings.renderableToVisualCoords(this.cellRange.getBottomRightCorner()); + return [topLeft.row, topLeft.col, bottomRight.row, bottomRight.col]; + } + /** + * Creates a new CellRange object based on visual coordinates which before object creation are + * translated to renderable indexes. + * + * @param {CellCoords} visualFromCoords The CellCoords object which contains coordinates that + * points to the begining of the selection. + * @param {CellCoords} visualToCoords The CellCoords object which contains coordinates that + * points to the end of the selection. + * @returns {CellRange} + */ + + }, { + key: "createRenderableCellRange", + value: function createRenderableCellRange(visualFromCoords, visualToCoords) { + var renderableFromCoords = this.settings.visualToRenderableCoords(visualFromCoords); + var renderableToCoords = this.settings.visualToRenderableCoords(visualToCoords); + return new CellRange(renderableFromCoords, renderableFromCoords, renderableToCoords); + } + /** + * It returns rows shift needed for searching visual row. + * + * @private + * @param {CellRange} cellRange Selection range. + * @returns {number} Rows shift. It return 1 when we should increase indexes (moving from the top to the bottom) or + * -1 when we should decrease indexes (moving other way around). + */ + + }, { + key: "getRowSearchDirection", + value: function getRowSearchDirection(cellRange) { + if (cellRange.from.row < cellRange.to.row) { + return 1; // Increasing row indexes. + } + + return -1; // Decreasing row indexes. + } + /** + * It returns columns shift needed for searching visual column. + * + * @private + * @param {CellRange} cellRange Selection range. + * @returns {number} Columns shift. It return 1 when we should increase indexes (moving from the left to the right) or + * -1 when we should decrease indexes (moving other way around). + */ + + }, { + key: "getColumnSearchDirection", + value: function getColumnSearchDirection(cellRange) { + if (cellRange.from.col < cellRange.to.col) { + return 1; // Increasing column indexes. + } + + return -1; // Decreasing column indexes. + } + }]); + + return VisualSelection; +}(Selection); + +function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$1(Object(source), true).forEach(function (key) { _defineProperty$5(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$1(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$5(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } +/** + * @returns {Selection} + */ + +function createHighlight(_ref) { + var activeHeaderClassName = _ref.activeHeaderClassName, + restOptions = _objectWithoutProperties(_ref, ["activeHeaderClassName"]); + + var s = new VisualSelection(_objectSpread({ + highlightHeaderClassName: activeHeaderClassName + }, restOptions)); + return s; +} + +function ownKeys$2(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$1(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$2(Object(source), true).forEach(function (key) { _defineProperty$6(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$2(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$6(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _objectWithoutProperties$1(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$1(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose$1(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } +/** + * Creates the new instance of Selection responsible for highlighting area of the selected multiple cells. + * + * @returns {Selection} + */ + +function createHighlight$1(_ref) { + var layerLevel = _ref.layerLevel, + areaCornerVisible = _ref.areaCornerVisible, + restOptions = _objectWithoutProperties$1(_ref, ["layerLevel", "areaCornerVisible"]); + + var s = new VisualSelection(_objectSpread$1({ + className: 'area', + markIntersections: true, + layerLevel: Math.min(layerLevel, 7), + border: { + width: 1, + color: '#4b89ff', + cornerVisible: areaCornerVisible + } + }, restOptions)); + return s; +} + +function ownKeys$3(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$2(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$3(Object(source), true).forEach(function (key) { _defineProperty$7(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$3(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$7(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _objectWithoutProperties$2(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$2(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose$2(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } +/** + * Creates the new instance of Selection responsible for highlighting currently selected cell. This type of selection + * can present on the table only one at the time. + * + * @returns {Selection} + */ + +function createHighlight$2(_ref) { + var cellCornerVisible = _ref.cellCornerVisible, + restOptions = _objectWithoutProperties$2(_ref, ["cellCornerVisible"]); + + var s = new VisualSelection(_objectSpread$2({ + className: 'current', + border: { + width: 2, + color: '#4b89ff', + cornerVisible: cellCornerVisible + } + }, restOptions)); + return s; +} + +function ownKeys$4(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$3(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$4(Object(source), true).forEach(function (key) { _defineProperty$8(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$4(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$8(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _objectWithoutProperties$3(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$3(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose$3(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } +/** + * Creates the new instance of Selection responsible for highlighting currently selected cell. This type of selection + * can present on the table only one at the time. + * + * @returns {Selection} + */ + +function createHighlight$3(_ref) { + var border = _ref.border, + visualCellRange = _ref.visualCellRange, + restOptions = _objectWithoutProperties$3(_ref, ["border", "visualCellRange"]); + + var s = new VisualSelection(_objectSpread$3(_objectSpread$3({}, border), restOptions), visualCellRange); + return s; +} + +var nativeAssign = Object.assign; +var defineProperty$6 = Object.defineProperty; + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +var objectAssign = !nativeAssign || fails(function () { + // should have correct order of operations (Edge bug) + if (descriptors && nativeAssign({ b: 1 }, nativeAssign(defineProperty$6({}, 'a', { + enumerable: true, + get: function () { + defineProperty$6(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + /* global Symbol -- required for testing */ + var symbol = Symbol(); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = objectGetOwnPropertySymbols.f; + var propertyIsEnumerable = objectPropertyIsEnumerable.f; + while (argumentsLength > index) { + var S = indexedObject(arguments[index++]); + var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!descriptors || propertyIsEnumerable.call(S, key)) T[key] = S[key]; + } + } return T; +} : nativeAssign; + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +_export({ target: 'Object', stat: true, forced: Object.assign !== objectAssign }, { + assign: objectAssign +}); + +function ownKeys$5(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$4(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$5(Object(source), true).forEach(function (key) { _defineProperty$9(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$5(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$9(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +/** + * Creates the new instance of Selection, responsible for highlighting cells which are covered by fill handle + * functionality. This type of selection can present on the table only one at the time. + * + * @returns {Selection} + */ + +function createHighlight$4(_ref) { + var restOptions = Object.assign({}, _ref); + var s = new VisualSelection(_objectSpread$4({ + className: 'fill', + border: { + width: 1, + color: '#ff0000' + } + }, restOptions)); + return s; +} + +function ownKeys$6(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$5(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$6(Object(source), true).forEach(function (key) { _defineProperty$a(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$6(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$a(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _objectWithoutProperties$4(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$4(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose$4(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } +/** + * Creates the new instance of Selection, responsible for highlighting row and column headers. This type of selection + * can occur multiple times. + * + * @returns {Selection} + */ + +function createHighlight$5(_ref) { + var headerClassName = _ref.headerClassName, + rowClassName = _ref.rowClassName, + columnClassName = _ref.columnClassName, + restOptions = _objectWithoutProperties$4(_ref, ["headerClassName", "rowClassName", "columnClassName"]); + + var s = new VisualSelection(_objectSpread$5({ + className: 'highlight', + highlightHeaderClassName: headerClassName, + highlightRowClassName: rowClassName, + highlightColumnClassName: columnClassName + }, restOptions)); + return s; +} + +function ownKeys$7(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$6(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$7(Object(source), true).forEach(function (key) { _defineProperty$b(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$7(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$b(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var _staticRegister$6 = staticRegister('highlight/types'), + register$5 = _staticRegister$6.register, + getItem$4 = _staticRegister$6.getItem; + +register$5('active-header', createHighlight); +register$5('area', createHighlight$1); +register$5('cell', createHighlight$2); +register$5('custom-selection', createHighlight$3); +register$5('fill', createHighlight$4); +register$5('header', createHighlight$5); +/** + * @param {string} highlightType The selection type. + * @param {object} options The selection options. + * @returns {Selection} + */ + +function createHighlight$6(highlightType, options) { + return getItem$4(highlightType)(_objectSpread$6({ + type: highlightType + }, options)); +} + +function _toConsumableArray$f(arr) { return _arrayWithoutHoles$d(arr) || _iterableToArray$d(arr) || _unsupportedIterableToArray$i(arr) || _nonIterableSpread$d(); } + +function _nonIterableSpread$d() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$i(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$i(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$i(o, minLen); } + +function _iterableToArray$d(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$d(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$i(arr); } + +function _arrayLikeToArray$i(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function ownKeys$8(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$7(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$8(Object(source), true).forEach(function (key) { _defineProperty$c(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$8(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$c(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck$W(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$R(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); } } + +function _createClass$R(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$R(Constructor.prototype, protoProps); if (staticProps) _defineProperties$R(Constructor, staticProps); return Constructor; } +var ACTIVE_HEADER_TYPE = 'active-header'; +var AREA_TYPE = 'area'; +var CELL_TYPE = 'cell'; +var FILL_TYPE = 'fill'; +var HEADER_TYPE = 'header'; +var CUSTOM_SELECTION = 'custom-selection'; +/** + * Highlight class responsible for managing Walkontable Selection classes. + * + * With Highlight object you can manipulate four different highlight types: + * - `cell` can be added only to a single cell at a time and it defines currently selected cell; + * - `fill` can occur only once and its highlight defines selection of autofill functionality (managed by the plugin with the same name); + * - `areas` can be added to multiple cells at a time. This type highlights selected cell or multiple cells. + * The multiple cells have to be defined as an uninterrupted order (regular shape). Otherwise, the new layer of + * that type should be created to manage not-consecutive selection; + * - `header` can occur multiple times. This type is designed to highlight only headers. Like `area` type it + * can appear with multiple highlights (accessed under different level layers). + * + * @class Highlight + * @util + */ + +var Highlight = /*#__PURE__*/function () { + function Highlight(options) { + _classCallCheck$W(this, Highlight); + + /** + * Options consumed by Highlight class and Walkontable Selection classes. + * + * @type {object} + */ + this.options = options; + /** + * The property which describes which layer level of the visual selection will be modified. + * This option is valid only for `area` and `header` highlight types which occurs multiple times on + * the table (as a non-consecutive selection). + * + * An order of the layers is the same as the order of added new non-consecutive selections. + * + * @type {number} + * @default 0 + */ + + this.layerLevel = 0; + /** + * `cell` highlight object which describes attributes for the currently selected cell. + * It can only occur only once on the table. + * + * @type {Selection} + */ + + this.cell = createHighlight$6(CELL_TYPE, options); + /** + * `fill` highlight object which describes attributes for the borders for autofill functionality. + * It can only occur only once on the table. + * + * @type {Selection} + */ + + this.fill = createHighlight$6(FILL_TYPE, options); + /** + * Collection of the `area` highlights. That objects describes attributes for the borders and selection of + * the multiple selected cells. It can occur multiple times on the table. + * + * @type {Map.} + */ + + this.areas = new Map(); + /** + * Collection of the `header` highlights. That objects describes attributes for the selection of + * the multiple selected rows and columns in the table header. It can occur multiple times on the table. + * + * @type {Map.} + */ + + this.headers = new Map(); + /** + * Collection of the `active-header` highlights. That objects describes attributes for the selection of + * the multiple selected rows and columns in the table header. The table headers which have selected all items in + * a row will be marked as `active-header`. + * + * @type {Map.} + */ + + this.activeHeaders = new Map(); + /** + * Collection of the `custom-selection`, holder for example borders added through CustomBorders plugin. + * + * @type {Selection[]} + */ + + this.customSelections = []; + } + /** + * Check if highlight cell rendering is disabled for specified highlight type. + * + * @param {string} highlightType Highlight type. Possible values are: `cell`, `area`, `fill` or `header`. + * @returns {boolean} + */ + + + _createClass$R(Highlight, [{ + key: "isEnabledFor", + value: function isEnabledFor(highlightType) { + // Legacy compatibility. + var type = highlightType === 'current' ? CELL_TYPE : highlightType; + var disableHighlight = this.options.disableHighlight; + + if (typeof disableHighlight === 'string') { + disableHighlight = [disableHighlight]; + } + + return disableHighlight === false || Array.isArray(disableHighlight) && !disableHighlight.includes(type); + } + /** + * Set a new layer level to make access to the desire `area` and `header` highlights. + * + * @param {number} [level=0] Layer level to use. + * @returns {Highlight} + */ + + }, { + key: "useLayerLevel", + value: function useLayerLevel() { + var level = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; + this.layerLevel = level; + return this; + } + /** + * Get Walkontable Selection instance created for controlling highlight of the currently selected/edited cell. + * + * @returns {Selection} + */ + + }, { + key: "getCell", + value: function getCell() { + return this.cell; + } + /** + * Get Walkontable Selection instance created for controlling highlight of the autofill functionality. + * + * @returns {Selection} + */ + + }, { + key: "getFill", + value: function getFill() { + return this.fill; + } + /** + * Get or create (if not exist in the cache) Walkontable Selection instance created for controlling highlight + * of the multiple selected cells. + * + * @returns {Selection} + */ + + }, { + key: "createOrGetArea", + value: function createOrGetArea() { + var layerLevel = this.layerLevel; + var area; + + if (this.areas.has(layerLevel)) { + area = this.areas.get(layerLevel); + } else { + area = createHighlight$6(AREA_TYPE, _objectSpread$7({ + layerLevel: layerLevel + }, this.options)); + this.areas.set(layerLevel, area); + } + + return area; + } + /** + * Get all Walkontable Selection instances which describes the state of the visual highlight of the cells. + * + * @returns {Selection[]} + */ + + }, { + key: "getAreas", + value: function getAreas() { + return _toConsumableArray$f(this.areas.values()); + } + /** + * Get or create (if not exist in the cache) Walkontable Selection instance created for controlling highlight + * of the multiple selected header cells. + * + * @returns {Selection} + */ + + }, { + key: "createOrGetHeader", + value: function createOrGetHeader() { + var layerLevel = this.layerLevel; + var header; + + if (this.headers.has(layerLevel)) { + header = this.headers.get(layerLevel); + } else { + header = createHighlight$6(HEADER_TYPE, _objectSpread$7({}, this.options)); + this.headers.set(layerLevel, header); + } + + return header; + } + /** + * Get all Walkontable Selection instances which describes the state of the visual highlight of the headers. + * + * @returns {Selection[]} + */ + + }, { + key: "getHeaders", + value: function getHeaders() { + return _toConsumableArray$f(this.headers.values()); + } + /** + * Get or create (if not exist in the cache) Walkontable Selection instance created for controlling highlight + * of the multiple selected active header cells. + * + * @returns {Selection} + */ + + }, { + key: "createOrGetActiveHeader", + value: function createOrGetActiveHeader() { + var layerLevel = this.layerLevel; + var header; + + if (this.activeHeaders.has(layerLevel)) { + header = this.activeHeaders.get(layerLevel); + } else { + header = createHighlight$6(ACTIVE_HEADER_TYPE, _objectSpread$7({}, this.options)); + this.activeHeaders.set(layerLevel, header); + } + + return header; + } + /** + * Get all Walkontable Selection instances which describes the state of the visual highlight of the active headers. + * + * @returns {Selection[]} + */ + + }, { + key: "getActiveHeaders", + value: function getActiveHeaders() { + return _toConsumableArray$f(this.activeHeaders.values()); + } + /** + * Get Walkontable Selection instance created for controlling highlight of the custom selection functionality. + * + * @returns {Selection} + */ + + }, { + key: "getCustomSelections", + value: function getCustomSelections() { + return _toConsumableArray$f(this.customSelections.values()); + } + /** + * Add selection to the custom selection instance. The new selection are added to the end of the selection collection. + * + * @param {object} selectionInstance The selection instance. + */ + + }, { + key: "addCustomSelection", + value: function addCustomSelection(selectionInstance) { + this.customSelections.push(createHighlight$6(CUSTOM_SELECTION, _objectSpread$7(_objectSpread$7({}, this.options), selectionInstance))); + } + /** + * Perform cleaning visual highlights for the whole table. + */ + + }, { + key: "clear", + value: function clear() { + this.cell.clear(); + this.fill.clear(); + arrayEach(this.areas.values(), function (highlight) { + return void highlight.clear(); + }); + arrayEach(this.headers.values(), function (highlight) { + return void highlight.clear(); + }); + arrayEach(this.activeHeaders.values(), function (highlight) { + return void highlight.clear(); + }); + } + /** + * This object can be iterate over using `for of` syntax or using internal `arrayEach` helper. + * + * @returns {Selection[]} + */ + + }, { + key: Symbol.iterator, + value: function value() { + return [this.cell, this.fill].concat(_toConsumableArray$f(this.areas.values()), _toConsumableArray$f(this.headers.values()), _toConsumableArray$f(this.activeHeaders.values()), _toConsumableArray$f(this.customSelections))[Symbol.iterator](); + } + }]); + + return Highlight; +}(); + +function _classCallCheck$X(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$S(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); } } + +function _createClass$S(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$S(Constructor.prototype, protoProps); if (staticProps) _defineProperties$S(Constructor, staticProps); return Constructor; } +/** + * The SelectionRange class is a simple CellRanges collection designed for easy manipulation of the multiple + * consecutive and non-consecutive selections. + * + * @class SelectionRange + * @util + */ + +var SelectionRange = /*#__PURE__*/function () { + function SelectionRange() { + _classCallCheck$X(this, SelectionRange); + + /** + * List of all CellRanges added to the class instance. + * + * @type {CellRange[]} + */ + this.ranges = []; + } + /** + * Check if selected range is empty. + * + * @returns {boolean} + */ + + + _createClass$S(SelectionRange, [{ + key: "isEmpty", + value: function isEmpty() { + return this.size() === 0; + } + /** + * Set coordinates to the class instance. It clears all previously added coordinates and push `coords` + * to the collection. + * + * @param {CellCoords} coords The CellCoords instance with defined visual coordinates. + * @returns {SelectionRange} + */ + + }, { + key: "set", + value: function set(coords) { + this.clear(); + this.ranges.push(new CellRange(coords)); + return this; + } + /** + * Add coordinates to the class instance. The new coordinates are added to the end of the range collection. + * + * @param {CellCoords} coords The CellCoords instance with defined visual coordinates. + * @returns {SelectionRange} + */ + + }, { + key: "add", + value: function add(coords) { + this.ranges.push(new CellRange(coords)); + return this; + } + /** + * Removes from the stack the last added coordinates. + * + * @returns {SelectionRange} + */ + + }, { + key: "pop", + value: function pop() { + this.ranges.pop(); + return this; + } + /** + * Get last added coordinates from ranges, it returns a CellRange instance. + * + * @returns {CellRange|undefined} + */ + + }, { + key: "current", + value: function current() { + return this.peekByIndex(0); + } + /** + * Get previously added coordinates from ranges, it returns a CellRange instance. + * + * @returns {CellRange|undefined} + */ + + }, { + key: "previous", + value: function previous() { + return this.peekByIndex(-1); + } + /** + * Returns `true` if coords is within selection coords. This method iterates through all selection layers to check if + * the coords object is within selection range. + * + * @param {CellCoords} coords The CellCoords instance with defined visual coordinates. + * @returns {boolean} + */ + + }, { + key: "includes", + value: function includes(coords) { + return this.ranges.some(function (cellRange) { + return cellRange.includes(coords); + }); + } + /** + * Clear collection. + * + * @returns {SelectionRange} + */ + + }, { + key: "clear", + value: function clear() { + this.ranges.length = 0; + return this; + } + /** + * Get count of added all coordinates added to the selection. + * + * @returns {number} + */ + + }, { + key: "size", + value: function size() { + return this.ranges.length; + } + /** + * Peek the coordinates based on the offset where that coordinate resides in the collection. + * + * @param {number} [offset=0] An offset where the coordinate will be retrieved from. + * @returns {CellRange|undefined} + */ + + }, { + key: "peekByIndex", + value: function peekByIndex() { + var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; + var rangeIndex = this.size() + offset - 1; + var cellRange; + + if (rangeIndex >= 0) { + cellRange = this.ranges[rangeIndex]; + } + + return cellRange; + } + }, { + key: Symbol.iterator, + value: function value() { + return this.ranges[Symbol.iterator](); + } + }]); + + return SelectionRange; +}(); + +function _classCallCheck$Y(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$T(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); } } + +function _createClass$T(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$T(Constructor.prototype, protoProps); if (staticProps) _defineProperties$T(Constructor, staticProps); return Constructor; } +/** + * The Transformation class implements algorithms for transforming coordinates based on current settings + * passed to the Handsontable. + * + * Transformation is always applied relative to the current selection. + * + * @class Transformation + * @util + */ + +var Transformation = /*#__PURE__*/function () { + function Transformation(range, options) { + _classCallCheck$Y(this, Transformation); + + /** + * Instance of the SelectionRange, holder for visual coordinates applied to the table. + * + * @type {SelectionRange} + */ + this.range = range; + /** + * Additional options which define the state of the settings which can infer transformation and + * give the possibility to translate indexes. + * + * @type {object} + */ + + this.options = options; + } + /** + * Selects cell relative to current cell (if possible). + * + * @param {number} rowDelta Rows number to move, value can be passed as negative number. + * @param {number} colDelta Columns number to move, value can be passed as negative number. + * @param {boolean} force If `true` the new rows/columns will be created if necessary. Otherwise, row/column will + * be created according to `minSpareRows/minSpareCols` settings of Handsontable. + * @returns {CellCoords} Visual coordinates after transformation. + */ + + + _createClass$T(Transformation, [{ + key: "transformStart", + value: function transformStart(rowDelta, colDelta, force) { + var delta = new CellCoords(rowDelta, colDelta); + var highlightCoords = this.range.current().highlight; + + var _this$options$visualT = this.options.visualToRenderableCoords(highlightCoords), + renderableRow = _this$options$visualT.row, + renderableColumn = _this$options$visualT.col; + + var visualCoords = highlightCoords; + var rowTransformDir = 0; + var colTransformDir = 0; + this.runLocalHooks('beforeTransformStart', delta); + + if (renderableRow !== null && renderableColumn !== null) { + var totalRows = this.options.countRows(); + var totalCols = this.options.countCols(); + var fixedRowsBottom = this.options.fixedRowsBottom(); + var minSpareRows = this.options.minSpareRows(); + var minSpareCols = this.options.minSpareCols(); + var autoWrapRow = this.options.autoWrapRow(); + var autoWrapCol = this.options.autoWrapCol(); + + if (renderableRow + rowDelta > totalRows - 1) { + if (force && minSpareRows > 0 && !(fixedRowsBottom && renderableRow >= totalRows - fixedRowsBottom - 1)) { + this.runLocalHooks('insertRowRequire', totalRows); + totalRows = this.options.countRows(); + } else if (autoWrapCol) { + delta.row = 1 - totalRows; + delta.col = renderableColumn + delta.col === totalCols - 1 ? 1 - totalCols : 1; + } + } else if (autoWrapCol && renderableRow + delta.row < 0 && renderableColumn + delta.col >= 0) { + delta.row = totalRows - 1; + delta.col = renderableColumn + delta.col === 0 ? totalCols - 1 : -1; + } + + if (renderableColumn + delta.col > totalCols - 1) { + if (force && minSpareCols > 0) { + this.runLocalHooks('insertColRequire', totalCols); + totalCols = this.options.countCols(); + } else if (autoWrapRow) { + delta.row = renderableRow + delta.row === totalRows - 1 ? 1 - totalRows : 1; + delta.col = 1 - totalCols; + } + } else if (autoWrapRow && renderableColumn + delta.col < 0 && renderableRow + delta.row >= 0) { + delta.row = renderableRow + delta.row === 0 ? totalRows - 1 : -1; + delta.col = totalCols - 1; + } + + var coords = new CellCoords(renderableRow + delta.row, renderableColumn + delta.col); + rowTransformDir = 0; + colTransformDir = 0; + + if (coords.row < 0) { + rowTransformDir = -1; + coords.row = 0; + } else if (coords.row > 0 && coords.row >= totalRows) { + rowTransformDir = 1; + coords.row = totalRows - 1; + } + + if (coords.col < 0) { + colTransformDir = -1; + coords.col = 0; + } else if (coords.col > 0 && coords.col >= totalCols) { + colTransformDir = 1; + coords.col = totalCols - 1; + } + + visualCoords = this.options.renderableToVisualCoords(coords); + } + + this.runLocalHooks('afterTransformStart', visualCoords, rowTransformDir, colTransformDir); + return visualCoords; + } + /** + * Sets selection end cell relative to current selection end cell (if possible). + * + * @param {number} rowDelta Rows number to move, value can be passed as negative number. + * @param {number} colDelta Columns number to move, value can be passed as negative number. + * @returns {CellCoords} Visual coordinates after transformation. + */ + + }, { + key: "transformEnd", + value: function transformEnd(rowDelta, colDelta) { + var delta = new CellCoords(rowDelta, colDelta); + var cellRange = this.range.current(); + var visualCoords = cellRange.to; + var rowTransformDir = 0; + var colTransformDir = 0; + this.runLocalHooks('beforeTransformEnd', delta); + + var _this$options$visualT2 = this.options.visualToRenderableCoords(cellRange.highlight), + rowHighlight = _this$options$visualT2.row, + colHighlight = _this$options$visualT2.col; // We have highlight (start point for the selection). + + + if (rowHighlight !== null && colHighlight !== null) { + var totalRows = this.options.countRows(); + var totalCols = this.options.countCols(); + + var _this$options$visualT3 = this.options.visualToRenderableCoords(cellRange.to), + rowTo = _this$options$visualT3.row, + colTo = _this$options$visualT3.col; + + var coords = new CellCoords(rowTo + delta.row, colTo + delta.col); + rowTransformDir = 0; + colTransformDir = 0; + + if (coords.row < 0) { + rowTransformDir = -1; + coords.row = 0; + } else if (coords.row > 0 && coords.row >= totalRows) { + rowTransformDir = 1; + coords.row = totalRows - 1; + } + + if (coords.col < 0) { + colTransformDir = -1; + coords.col = 0; + } else if (coords.col > 0 && coords.col >= totalCols) { + colTransformDir = 1; + coords.col = totalCols - 1; + } + + visualCoords = this.options.renderableToVisualCoords(coords); + } + + this.runLocalHooks('afterTransformEnd', visualCoords, rowTransformDir, colTransformDir); + return visualCoords; + } + }]); + + return Transformation; +}(); + +mixin(Transformation, localHooks); + +function _slicedToArray$a(arr, i) { return _arrayWithHoles$a(arr) || _iterableToArrayLimit$a(arr, i) || _unsupportedIterableToArray$j(arr, i) || _nonIterableRest$a(); } + +function _nonIterableRest$a() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$j(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$j(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$j(o, minLen); } + +function _arrayLikeToArray$j(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$a(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$a(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof$w(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$w = function _typeof(obj) { return typeof obj; }; } else { _typeof$w = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$w(obj); } +var SELECTION_TYPE_UNRECOGNIZED = 0; +var SELECTION_TYPE_EMPTY = 1; +var SELECTION_TYPE_ARRAY = 2; +var SELECTION_TYPE_OBJECT = 3; +var SELECTION_TYPES = [SELECTION_TYPE_OBJECT, SELECTION_TYPE_ARRAY]; +var ARRAY_TYPE_PATTERN = [['number'], ['number', 'string'], ['number', 'undefined'], ['number', 'string', 'undefined']]; +var rootCall = Symbol('root'); +var childCall = Symbol('child'); +/** + * Detect selection schema structure. + * + * @param {*} selectionRanges The selected range or and array of selected ranges. This type of data is produced by + * `hot.getSelected()`, `hot.getSelectedLast()`, `hot.getSelectedRange()` + * and `hot.getSelectedRangeLast()` methods. + * @param {symbol} _callSymbol The symbol object which indicates source of the helper invocation. + * @returns {number} Returns a number that specifies the type of detected selection schema. If selection schema type + * is unrecognized than it returns `0`. + */ + +function detectSelectionType(selectionRanges) { + var _callSymbol = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : rootCall; + + if (_callSymbol !== rootCall && _callSymbol !== childCall) { + throw new Error('The second argument is used internally only and cannot be overwritten.'); + } + + var isArray = Array.isArray(selectionRanges); + var isRootCall = _callSymbol === rootCall; + var result = SELECTION_TYPE_UNRECOGNIZED; + + if (isArray) { + var firstItem = selectionRanges[0]; + + if (selectionRanges.length === 0) { + result = SELECTION_TYPE_EMPTY; + } else if (isRootCall && firstItem instanceof CellRange) { + result = SELECTION_TYPE_OBJECT; + } else if (isRootCall && Array.isArray(firstItem)) { + result = detectSelectionType(firstItem, childCall); + } else if (selectionRanges.length >= 2 && selectionRanges.length <= 4) { + var isArrayType = !selectionRanges.some(function (value, index) { + return !ARRAY_TYPE_PATTERN[index].includes(_typeof$w(value)); + }); + + if (isArrayType) { + result = SELECTION_TYPE_ARRAY; + } + } + } + + return result; +} +/** + * Factory function designed for normalization data schema from different data structures of the selection ranges. + * + * @param {string} type Selection type which will be processed. + * @param {object} [options] The normalization options. + * @param {boolean} [options.keepDirection=false] If `true`, the coordinates which contain the direction of the + * selected cells won't be changed. Otherwise, the selection will be + * normalized to values starting from top-left to bottom-right. + * @param {Function} [options.propToCol] Pass the converting function (usually `datamap.propToCol`) if the column + * defined as props should be normalized to the numeric values. + * @returns {number[]} Returns normalized data about selected range as an array (`[rowStart, columnStart, rowEnd, columnEnd]`). + */ + +function normalizeSelectionFactory(type) { + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + _ref$keepDirection = _ref.keepDirection, + keepDirection = _ref$keepDirection === void 0 ? false : _ref$keepDirection, + propToCol = _ref.propToCol; + + if (!SELECTION_TYPES.includes(type)) { + throw new Error('Unsupported selection ranges schema type was provided.'); + } + + return function (selection) { + var isObjectType = type === SELECTION_TYPE_OBJECT; + var rowStart = isObjectType ? selection.from.row : selection[0]; + var columnStart = isObjectType ? selection.from.col : selection[1]; + var rowEnd = isObjectType ? selection.to.row : selection[2]; + var columnEnd = isObjectType ? selection.to.col : selection[3]; + + if (typeof propToCol === 'function') { + if (typeof columnStart === 'string') { + columnStart = propToCol(columnStart); + } + + if (typeof columnEnd === 'string') { + columnEnd = propToCol(columnEnd); + } + } + + if (isUndefined(rowEnd)) { + rowEnd = rowStart; + } + + if (isUndefined(columnEnd)) { + columnEnd = columnStart; + } + + if (!keepDirection) { + var origRowStart = rowStart; + var origColumnStart = columnStart; + var origRowEnd = rowEnd; + var origColumnEnd = columnEnd; + rowStart = Math.min(origRowStart, origRowEnd); + columnStart = Math.min(origColumnStart, origColumnEnd); + rowEnd = Math.max(origRowStart, origRowEnd); + columnEnd = Math.max(origColumnStart, origColumnEnd); + } + + return [rowStart, columnStart, rowEnd, columnEnd]; + }; +} +/** + * Function transform selection ranges (produced by `hot.getSelected()` and `hot.getSelectedRange()`) to normalized + * data structure. It merges repeated ranges into consecutive coordinates. The returned structure + * contains an array of arrays. The single item contains at index 0 visual column index from the selection was + * started and at index 1 distance as a count of selected columns. + * + * @param {Array[]|CellRange[]} selectionRanges Selection ranges produced by Handsontable. + * @returns {Array[]} Returns an array of arrays with ranges defines in that schema: + * `[[visualColumnStart, distance], [visualColumnStart, distance], ...]`. + * The column distances are always created starting from the left (zero index) to the + * right (the latest column index). + */ + +function transformSelectionToColumnDistance(selectionRanges) { + var selectionType = detectSelectionType(selectionRanges); + + if (selectionType === SELECTION_TYPE_UNRECOGNIZED || selectionType === SELECTION_TYPE_EMPTY) { + return []; + } + + var selectionSchemaNormalizer = normalizeSelectionFactory(selectionType); + var unorderedIndexes = new Set(); // Iterate through all ranges and collect all column indexes which are not saved yet. + + arrayEach(selectionRanges, function (selection) { + var _selectionSchemaNorma = selectionSchemaNormalizer(selection), + _selectionSchemaNorma2 = _slicedToArray$a(_selectionSchemaNorma, 4), + columnStart = _selectionSchemaNorma2[1], + columnEnd = _selectionSchemaNorma2[3]; + + var columnNonHeaderStart = Math.max(columnStart, 0); + var amount = columnEnd - columnNonHeaderStart + 1; + arrayEach(Array.from(new Array(amount), function (_, i) { + return columnNonHeaderStart + i; + }), function (index) { + if (!unorderedIndexes.has(index)) { + unorderedIndexes.add(index); + } + }); + }); // Sort indexes in ascending order to easily detecting non-consecutive columns. + + var orderedIndexes = Array.from(unorderedIndexes).sort(function (a, b) { + return a - b; + }); + var normalizedColumnRanges = arrayReduce(orderedIndexes, function (acc, visualColumnIndex, index, array) { + if (index !== 0 && visualColumnIndex === array[index - 1] + 1) { + acc[acc.length - 1][1] += 1; + } else { + acc.push([visualColumnIndex, 1]); + } + + return acc; + }, []); + return normalizedColumnRanges; +} +/** + * Function transform selection ranges (produced by `hot.getSelected()` and `hot.getSelectedRange()`) to normalized + * data structure. It merges repeated ranges into consecutive coordinates. The returned structure + * contains an array of arrays. The single item contains at index 0 visual column index from the selection was + * started and at index 1 distance as a count of selected columns. + * + * @param {Array[]|CellRange[]} selectionRanges Selection ranges produced by Handsontable. + * @returns {Array[]} Returns an array of arrays with ranges defines in that schema: + * `[[visualColumnStart, distance], [visualColumnStart, distance], ...]`. + * The column distances are always created starting from the left (zero index) to the + * right (the latest column index). + */ + +function transformSelectionToRowDistance(selectionRanges) { + var selectionType = detectSelectionType(selectionRanges); + + if (selectionType === SELECTION_TYPE_UNRECOGNIZED || selectionType === SELECTION_TYPE_EMPTY) { + return []; + } + + var selectionSchemaNormalizer = normalizeSelectionFactory(selectionType); + var unorderedIndexes = new Set(); // Iterate through all ranges and collect all column indexes which are not saved yet. + + arrayEach(selectionRanges, function (selection) { + var _selectionSchemaNorma3 = selectionSchemaNormalizer(selection), + _selectionSchemaNorma4 = _slicedToArray$a(_selectionSchemaNorma3, 3), + rowStart = _selectionSchemaNorma4[0], + rowEnd = _selectionSchemaNorma4[2]; + + var rowNonHeaderStart = Math.max(rowStart, 0); + var amount = rowEnd - rowNonHeaderStart + 1; + arrayEach(Array.from(new Array(amount), function (_, i) { + return rowNonHeaderStart + i; + }), function (index) { + if (!unorderedIndexes.has(index)) { + unorderedIndexes.add(index); + } + }); + }); // Sort indexes in ascending order to easily detecting non-consecutive columns. + + var orderedIndexes = Array.from(unorderedIndexes).sort(function (a, b) { + return a - b; + }); + var normalizedRowRanges = arrayReduce(orderedIndexes, function (acc, rowIndex, index, array) { + if (index !== 0 && rowIndex === array[index - 1] + 1) { + acc[acc.length - 1][1] += 1; + } else { + acc.push([rowIndex, 1]); + } + + return acc; + }, []); + return normalizedRowRanges; +} +/** + * Check if passed value can be treated as valid cell coordinate. The second argument is + * used to check if the value doesn't exceed the defined max table rows/columns count. + * + * @param {number} coord The coordinate to validate (row index or column index). + * @param {number} maxTableItemsCount The value that declares the maximum coordinate that is still validatable. + * @returns {boolean} + */ + +function isValidCoord(coord) { + var maxTableItemsCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Infinity; + return typeof coord === 'number' && coord >= 0 && coord < maxTableItemsCount; +} + +var _templateObject$4; + +function _slicedToArray$b(arr, i) { return _arrayWithHoles$b(arr) || _iterableToArrayLimit$b(arr, i) || _unsupportedIterableToArray$k(arr, i) || _nonIterableRest$b(); } + +function _nonIterableRest$b() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$k(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$k(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$k(o, minLen); } + +function _arrayLikeToArray$k(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$b(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$b(arr) { if (Array.isArray(arr)) return arr; } + +function _taggedTemplateLiteral$4(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _classCallCheck$Z(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$U(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); } } + +function _createClass$U(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$U(Constructor.prototype, protoProps); if (staticProps) _defineProperties$U(Constructor, staticProps); return Constructor; } +/** + * @class Selection + * @util + */ + +var Selection$1 = /*#__PURE__*/function () { + function Selection(settings, tableProps) { + var _this = this; + + _classCallCheck$Z(this, Selection); + + /** + * Handsontable settings instance. + * + * @type {GridSettings} + */ + this.settings = settings; + /** + * An additional object with dynamically defined properties which describes table state. + * + * @type {object} + */ + + this.tableProps = tableProps; + /** + * The flag which determines if the selection is in progress. + * + * @type {boolean} + */ + + this.inProgress = false; + /** + * The flag indicates that selection was performed by clicking the corner overlay. + * + * @type {boolean} + */ + + this.selectedByCorner = false; + /** + * The collection of the selection layer levels where the whole row was selected using the row header or + * the corner header. + * + * @type {Set.} + */ + + this.selectedByRowHeader = new Set(); + /** + * The collection of the selection layer levels where the whole column was selected using the column header or + * the corner header. + * + * @type {Set.} + */ + + this.selectedByColumnHeader = new Set(); + /** + * Selection data layer (handle visual coordinates). + * + * @type {SelectionRange} + */ + + this.selectedRange = new SelectionRange(); + /** + * Visualization layer. + * + * @type {Highlight} + */ + + this.highlight = new Highlight({ + headerClassName: settings.currentHeaderClassName, + activeHeaderClassName: settings.activeHeaderClassName, + rowClassName: settings.currentRowClassName, + columnClassName: settings.currentColClassName, + disableHighlight: this.settings.disableVisualSelection, + cellCornerVisible: function cellCornerVisible() { + return _this.isCellCornerVisible.apply(_this, arguments); + }, + areaCornerVisible: function areaCornerVisible() { + return _this.isAreaCornerVisible.apply(_this, arguments); + }, + visualToRenderableCoords: function visualToRenderableCoords(coords) { + return _this.tableProps.visualToRenderableCoords(coords); + }, + renderableToVisualCoords: function renderableToVisualCoords(coords) { + return _this.tableProps.renderableToVisualCoords(coords); + } + }); + /** + * The module for modifying coordinates. + * + * @type {Transformation} + */ + + this.transformation = new Transformation(this.selectedRange, { + countRows: function countRows() { + return _this.tableProps.countRowsTranslated(); + }, + countCols: function countCols() { + return _this.tableProps.countColsTranslated(); + }, + visualToRenderableCoords: function visualToRenderableCoords(coords) { + return _this.tableProps.visualToRenderableCoords(coords); + }, + renderableToVisualCoords: function renderableToVisualCoords(coords) { + return _this.tableProps.renderableToVisualCoords(coords); + }, + fixedRowsBottom: function fixedRowsBottom() { + return settings.fixedRowsBottom; + }, + minSpareRows: function minSpareRows() { + return settings.minSpareRows; + }, + minSpareCols: function minSpareCols() { + return settings.minSpareCols; + }, + autoWrapRow: function autoWrapRow() { + return settings.autoWrapRow; + }, + autoWrapCol: function autoWrapCol() { + return settings.autoWrapCol; + } + }); + this.transformation.addLocalHook('beforeTransformStart', function () { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return _this.runLocalHooks.apply(_this, ['beforeModifyTransformStart'].concat(args)); + }); + this.transformation.addLocalHook('afterTransformStart', function () { + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + return _this.runLocalHooks.apply(_this, ['afterModifyTransformStart'].concat(args)); + }); + this.transformation.addLocalHook('beforeTransformEnd', function () { + for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments[_key3]; + } + + return _this.runLocalHooks.apply(_this, ['beforeModifyTransformEnd'].concat(args)); + }); + this.transformation.addLocalHook('afterTransformEnd', function () { + for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { + args[_key4] = arguments[_key4]; + } + + return _this.runLocalHooks.apply(_this, ['afterModifyTransformEnd'].concat(args)); + }); + this.transformation.addLocalHook('insertRowRequire', function () { + for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { + args[_key5] = arguments[_key5]; + } + + return _this.runLocalHooks.apply(_this, ['insertRowRequire'].concat(args)); + }); + this.transformation.addLocalHook('insertColRequire', function () { + for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) { + args[_key6] = arguments[_key6]; + } + + return _this.runLocalHooks.apply(_this, ['insertColRequire'].concat(args)); + }); + } + /** + * Get data layer for current selection. + * + * @returns {SelectionRange} + */ + + + _createClass$U(Selection, [{ + key: "getSelectedRange", + value: function getSelectedRange() { + return this.selectedRange; + } + /** + * Indicate that selection process began. It sets internaly `.inProgress` property to `true`. + */ + + }, { + key: "begin", + value: function begin() { + this.inProgress = true; + } + /** + * Indicate that selection process finished. It sets internaly `.inProgress` property to `false`. + */ + + }, { + key: "finish", + value: function finish() { + this.runLocalHooks('afterSelectionFinished', Array.from(this.selectedRange)); + this.inProgress = false; + } + /** + * Check if the process of selecting the cell/cells is in progress. + * + * @returns {boolean} + */ + + }, { + key: "isInProgress", + value: function isInProgress() { + return this.inProgress; + } + /** + * Starts selection range on given coordinate object. + * + * @param {CellCoords} coords Visual coords. + * @param {boolean} [multipleSelection] If `true`, selection will be worked in 'multiple' mode. This option works + * only when 'selectionMode' is set as 'multiple'. If the argument is not defined + * the default trigger will be used (isPressedCtrlKey() helper). + * @param {boolean} [fragment=false] If `true`, the selection will be treated as a partial selection where the + * `setRangeEnd` method won't be called on every `setRangeStart` call. + */ + + }, { + key: "setRangeStart", + value: function setRangeStart(coords, multipleSelection) { + var fragment = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var isMultipleMode = this.settings.selectionMode === 'multiple'; + var isMultipleSelection = isUndefined(multipleSelection) ? isPressedCtrlKey() : multipleSelection; + var isRowNegative = coords.row < 0; + var isColumnNegative = coords.col < 0; + var selectedByCorner = isRowNegative && isColumnNegative; + this.selectedByCorner = selectedByCorner; + this.runLocalHooks("beforeSetRangeStart".concat(fragment ? 'Only' : ''), coords); + + if (!isMultipleMode || isMultipleMode && !isMultipleSelection && isUndefined(multipleSelection)) { + this.selectedRange.clear(); + } + + this.selectedRange.add(coords); + + if (this.getLayerLevel() === 0) { + this.selectedByRowHeader.clear(); + this.selectedByColumnHeader.clear(); + } + + if (!selectedByCorner && isColumnNegative) { + this.selectedByRowHeader.add(this.getLayerLevel()); + } + + if (!selectedByCorner && isRowNegative) { + this.selectedByColumnHeader.add(this.getLayerLevel()); + } + + if (!fragment) { + this.setRangeEnd(coords); + } + } + /** + * Starts selection range on given coordinate object. + * + * @param {CellCoords} coords Visual coords. + * @param {boolean} [multipleSelection] If `true`, selection will be worked in 'multiple' mode. This option works + * only when 'selectionMode' is set as 'multiple'. If the argument is not defined + * the default trigger will be used (isPressedCtrlKey() helper). + */ + + }, { + key: "setRangeStartOnly", + value: function setRangeStartOnly(coords, multipleSelection) { + this.setRangeStart(coords, multipleSelection, true); + } + /** + * Ends selection range on given coordinate object. + * + * @param {CellCoords} coords Visual coords. + */ + + }, { + key: "setRangeEnd", + value: function setRangeEnd(coords) { + if (this.selectedRange.isEmpty()) { + return; + } + + this.runLocalHooks('beforeSetRangeEnd', coords); + this.begin(); + var cellRange = this.selectedRange.current(); + + if (this.settings.selectionMode !== 'single') { + cellRange.setTo(new CellCoords(coords.row, coords.col)); + } // Set up current selection. + + + this.highlight.getCell().clear(); + + if (this.highlight.isEnabledFor(CELL_TYPE)) { + this.highlight.getCell().add(this.selectedRange.current().highlight).commit().adjustCoordinates(cellRange); + } + + var layerLevel = this.getLayerLevel(); // If the next layer level is lower than previous then clear all area and header highlights. This is the + // indication that the new selection is performing. + + if (layerLevel < this.highlight.layerLevel) { + arrayEach(this.highlight.getAreas(), function (highlight) { + return void highlight.clear(); + }); + arrayEach(this.highlight.getHeaders(), function (highlight) { + return void highlight.clear(); + }); + arrayEach(this.highlight.getActiveHeaders(), function (highlight) { + return void highlight.clear(); + }); + } + + this.highlight.useLayerLevel(layerLevel); + var areaHighlight = this.highlight.createOrGetArea(); + var headerHighlight = this.highlight.createOrGetHeader(); + var activeHeaderHighlight = this.highlight.createOrGetActiveHeader(); + areaHighlight.clear(); + headerHighlight.clear(); + activeHeaderHighlight.clear(); + + if (this.highlight.isEnabledFor(AREA_TYPE) && (this.isMultiple() || layerLevel >= 1)) { + areaHighlight.add(cellRange.from).add(cellRange.to).commit(); + + if (layerLevel === 1) { + // For single cell selection in the same layer, we do not create area selection to prevent blue background. + // When non-consecutive selection is performed we have to add that missing area selection to the previous layer + // based on previous coordinates. It only occurs when the previous selection wasn't select multiple cells. + var previousRange = this.selectedRange.previous(); + this.highlight.useLayerLevel(layerLevel - 1).createOrGetArea().add(previousRange.from).commit() // Range may start with hidden indexes. Commit would not found start point (as we add just the `from` coords). + .adjustCoordinates(previousRange); + this.highlight.useLayerLevel(layerLevel); + } + } + + if (this.highlight.isEnabledFor(HEADER_TYPE)) { + // The header selection generally contains cell selection. In a case when all rows (or columns) + // are hidden that visual coordinates are translated to renderable coordinates that do not exist. + // Hence no header highlight is generated. In that case, to make a column (or a row) header + // highlight, the row and column index has to point to the header (the negative value). See #7052. + var areAnyRowsRendered = this.tableProps.countRowsTranslated() === 0; + var areAnyColumnsRendered = this.tableProps.countColsTranslated() === 0; + var headerCellRange = cellRange; + + if (areAnyRowsRendered || areAnyColumnsRendered) { + headerCellRange = cellRange.clone(); + } + + if (areAnyRowsRendered) { + headerCellRange.from.row = -1; + } + + if (areAnyColumnsRendered) { + headerCellRange.from.col = -1; + } + + if (this.settings.selectionMode === 'single') { + if (this.isSelectedByAnyHeader()) { + headerCellRange.from.normalize(); + } + + headerHighlight.add(headerCellRange.from).commit(); + } else { + headerHighlight.add(headerCellRange.from).add(headerCellRange.to).commit(); + } + } + + if (this.isEntireRowSelected()) { + var isRowSelected = this.tableProps.countCols() === cellRange.getWidth(); // Make sure that the whole row is selected (in case where selectionMode is set to 'single') + + if (isRowSelected) { + activeHeaderHighlight.add(new CellCoords(cellRange.from.row, -1)).add(new CellCoords(cellRange.to.row, -1)).commit(); + } + } + + if (this.isEntireColumnSelected()) { + var isColumnSelected = this.tableProps.countRows() === cellRange.getHeight(); // Make sure that the whole column is selected (in case where selectionMode is set to 'single') + + if (isColumnSelected) { + activeHeaderHighlight.add(new CellCoords(-1, cellRange.from.col)).add(new CellCoords(-1, cellRange.to.col)).commit(); + } + } + + this.runLocalHooks('afterSetRangeEnd', coords); + } + /** + * Returns information if we have a multiselection. This method check multiselection only on the latest layer of + * the selection. + * + * @returns {boolean} + */ + + }, { + key: "isMultiple", + value: function isMultiple() { + var isMultipleListener = createObjectPropListener(!this.selectedRange.current().isSingle()); + this.runLocalHooks('afterIsMultipleSelection', isMultipleListener); + return isMultipleListener.value; + } + /** + * Selects cell relative to the current cell (if possible). + * + * @param {number} rowDelta Rows number to move, value can be passed as negative number. + * @param {number} colDelta Columns number to move, value can be passed as negative number. + * @param {boolean} force If `true` the new rows/columns will be created if necessary. Otherwise, row/column will + * be created according to `minSpareRows/minSpareCols` settings of Handsontable. + */ + + }, { + key: "transformStart", + value: function transformStart(rowDelta, colDelta, force) { + this.setRangeStart(this.transformation.transformStart(rowDelta, colDelta, force)); + } + /** + * Sets selection end cell relative to the current selection end cell (if possible). + * + * @param {number} rowDelta Rows number to move, value can be passed as negative number. + * @param {number} colDelta Columns number to move, value can be passed as negative number. + */ + + }, { + key: "transformEnd", + value: function transformEnd(rowDelta, colDelta) { + this.setRangeEnd(this.transformation.transformEnd(rowDelta, colDelta)); + } + /** + * Returns currently used layer level. + * + * @returns {number} Returns layer level starting from 0. If no selection was added to the table -1 is returned. + */ + + }, { + key: "getLayerLevel", + value: function getLayerLevel() { + return this.selectedRange.size() - 1; + } + /** + * Returns `true` if currently there is a selection on the screen, `false` otherwise. + * + * @returns {boolean} + */ + + }, { + key: "isSelected", + value: function isSelected() { + return !this.selectedRange.isEmpty(); + } + /** + * Returns `true` if the selection was applied by clicking to the row header. If the `layerLevel` + * argument is passed then only that layer will be checked. Otherwise, it checks if any row header + * was clicked on any selection layer level. + * + * @param {number} [layerLevel=this.getLayerLevel()] Selection layer level to check. + * @returns {boolean} + */ + + }, { + key: "isSelectedByRowHeader", + value: function isSelectedByRowHeader() { + var layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel(); + return !this.isSelectedByCorner(layerLevel) && this.isEntireRowSelected(layerLevel); + } + /** + * Returns `true` if the selection consists of entire rows (including their headers). If the `layerLevel` + * argument is passed then only that layer will be checked. Otherwise, it checks the selection for all layers. + * + * @param {number} [layerLevel=this.getLayerLevel()] Selection layer level to check. + * @returns {boolean} + */ + + }, { + key: "isEntireRowSelected", + value: function isEntireRowSelected() { + var layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel(); + return layerLevel === -1 ? this.selectedByRowHeader.size > 0 : this.selectedByRowHeader.has(layerLevel); + } + /** + * Returns `true` if the selection was applied by clicking to the column header. If the `layerLevel` + * argument is passed then only that layer will be checked. Otherwise, it checks if any column header + * was clicked on any selection layer level. + * + * @param {number} [layerLevel=this.getLayerLevel()] Selection layer level to check. + * @returns {boolean} + */ + + }, { + key: "isSelectedByColumnHeader", + value: function isSelectedByColumnHeader() { + var layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel(); + return !this.isSelectedByCorner() && this.isEntireColumnSelected(layerLevel); + } + /** + * Returns `true` if the selection consists of entire columns (including their headers). If the `layerLevel` + * argument is passed then only that layer will be checked. Otherwise, it checks the selection for all layers. + * + * @param {number} [layerLevel=this.getLayerLevel()] Selection layer level to check. + * @returns {boolean} + */ + + }, { + key: "isEntireColumnSelected", + value: function isEntireColumnSelected() { + var layerLevel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getLayerLevel(); + return layerLevel === -1 ? this.selectedByColumnHeader.size > 0 : this.selectedByColumnHeader.has(layerLevel); + } + /** + * Returns `true` if the selection was applied by clicking on the row or column header on any layer level. + * + * @returns {boolean} + */ + + }, { + key: "isSelectedByAnyHeader", + value: function isSelectedByAnyHeader() { + return this.isSelectedByRowHeader(-1) || this.isSelectedByColumnHeader(-1) || this.isSelectedByCorner(); + } + /** + * Returns `true` if the selection was applied by clicking on the left-top corner overlay. + * + * @returns {boolean} + */ + + }, { + key: "isSelectedByCorner", + value: function isSelectedByCorner() { + return this.selectedByCorner; + } + /** + * Returns `true` if coords is within selection coords. This method iterates through all selection layers to check if + * the coords object is within selection range. + * + * @param {CellCoords} coords The CellCoords instance with defined visual coordinates. + * @returns {boolean} + */ + + }, { + key: "inInSelection", + value: function inInSelection(coords) { + return this.selectedRange.includes(coords); + } + /** + * Returns `true` if the cell corner should be visible. + * + * @private + * @returns {boolean} `true` if the corner element has to be visible, `false` otherwise. + */ + + }, { + key: "isCellCornerVisible", + value: function isCellCornerVisible() { + return this.settings.fillHandle && !this.tableProps.isEditorOpened() && !this.isMultiple(); + } + /** + * Returns `true` if the area corner should be visible. + * + * @param {number} layerLevel The layer level. + * @returns {boolean} `true` if the corner element has to be visible, `false` otherwise. + */ + + }, { + key: "isAreaCornerVisible", + value: function isAreaCornerVisible(layerLevel) { + if (Number.isInteger(layerLevel) && layerLevel !== this.getLayerLevel()) { + return false; + } + + return this.settings.fillHandle && !this.tableProps.isEditorOpened() && this.isMultiple(); + } + /** + * Clear the selection by resetting the collected ranges and highlights. + */ + + }, { + key: "clear", + value: function clear() { + // TODO: collections selectedByColumnHeader and selectedByRowHeader should be clear too. + this.selectedRange.clear(); + this.highlight.clear(); + } + /** + * Deselects all selected cells. + */ + + }, { + key: "deselect", + value: function deselect() { + if (!this.isSelected()) { + return; + } + + this.inProgress = false; + this.clear(); + this.runLocalHooks('afterDeselect'); + } + /** + * Select all cells. + * + * @param {boolean} [includeRowHeaders=false] `true` If the selection should include the row headers, `false` + * otherwise. + * @param {boolean} [includeColumnHeaders=false] `true` If the selection should include the column headers, `false` + * otherwise. + */ + + }, { + key: "selectAll", + value: function selectAll() { + var includeRowHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var includeColumnHeaders = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var nrOfRows = this.tableProps.countRows(); + var nrOfColumns = this.tableProps.countCols(); // We can't select cells when there is no data. + + if (!includeRowHeaders && !includeColumnHeaders && (nrOfRows === 0 || nrOfColumns === 0)) { + return; + } + + var startCoords = new CellCoords(includeColumnHeaders ? -1 : 0, includeRowHeaders ? -1 : 0); + this.clear(); + this.setRangeStartOnly(startCoords); + this.selectedByRowHeader.add(this.getLayerLevel()); + this.selectedByColumnHeader.add(this.getLayerLevel()); + this.setRangeEnd(new CellCoords(nrOfRows - 1, nrOfColumns - 1)); + this.finish(); + } + /** + * Make multiple, non-contiguous selection specified by `row` and `column` values or a range of cells + * finishing at `endRow`, `endColumn`. The method supports two input formats, first as an array of arrays such + * as `[[rowStart, columnStart, rowEnd, columnEnd]]` and second format as an array of CellRange objects. + * If the passed ranges have another format the exception will be thrown. + * + * @param {Array[]|CellRange[]} selectionRanges The coordinates which define what the cells should be selected. + * @returns {boolean} Returns `true` if selection was successful, `false` otherwise. + */ + + }, { + key: "selectCells", + value: function selectCells(selectionRanges) { + var _this2 = this; + + var selectionType = detectSelectionType(selectionRanges); + + if (selectionType === SELECTION_TYPE_EMPTY) { + return false; + } else if (selectionType === SELECTION_TYPE_UNRECOGNIZED) { + throw new Error(toSingleLine(_templateObject$4 || (_templateObject$4 = _taggedTemplateLiteral$4(["Unsupported format of the selection ranges was passed. To select cells pass \n the coordinates as an array of arrays ([[rowStart, columnStart/columnPropStart, rowEnd, \n columnEnd/columnPropEnd]]) or as an array of CellRange objects."], ["Unsupported format of the selection ranges was passed. To select cells pass\\x20\n the coordinates as an array of arrays ([[rowStart, columnStart/columnPropStart, rowEnd,\\x20\n columnEnd/columnPropEnd]]) or as an array of CellRange objects."])))); + } + + var selectionSchemaNormalizer = normalizeSelectionFactory(selectionType, { + propToCol: function propToCol(prop) { + return _this2.tableProps.propToCol(prop); + }, + keepDirection: true + }); + var nrOfRows = this.tableProps.countRows(); + var nrOfColumns = this.tableProps.countCols(); // Check if every layer of the coordinates are valid. + + var isValid = !selectionRanges.some(function (selection) { + var _selectionSchemaNorma = selectionSchemaNormalizer(selection), + _selectionSchemaNorma2 = _slicedToArray$b(_selectionSchemaNorma, 4), + rowStart = _selectionSchemaNorma2[0], + columnStart = _selectionSchemaNorma2[1], + rowEnd = _selectionSchemaNorma2[2], + columnEnd = _selectionSchemaNorma2[3]; + + var _isValid = isValidCoord(rowStart, nrOfRows) && isValidCoord(columnStart, nrOfColumns) && isValidCoord(rowEnd, nrOfRows) && isValidCoord(columnEnd, nrOfColumns); + + return !_isValid; + }); + + if (isValid) { + this.clear(); + arrayEach(selectionRanges, function (selection) { + var _selectionSchemaNorma3 = selectionSchemaNormalizer(selection), + _selectionSchemaNorma4 = _slicedToArray$b(_selectionSchemaNorma3, 4), + rowStart = _selectionSchemaNorma4[0], + columnStart = _selectionSchemaNorma4[1], + rowEnd = _selectionSchemaNorma4[2], + columnEnd = _selectionSchemaNorma4[3]; + + _this2.setRangeStartOnly(new CellCoords(rowStart, columnStart), false); + + _this2.setRangeEnd(new CellCoords(rowEnd, columnEnd)); + + _this2.finish(); + }); + } + + return isValid; + } + /** + * Select column specified by `startColumn` visual index or column property or a range of columns finishing at + * `endColumn`. + * + * @param {number|string} startColumn Visual column index or column property from which the selection starts. + * @param {number|string} [endColumn] Visual column index or column property from to the selection finishes. + * @returns {boolean} Returns `true` if selection was successful, `false` otherwise. + */ + + }, { + key: "selectColumns", + value: function selectColumns(startColumn) { + var endColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startColumn; + var start = typeof startColumn === 'string' ? this.tableProps.propToCol(startColumn) : startColumn; + var end = typeof endColumn === 'string' ? this.tableProps.propToCol(endColumn) : endColumn; + var nrOfColumns = this.tableProps.countCols(); + var nrOfRows = this.tableProps.countRows(); + var isValid = isValidCoord(start, nrOfColumns) && isValidCoord(end, nrOfColumns); + + if (isValid) { + this.setRangeStartOnly(new CellCoords(-1, start)); + this.setRangeEnd(new CellCoords(nrOfRows - 1, end)); + this.finish(); + } + + return isValid; + } + /** + * Select row specified by `startRow` visual index or a range of rows finishing at `endRow`. + * + * @param {number} startRow Visual row index from which the selection starts. + * @param {number} [endRow] Visual row index from to the selection finishes. + * @returns {boolean} Returns `true` if selection was successful, `false` otherwise. + */ + + }, { + key: "selectRows", + value: function selectRows(startRow) { + var endRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startRow; + var nrOfRows = this.tableProps.countRows(); + var nrOfColumns = this.tableProps.countCols(); + var isValid = isValidCoord(startRow, nrOfRows) && isValidCoord(endRow, nrOfRows); + + if (isValid) { + this.setRangeStartOnly(new CellCoords(startRow, -1)); + this.setRangeEnd(new CellCoords(endRow, nrOfColumns - 1)); + this.finish(); + } + + return isValid; + } + /** + * Rewrite the rendered state of the selection as visual selection may have a new representation in the DOM. + */ + + }, { + key: "refresh", + value: function refresh() { + var customSelections = this.highlight.getCustomSelections(); + customSelections.forEach(function (customSelection) { + customSelection.commit(); + }); + + if (!this.isSelected()) { + return; + } + + var cellHighlight = this.highlight.getCell(); + var currentLayer = this.getLayerLevel(); + cellHighlight.commit().adjustCoordinates(this.selectedRange.current()); // Rewriting rendered ranges going through all layers. + + for (var layerLevel = 0; layerLevel < this.selectedRange.size(); layerLevel += 1) { + this.highlight.useLayerLevel(layerLevel); + var areaHighlight = this.highlight.createOrGetArea(); + var headerHighlight = this.highlight.createOrGetHeader(); + var activeHeaderHighlight = this.highlight.createOrGetActiveHeader(); + areaHighlight.commit(); + headerHighlight.commit(); + activeHeaderHighlight.commit(); + } // Reverting starting layer for the Highlight. + + + this.highlight.useLayerLevel(currentLayer); + } + }]); + + return Selection; +}(); + +mixin(Selection$1, localHooks); + +var getOwnPropertyDescriptor$4 = objectGetOwnPropertyDescriptor.f; + + + + + + +var nativeStartsWith = ''.startsWith; +var min$6 = Math.min; + +var CORRECT_IS_REGEXP_LOGIC = correctIsRegexpLogic('startsWith'); +// https://github.com/zloirock/core-js/pull/702 +var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor$4(String.prototype, 'startsWith'); + return descriptor && !descriptor.writable; +}(); + +// `String.prototype.startsWith` method +// https://tc39.es/ecma262/#sec-string.prototype.startswith +_export({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, { + startsWith: function startsWith(searchString /* , position = 0 */) { + var that = String(requireObjectCoercible(this)); + notARegexp(searchString); + var index = toLength(min$6(arguments.length > 1 ? arguments[1] : undefined, that.length)); + var search = String(searchString); + return nativeStartsWith + ? nativeStartsWith.call(that, search, index) + : that.slice(index, index + search.length) === search; + } +}); + +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * SheetClip - Spreadsheet Clipboard Parser. + * version 0.2 + * + * This tiny library transforms JavaScript arrays to strings that are pasteable by LibreOffice, OpenOffice, + * Google Docs and Microsoft Excel. + * + * Copyright 2012, Marcin Warpechowski + * Licensed under the MIT license. + * http://github.com/warpech/sheetclip/ + */ +var regUniversalNewLine = /^(\r\n|\n\r|\r|\n)/; +var regNextCellNoQuotes = /^[^\t\r\n]+/; +var regNextEmptyCell = /^\t/; +/** + * Decode spreadsheet string into array. + * + * @param {string} str The string to parse. + * @returns {Array} + */ + +function parse(str) { + var arr = [['']]; + + if (str.length === 0) { + return arr; + } + + var column = 0; + var row = 0; + var lastLength; + + while (str.length > 0) { + if (lastLength === str.length) { + // In the case If in last cycle we didn't match anything, we have to leave the infinite loop + break; + } + + lastLength = str.length; + + if (str.match(regNextEmptyCell)) { + str = str.replace(regNextEmptyCell, ''); + column += 1; + arr[row][column] = ''; + } else if (str.match(regUniversalNewLine)) { + str = str.replace(regUniversalNewLine, ''); + column = 0; + row += 1; + arr[row] = ['']; + } else { + var nextCell = ''; + + if (str.startsWith('"')) { + var quoteNo = 0; + var isStillCell = true; + + while (isStillCell) { + var nextChar = str.slice(0, 1); + + if (nextChar === '"') { + quoteNo += 1; + } + + nextCell += nextChar; + str = str.slice(1); + + if (str.length === 0 || str.match(/^[\t\r\n]/) && quoteNo % 2 === 0) { + isStillCell = false; + } + } + + nextCell = nextCell.replace(/^"/, '').replace(/"$/, '').replace(/["]*/g, function (match) { + return new Array(Math.floor(match.length / 2)).fill('"').join(''); + }); + } else { + var matchedText = str.match(regNextCellNoQuotes); + nextCell = matchedText ? matchedText[0] : ''; + str = str.slice(nextCell.length); + } + + arr[row][column] = nextCell; + } + } + + return arr; +} +/** + * Encode array into valid spreadsheet string. + * + * @param {Array} arr An array of arrays to stringify. + * @returns {string} + */ + +function stringify$1(arr) { + var r; + var rLen; + var c; + var cLen; + var str = ''; + var val; + + for (r = 0, rLen = arr.length; r < rLen; r += 1) { + cLen = arr[r].length; + + for (c = 0; c < cLen; c += 1) { + if (c > 0) { + str += '\t'; + } + + val = arr[r][c]; + + if (typeof val === 'string') { + if (val.indexOf('\n') > -1) { + str += "\"".concat(val.replace(/"/g, '""'), "\""); + } else { + str += val; + } + } else if (val === null || val === void 0) { + // void 0 resolves to undefined + str += ''; + } else { + str += val; + } + } + + if (r !== rLen - 1) { + str += '\n'; + } + } + + return str; +} + +function _typeof$x(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$x = function _typeof(obj) { return typeof obj; }; } else { _typeof$x = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$x(obj); } + +function _classCallCheck$_(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$V(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); } } + +function _createClass$V(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$V(Constructor.prototype, protoProps); if (staticProps) _defineProperties$V(Constructor, staticProps); return Constructor; } +var copyableLookup = cellMethodLookupFactory('copyable', false); +/** + * Utility class that gets and saves data from/to the data source using mapping of columns numbers to object property names. + * + * @todo Refactor arguments of methods getRange, getText to be numbers (not objects). + * @todo Remove priv, GridSettings from object constructor. + * + * @util + * @class DataMap + * @private + */ + +var DataMap = /*#__PURE__*/function () { + /** + * @param {object} instance Instance of Handsontable. + * @param {Array} data Array of arrays or array of objects containing data. + * @param {TableMeta} tableMeta The table meta instance. + */ + function DataMap(instance, data, tableMeta) { + _classCallCheck$_(this, DataMap); + + /** + * Instance of {@link Handsontable}. + * + * @private + * @type {Handsontable} + */ + this.instance = instance; + /** + * Instance of {@link TableMeta}. + * + * @private + * @type {TableMeta} + */ + + this.tableMeta = tableMeta; + /** + * Reference to the original dataset. + * + * @type {*} + */ + + this.dataSource = data; + /** + * Generated schema based on the first row from the source data. + * + * @type {object} + */ + + this.duckSchema = this.dataSource && this.dataSource[0] ? duckSchema(this.dataSource[0]) : {}; + /** + * Cached array of properties to columns. + * + * @type {Array} + */ + + this.colToPropCache = void 0; + /** + * Cached map of properties to columns. + * + * @type {Map} + */ + + this.propToColCache = void 0; + this.createMap(); + } + /** + * Generates cache for property to and from column addressation. + */ + + + _createClass$V(DataMap, [{ + key: "createMap", + value: function createMap() { + var schema = this.getSchema(); + + if (typeof schema === 'undefined') { + throw new Error('trying to create `columns` definition but you didn\'t provide `schema` nor `data`'); + } + + var columns = this.tableMeta.columns; + var i; + this.colToPropCache = []; + this.propToColCache = new Map(); + + if (columns) { + var columnsLen = 0; + var filteredIndex = 0; + var columnsAsFunc = false; + + if (typeof columns === 'function') { + var schemaLen = deepObjectSize(schema); + columnsLen = schemaLen > 0 ? schemaLen : this.countFirstRowKeys(); + columnsAsFunc = true; + } else { + var maxCols = this.tableMeta.maxCols; + columnsLen = Math.min(maxCols, columns.length); + } + + for (i = 0; i < columnsLen; i++) { + var column = columnsAsFunc ? columns(i) : columns[i]; + + if (isObject$1(column)) { + if (typeof column.data !== 'undefined') { + var index = columnsAsFunc ? filteredIndex : i; + this.colToPropCache[index] = column.data; + this.propToColCache.set(column.data, index); + } + + filteredIndex += 1; + } + } + } else { + this.recursiveDuckColumns(schema); + } + } + /** + * Get the amount of physical columns in the first data row. + * + * @returns {number} Amount of physical columns in the first data row. + */ + + }, { + key: "countFirstRowKeys", + value: function countFirstRowKeys$1() { + return countFirstRowKeys(this.dataSource); + } + /** + * Generates columns' translation cache. + * + * @param {object} schema An object to generate schema from. + * @param {number} lastCol The column index. + * @param {number} parent The property cache for recursive calls. + * @returns {number} + */ + + }, { + key: "recursiveDuckColumns", + value: function recursiveDuckColumns(schema, lastCol, parent) { + var _this = this; + + var lastColumn = lastCol; + var propertyParent = parent; + var prop; + + if (typeof lastColumn === 'undefined') { + lastColumn = 0; + propertyParent = ''; + } + + if (_typeof$x(schema) === 'object' && !Array.isArray(schema)) { + objectEach(schema, function (value, key) { + if (value === null) { + prop = propertyParent + key; + + _this.colToPropCache.push(prop); + + _this.propToColCache.set(prop, lastColumn); + + lastColumn += 1; + } else { + lastColumn = _this.recursiveDuckColumns(value, lastColumn, "".concat(key, ".")); + } + }); + } + + return lastColumn; + } + /** + * Returns property name that corresponds with the given column index. + * + * @param {string|number} column Visual column index or another passed argument. + * @returns {string|number} Column property, physical column index or passed argument. + */ + + }, { + key: "colToProp", + value: function colToProp(column) { + // TODO: Should it work? Please, look at the test: + // "it should return the provided property name, when the user passes a property name as a column number". + if (Number.isInteger(column) === false) { + return column; + } + + var physicalColumn = this.instance.toPhysicalColumn(column); // Out of range, not visible column index. + + if (physicalColumn === null) { + return column; + } // Cached property. + + + if (this.colToPropCache && isDefined(this.colToPropCache[physicalColumn])) { + return this.colToPropCache[physicalColumn]; + } + + return physicalColumn; + } + /** + * Translates property into visual column index. + * + * @param {string|number} prop Column property which may be also a physical column index. + * @returns {string|number} Visual column index or passed argument. + */ + + }, { + key: "propToCol", + value: function propToCol(prop) { + var cachedPhysicalIndex = this.propToColCache.get(prop); + + if (isDefined(cachedPhysicalIndex)) { + return this.instance.toVisualColumn(cachedPhysicalIndex); + } // Property may be a physical column index. + + + var visualColumn = this.instance.toVisualColumn(prop); + + if (visualColumn === null) { + return prop; + } + + return visualColumn; + } + /** + * Returns data's schema. + * + * @returns {object} + */ + + }, { + key: "getSchema", + value: function getSchema() { + var schema = this.tableMeta.dataSchema; + + if (schema) { + if (typeof schema === 'function') { + return schema(); + } + + return schema; + } + + return this.duckSchema; + } + /** + * Creates row at the bottom of the data array. + * + * @param {number} [index] Physical index of the row before which the new row will be inserted. + * @param {number} [amount=1] An amount of rows to add. + * @param {string} [source] Source of method call. + * @fires Hooks#afterCreateRow + * @returns {number} Returns number of created rows. + */ + + }, { + key: "createRow", + value: function createRow(index) { + var _this2 = this; + + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + var source = arguments.length > 2 ? arguments[2] : undefined; + var sourceRowsCount = this.instance.countSourceRows(); + var physicalRowIndex = sourceRowsCount; + var numberOfCreatedRows = 0; + var rowIndex = index; + + if (typeof rowIndex !== 'number' || rowIndex >= sourceRowsCount) { + rowIndex = sourceRowsCount; + } + + if (rowIndex < this.instance.countRows()) { + physicalRowIndex = this.instance.toPhysicalRow(rowIndex); + } + + var continueProcess = this.instance.runHooks('beforeCreateRow', rowIndex, amount, source); + + if (continueProcess === false || physicalRowIndex === null) { + return 0; + } + + var maxRows = this.tableMeta.maxRows; + var columnCount = this.instance.countCols(); + var rowsToAdd = []; + + var _loop = function _loop() { + var row = null; + + if (_this2.instance.dataType === 'array') { + if (_this2.tableMeta.dataSchema) { + // Clone template array + row = deepClone(_this2.getSchema()); + } else { + row = []; + /* eslint-disable no-loop-func */ + + rangeEach(columnCount - 1, function () { + return row.push(null); + }); + } + } else if (_this2.instance.dataType === 'function') { + row = _this2.tableMeta.dataSchema(rowIndex + numberOfCreatedRows); + } else { + row = {}; + deepExtend(row, _this2.getSchema()); + } + + rowsToAdd.push(row); + numberOfCreatedRows += 1; + }; + + while (numberOfCreatedRows < amount && sourceRowsCount + numberOfCreatedRows < maxRows) { + _loop(); + } + + this.instance.rowIndexMapper.insertIndexes(rowIndex, numberOfCreatedRows); + this.spliceData.apply(this, [physicalRowIndex, 0].concat(rowsToAdd)); + this.instance.runHooks('afterCreateRow', rowIndex, numberOfCreatedRows, source); + this.instance.forceFullRender = true; // used when data was changed + + return numberOfCreatedRows; + } + /** + * Creates column at the right of the data array. + * + * @param {number} [index] Visual index of the column before which the new column will be inserted. + * @param {number} [amount=1] An amount of columns to add. + * @param {string} [source] Source of method call. + * @fires Hooks#afterCreateCol + * @returns {number} Returns number of created columns. + */ + + }, { + key: "createCol", + value: function createCol(index) { + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + var source = arguments.length > 2 ? arguments[2] : undefined; + + if (!this.instance.isColumnModificationAllowed()) { + throw new Error('Cannot create new column. When data source in an object, ' + 'you can only have as much columns as defined in first data row, data schema or in the \'columns\' setting.' + 'If you want to be able to add new columns, you have to use array datasource.'); + } + + var dataSource = this.dataSource; + var maxCols = this.tableMeta.maxCols; + var columnIndex = index; + + if (typeof columnIndex !== 'number' || columnIndex >= this.instance.countSourceCols()) { + columnIndex = this.instance.countSourceCols(); + } + + var continueProcess = this.instance.runHooks('beforeCreateCol', columnIndex, amount, source); + + if (continueProcess === false) { + return 0; + } + + var physicalColumnIndex = this.instance.countSourceCols(); + + if (columnIndex < this.instance.countCols()) { + physicalColumnIndex = this.instance.toPhysicalColumn(columnIndex); + } + + var numberOfSourceRows = this.instance.countSourceRows(); + var nrOfColumns = this.instance.countCols(); + var numberOfCreatedCols = 0; + var currentIndex = physicalColumnIndex; + + while (numberOfCreatedCols < amount && nrOfColumns < maxCols) { + if (typeof columnIndex !== 'number' || columnIndex >= nrOfColumns) { + if (numberOfSourceRows > 0) { + for (var row = 0; row < numberOfSourceRows; row += 1) { + if (typeof dataSource[row] === 'undefined') { + dataSource[row] = []; + } + + dataSource[row].push(null); + } + } else { + dataSource.push([null]); + } + } else { + for (var _row = 0; _row < numberOfSourceRows; _row++) { + dataSource[_row].splice(currentIndex, 0, null); + } + } + + numberOfCreatedCols += 1; + currentIndex += 1; + nrOfColumns += 1; + } + + this.instance.columnIndexMapper.insertIndexes(columnIndex, numberOfCreatedCols); + this.instance.runHooks('afterCreateCol', columnIndex, numberOfCreatedCols, source); + this.instance.forceFullRender = true; // used when data was changed + + return numberOfCreatedCols; + } + /** + * Removes row from the data array. + * + * @fires Hooks#beforeRemoveRow + * @fires Hooks#afterRemoveRow + * @param {number} [index] Visual index of the row to be removed. If not provided, the last row will be removed. + * @param {number} [amount=1] Amount of the rows to be removed. If not provided, one row will be removed. + * @param {string} [source] Source of method call. + * @returns {boolean} Returns `false` when action was cancelled, otherwise `true`. + */ + + }, { + key: "removeRow", + value: function removeRow(index) { + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + var source = arguments.length > 2 ? arguments[2] : undefined; + var rowIndex = Number.isInteger(index) ? index : -amount; // -amount = taking indexes from the end. + + var removedPhysicalIndexes = this.visualRowsToPhysical(rowIndex, amount); + var sourceRowsLength = this.instance.countSourceRows(); + rowIndex = (sourceRowsLength + rowIndex) % sourceRowsLength; // It handle also callback from the `NestedRows` plugin. Removing parent node has effect in removing children nodes. + + var actionWasNotCancelled = this.instance.runHooks('beforeRemoveRow', rowIndex, removedPhysicalIndexes.length, removedPhysicalIndexes, source); + + if (actionWasNotCancelled === false) { + return false; + } + + var data = this.dataSource; // List of removed indexes might be changed in the `beforeRemoveRow` hook. There may be new values. + + var numberOfRemovedIndexes = removedPhysicalIndexes.length; + var newData = this.filterData(rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes); + + if (newData) { + data.length = 0; + Array.prototype.push.apply(data, newData); + } // TODO: Function `removeRow` should validate fully, probably above. + + + if (rowIndex < this.instance.countRows()) { + this.instance.rowIndexMapper.removeIndexes(removedPhysicalIndexes); + var customDefinedColumns = isDefined(this.tableMeta.columns) || isDefined(this.tableMeta.dataSchema); // All rows have been removed. There shouldn't be any columns. + + if (this.instance.rowIndexMapper.getNotTrimmedIndexesLength() === 0 && customDefinedColumns === false) { + this.instance.columnIndexMapper.setIndexesSequence([]); + } + } + + this.instance.runHooks('afterRemoveRow', rowIndex, numberOfRemovedIndexes, removedPhysicalIndexes, source); + this.instance.forceFullRender = true; // used when data was changed + + return true; + } + /** + * Removes column from the data array. + * + * @fires Hooks#beforeRemoveCol + * @fires Hooks#afterRemoveCol + * @param {number} [index] Visual index of the column to be removed. If not provided, the last column will be removed. + * @param {number} [amount=1] Amount of the columns to be removed. If not provided, one column will be removed. + * @param {string} [source] Source of method call. + * @returns {boolean} Returns `false` when action was cancelled, otherwise `true`. + */ + + }, { + key: "removeCol", + value: function removeCol(index) { + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + var source = arguments.length > 2 ? arguments[2] : undefined; + + if (this.instance.dataType === 'object' || this.tableMeta.columns) { + throw new Error('cannot remove column with object data source or columns option specified'); + } + + var columnIndex = typeof index !== 'number' ? -amount : index; + columnIndex = (this.instance.countCols() + columnIndex) % this.instance.countCols(); + var logicColumns = this.visualColumnsToPhysical(columnIndex, amount); + var descendingLogicColumns = logicColumns.slice(0).sort(function (a, b) { + return b - a; + }); + var actionWasNotCancelled = this.instance.runHooks('beforeRemoveCol', columnIndex, amount, logicColumns, source); + + if (actionWasNotCancelled === false) { + return false; + } + + var isTableUniform = true; + var removedColumnsCount = descendingLogicColumns.length; + var data = this.dataSource; + + for (var c = 0; c < removedColumnsCount; c++) { + if (isTableUniform && logicColumns[0] !== logicColumns[c] - c) { + isTableUniform = false; + } + } + + if (isTableUniform) { + for (var r = 0, rlen = this.instance.countSourceRows(); r < rlen; r++) { + data[r].splice(logicColumns[0], amount); + } + } else { + for (var _r = 0, _rlen = this.instance.countSourceRows(); _r < _rlen; _r++) { + for (var _c = 0; _c < removedColumnsCount; _c++) { + data[_r].splice(descendingLogicColumns[_c], 1); + } + } + } // TODO: Function `removeCol` should validate fully, probably above. + + + if (columnIndex < this.instance.countCols()) { + this.instance.columnIndexMapper.removeIndexes(logicColumns); // All columns have been removed. There shouldn't be any rows. + + if (this.instance.columnIndexMapper.getNotTrimmedIndexesLength() === 0) { + this.instance.rowIndexMapper.setIndexesSequence([]); + } + } + + this.instance.runHooks('afterRemoveCol', columnIndex, amount, logicColumns, source); + this.instance.forceFullRender = true; // used when data was changed + + return true; + } + /** + * Add/Removes data from the column. + * + * @param {number} col Physical index of column in which do you want to do splice. + * @param {number} index Index at which to start changing the array. If negative, will begin that many elements from the end. + * @param {number} amount An integer indicating the number of old array elements to remove. If amount is 0, no elements are removed. + * @param {Array} [elements] The new columns to add. + * @returns {Array} Returns removed portion of columns. + */ + + }, { + key: "spliceCol", + value: function spliceCol(col, index, amount) { + var colData = this.instance.getDataAtCol(col); + var removed = colData.slice(index, index + amount); + var after = colData.slice(index + amount); + + for (var _len = arguments.length, elements = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) { + elements[_key - 3] = arguments[_key]; + } + + extendArray(elements, after); + var i = 0; + + while (i < amount) { + elements.push(null); // add null in place of removed elements + + i += 1; + } + + to2dArray(elements); + this.instance.populateFromArray(index, col, elements, null, null, 'spliceCol'); + return removed; + } + /** + * Add/Removes data from the row. + * + * @param {number} row Physical index of row in which do you want to do splice. + * @param {number} index Index at which to start changing the array. If negative, will begin that many elements from the end. + * @param {number} amount An integer indicating the number of old array elements to remove. If amount is 0, no elements are removed. + * @param {Array} [elements] The new rows to add. + * @returns {Array} Returns removed portion of rows. + */ + + }, { + key: "spliceRow", + value: function spliceRow(row, index, amount) { + var rowData = this.instance.getSourceDataAtRow(row); + var removed = rowData.slice(index, index + amount); + var after = rowData.slice(index + amount); + + for (var _len2 = arguments.length, elements = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) { + elements[_key2 - 3] = arguments[_key2]; + } + + extendArray(elements, after); + var i = 0; + + while (i < amount) { + elements.push(null); // add null in place of removed elements + + i += 1; + } + + this.instance.populateFromArray(row, index, [elements], null, null, 'spliceRow'); + return removed; + } + /** + * Add/remove row(s) to/from the data source. + * + * @param {number} index Physical index of the element to add/remove. + * @param {number} amount Number of rows to add/remove. + * @param {...object} elements Row elements to be added. + */ + + }, { + key: "spliceData", + value: function spliceData(index, amount) { + for (var _len3 = arguments.length, elements = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) { + elements[_key3 - 2] = arguments[_key3]; + } + + var continueSplicing = this.instance.runHooks('beforeDataSplice', index, amount, elements); + + if (continueSplicing !== false) { + var _this$dataSource; + + (_this$dataSource = this.dataSource).splice.apply(_this$dataSource, [index, amount].concat(elements)); + } + } + /** + * Filter unwanted data elements from the data source. + * + * @param {number} index Visual index of the element to remove. + * @param {number} amount Number of rows to add/remove. + * @param {number} physicalRows Physical row indexes. + * @returns {Array} + */ + + }, { + key: "filterData", + value: function filterData(index, amount, physicalRows) { + var continueSplicing = this.instance.runHooks('beforeDataFilter', index, amount, physicalRows); + + if (continueSplicing !== false) { + var newData = this.dataSource.filter(function (row, rowIndex) { + return physicalRows.indexOf(rowIndex) === -1; + }); + return newData; + } + } + /** + * Returns single value from the data array. + * + * @param {number} row Visual row index. + * @param {number} prop The column property. + * @returns {*} + */ + + }, { + key: "get", + value: function get(row, prop) { + var physicalRow = this.instance.toPhysicalRow(row); + var dataRow = this.dataSource[physicalRow]; // TODO: To remove, use 'modifyData' hook instead (see below) + + var modifiedRowData = this.instance.runHooks('modifyRowData', physicalRow); + dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow; // + + var value = null; // try to get value under property `prop` (includes dot) + + if (dataRow && dataRow.hasOwnProperty && hasOwnProperty$1(dataRow, prop)) { + value = dataRow[prop]; + } else if (typeof prop === 'string' && prop.indexOf('.') > -1) { + var sliced = prop.split('.'); + var out = dataRow; + + if (!out) { + return null; + } + + for (var i = 0, ilen = sliced.length; i < ilen; i++) { + out = out[sliced[i]]; + + if (typeof out === 'undefined') { + return null; + } + } + + value = out; + } else if (typeof prop === 'function') { + /** + * Allows for interacting with complex structures, for example + * d3/jQuery getter/setter properties: + * + * {columns: [{ + * data: function(row, value){ + * if(arguments.length === 1){ + * return row.property(); + * } + * row.property(value); + * } + * }]}. + */ + value = prop(this.dataSource.slice(physicalRow, physicalRow + 1)[0]); + } + + if (this.instance.hasHook('modifyData')) { + var valueHolder = createObjectPropListener(value); + this.instance.runHooks('modifyData', physicalRow, this.propToCol(prop), valueHolder, 'get'); + + if (valueHolder.isTouched()) { + value = valueHolder.value; + } + } + + return value; + } + /** + * Returns single value from the data array (intended for clipboard copy to an external application). + * + * @param {number} row Physical row index. + * @param {number} prop The column property. + * @returns {string} + */ + + }, { + key: "getCopyable", + value: function getCopyable(row, prop) { + if (copyableLookup.call(this.instance, row, this.propToCol(prop))) { + return this.get(row, prop); + } + + return ''; + } + /** + * Saves single value to the data array. + * + * @param {number} row Visual row index. + * @param {number} prop The column property. + * @param {string} value The value to set. + */ + + }, { + key: "set", + value: function set(row, prop, value) { + var physicalRow = this.instance.toPhysicalRow(row); + var newValue = value; + var dataRow = this.dataSource[physicalRow]; // TODO: To remove, use 'modifyData' hook instead (see below) + + var modifiedRowData = this.instance.runHooks('modifyRowData', physicalRow); + dataRow = isNaN(modifiedRowData) ? modifiedRowData : dataRow; // + + if (this.instance.hasHook('modifyData')) { + var valueHolder = createObjectPropListener(newValue); + this.instance.runHooks('modifyData', physicalRow, this.propToCol(prop), valueHolder, 'set'); + + if (valueHolder.isTouched()) { + newValue = valueHolder.value; + } + } // try to set value under property `prop` (includes dot) + + + if (dataRow && dataRow.hasOwnProperty && hasOwnProperty$1(dataRow, prop)) { + dataRow[prop] = newValue; + } else if (typeof prop === 'string' && prop.indexOf('.') > -1) { + var sliced = prop.split('.'); + var out = dataRow; + var i = 0; + var ilen; + + for (i = 0, ilen = sliced.length - 1; i < ilen; i++) { + if (typeof out[sliced[i]] === 'undefined') { + out[sliced[i]] = {}; + } + + out = out[sliced[i]]; + } + + out[sliced[i]] = newValue; + } else if (typeof prop === 'function') { + /* see the `function` handler in `get` */ + prop(this.dataSource.slice(physicalRow, physicalRow + 1)[0], newValue); + } else { + dataRow[prop] = newValue; + } + } + /** + * This ridiculous piece of code maps rows Id that are present in table data to those displayed for user. + * The trick is, the physical row id (stored in settings.data) is not necessary the same + * as the visual (displayed) row id (e.g. When sorting is applied). + * + * @param {number} index Visual row index. + * @param {number} amount An amount of rows to translate. + * @returns {number} + */ + + }, { + key: "visualRowsToPhysical", + value: function visualRowsToPhysical(index, amount) { + var totalRows = this.instance.countSourceRows(); + var logicRows = []; + var physicRow = (totalRows + index) % totalRows; + var rowsToRemove = amount; + var row; + + while (physicRow < totalRows && rowsToRemove) { + row = this.instance.toPhysicalRow(physicRow); + logicRows.push(row); + rowsToRemove -= 1; + physicRow += 1; + } + + return logicRows; + } + /** + * + * @param {number} index Visual column index. + * @param {number} amount An amount of rows to translate. + * @returns {Array} + */ + + }, { + key: "visualColumnsToPhysical", + value: function visualColumnsToPhysical(index, amount) { + var totalCols = this.instance.countCols(); + var visualCols = []; + var physicalCol = (totalCols + index) % totalCols; + var colsToRemove = amount; + + while (physicalCol < totalCols && colsToRemove) { + var col = this.instance.toPhysicalColumn(physicalCol); + visualCols.push(col); + colsToRemove -= 1; + physicalCol += 1; + } + + return visualCols; + } + /** + * Clears the data array. + */ + + }, { + key: "clear", + value: function clear() { + for (var r = 0; r < this.instance.countSourceRows(); r++) { + for (var c = 0; c < this.instance.countCols(); c++) { + this.set(r, this.colToProp(c), ''); + } + } + } + /** + * Get data length. + * + * @returns {number} + */ + + }, { + key: "getLength", + value: function getLength() { + var maxRowsFromSettings = this.tableMeta.maxRows; + var maxRows; + + if (maxRowsFromSettings < 0 || maxRowsFromSettings === 0) { + maxRows = 0; + } else { + maxRows = maxRowsFromSettings || Infinity; + } + + var length = this.instance.rowIndexMapper.getNotTrimmedIndexesLength(); + return Math.min(length, maxRows); + } + /** + * Returns the data array. + * + * @returns {Array} + */ + + }, { + key: "getAll", + value: function getAll() { + var start = { + row: 0, + col: 0 + }; + var end = { + row: Math.max(this.instance.countRows() - 1, 0), + col: Math.max(this.instance.countCols() - 1, 0) + }; + + if (start.row - end.row === 0 && !this.instance.countSourceRows()) { + return []; + } + + return this.getRange(start, end, DataMap.DESTINATION_RENDERER); + } + /** + * Count the number of columns cached in the `colToProp` cache. + * + * @returns {number} Amount of cached columns. + */ + + }, { + key: "countCachedColumns", + value: function countCachedColumns() { + return this.colToPropCache.length; + } + /** + * Returns data range as array. + * + * @param {object} [start] Start selection position. Visual indexes. + * @param {object} [end] End selection position. Visual indexes. + * @param {number} destination Destination of datamap.get. + * @returns {Array} + */ + + }, { + key: "getRange", + value: function getRange(start, end, destination) { + var output = []; + var r; + var c; + var row; + var maxRows = this.tableMeta.maxRows; + var maxCols = this.tableMeta.maxCols; + + if (maxRows === 0 || maxCols === 0) { + return []; + } + + var getFn = destination === DataMap.DESTINATION_CLIPBOARD_GENERATOR ? this.getCopyable : this.get; + var rlen = Math.min(Math.max(maxRows - 1, 0), Math.max(start.row, end.row)); + var clen = Math.min(Math.max(maxCols - 1, 0), Math.max(start.col, end.col)); + + for (r = Math.min(start.row, end.row); r <= rlen; r++) { + row = []; // We just store indexes for rows without headers. + + var physicalRow = r >= 0 ? this.instance.toPhysicalRow(r) : r; + + for (c = Math.min(start.col, end.col); c <= clen; c++) { + if (physicalRow === null) { + break; + } + + row.push(getFn.call(this, r, this.colToProp(c))); + } + + if (physicalRow !== null) { + output.push(row); + } + } + + return output; + } + /** + * Return data as text (tab separated columns). + * + * @param {object} [start] Start selection position. Visual indexes. + * @param {object} [end] End selection position. Visual indexes. + * @returns {string} + */ + + }, { + key: "getText", + value: function getText(start, end) { + return stringify$1(this.getRange(start, end, DataMap.DESTINATION_RENDERER)); + } + /** + * Return data as copyable text (tab separated columns intended for clipboard copy to an external application). + * + * @param {object} [start] Start selection position. Visual indexes. + * @param {object} [end] End selection position. Visual indexes. + * @returns {string} + */ + + }, { + key: "getCopyableText", + value: function getCopyableText(start, end) { + return stringify$1(this.getRange(start, end, DataMap.DESTINATION_CLIPBOARD_GENERATOR)); + } + /** + * Destroy instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.instance = null; + this.tableMeta = null; + this.dataSource = null; + this.duckSchema = null; + this.colToPropCache.length = 0; + this.propToColCache.clear(); + this.propToColCache = void 0; + } + }], [{ + key: "DESTINATION_RENDERER", + get: + /** + * @type {number} + */ + function get() { + return 1; + } + /** + * @type {number} + */ + + }, { + key: "DESTINATION_CLIPBOARD_GENERATOR", + get: function get() { + return 2; + } + }]); + + return DataMap; +}(); + +/** + * Expands "type" property of the meta object to single values. For example `type: 'numeric'` sets + * "renderer", "editor", "validator" properties to specific functions designed for numeric values. + * If "type" is passed as an object that object will be returned, excluding properties that + * already exist in the "metaObject" if passed. + * + * @param {object|string} type Type to expand;. + * @param {object|undefined} [metaObject] Source meta object. + * @returns {object|undefined} + */ + +function expandMetaType(type, metaObject) { + var validType = typeof type === 'string' ? _getItem$3(type) : type; + + if (!isObject$1(validType)) { + return; + } + + var preventSourceOverwrite = isObject$1(metaObject); + var expandedType = {}; + objectEach(validType, function (value, property) { + if (property !== 'CELL_TYPE' && (!preventSourceOverwrite || preventSourceOverwrite && !hasOwnProperty$1(metaObject, property))) { + expandedType[property] = value; + } + }); + return expandedType; +} +/** + * Creates new class which extends properties from TableMeta layer class. + * + * @param {TableMeta} TableMeta The TableMeta which the new ColumnMeta is created from. + * @param {string[]} [conflictList] List of the properties which are conflicted with the column meta layer. + * Conflicted properties are overwritten by `undefined` value, to separate them + * from the TableMeta layer. + * @returns {ColumnMeta} Returns constructor ready to initialize with `new` operator. + */ + +function columnFactory(TableMeta) { + var conflictList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + + // Do not use ES6 "class extends" syntax here. It seems that the babel produces code + // which drastically decreases the performance of the ColumnMeta class creation. + + /** + * Base "class" for column meta. + */ + function ColumnMeta() {} + + inherit(ColumnMeta, TableMeta); // Clear conflict settings + + for (var i = 0; i < conflictList.length; i++) { + ColumnMeta.prototype[conflictList[i]] = void 0; + } + + return ColumnMeta; +} +/** + * Helper which checks if the provided argument is an unsigned number. + * + * @param {*} value Value to check. + * @returns {boolean} + */ + +function isUnsignedNumber(value) { + return Number.isInteger(value) && value >= 0; +} +/** + * Function which makes assertion by custom condition. Function throws an error when assertion doesn't meet the spec. + * + * @param {Function} condition Function with custom logic. The condition has to return boolean values. + * @param {string} errorMessage String which describes assertion error. + */ + +function assert(condition, errorMessage) { + if (!condition()) { + throw new Error("Assertion failed: ".concat(errorMessage)); + } +} +/** + * Check if given variable is null or undefined. + * + * @param {*} variable Variable to check. + * @returns {boolean} + */ + +function isNullish(variable) { + return variable === null || variable === void 0; +} + +function _typeof$y(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$y = function _typeof(obj) { return typeof obj; }; } else { _typeof$y = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$y(obj); } +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @alias Options + * @class Options + * @description + * + * ## Constructor options. + * + * Constructor options are applied using an object literal passed as a second argument to the Handsontable constructor. + * + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: myArray, + * width: 400, + * height: 300 + * }); + * ``` + * + * --- + * ## Cascading configuration. + * + * Handsontable is using *Cascading Configuration*, which is a fast way to provide configuration options + * for the entire table, including its columns and particular cells. + * + * Consider the following example: + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * readOnly: true, + * columns: [ + * {readOnly: false}, + * {}, + * {}, + * ], + * cells: function(row, col, prop) { + * var cellProperties = {}; + * + * if (row === 0 && col === 0) { + * cellProperties.readOnly = true; + * }. + * + * return cellProperties; + * } + * }); + * ``` + * + * The above notation will result in all TDs being *read only*, except for first column TDs which will be *editable*, except for the TD in top left corner which will still be *read only*. + * + * ### The Cascading Configuration model + * + * ##### 1. Constructor + * + * Configuration options that are provided using first-level `handsontable(container, {option: "value"})` and `updateSettings` method. + * + * ##### 2. Columns + * + * Configuration options that are provided using second-level object `handsontable(container, {columns: {option: "value"}]})` + * + * ##### 3. Cells + * + * Configuration options that are provided using third-level function `handsontable(container, {cells: function: (row, col, prop){ }})` + * + * --- + * ## Architecture performance + * + * The Cascading Configuration model is based on prototypical inheritance. It is much faster and memory efficient + * compared to the previous model that used jQuery extend. See: [http://jsperf.com/extending-settings](http://jsperf.com/extending-settings). + * + * --- + * __Important notice:__ In order for the data separation to work properly, make sure that each instance of Handsontable has a unique `id`. + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var metaSchemaFactory = (function () { + return { + /** + * License key for commercial version of Handsontable. + * + * @memberof Options# + * @type {string} + * @default undefined + * @example + * ```js + * licenseKey: '00000-00000-00000-00000-00000', + * // or + * licenseKey: 'non-commercial-and-evaluation', + * ``` + */ + licenseKey: void 0, + + /** + * @description + * Initial data source that will be bound to the data grid __by reference__ (editing data grid alters the data source). + * Can be declared as an array of arrays or an array of objects. + * + * See [Understanding binding as reference](https://docs.handsontable.com/tutorial-data-binding.html#page-reference). + * + * @memberof Options# + * @type {Array[]|object[]} + * @default undefined + * @example + * ```js + * // as an array of arrays + * data: [ + * ['A', 'B', 'C'], + * ['D', 'E', 'F'], + * ['G', 'H', 'J'] + * ] + * + * // as an array of objects + * data: [ + * {id: 1, name: 'Ted Right'}, + * {id: 2, name: 'Frank Honest'}, + * {id: 3, name: 'Joan Well'}, + * {id: 4, name: 'Gail Polite'}, + * {id: 5, name: 'Michael Fair'}, + * ] + * ``` + */ + data: void 0, + + /** + * @description + * Defines the structure of a new row when data source is an array of objects. + * + * See [data-schema](https://docs.handsontable.com/tutorial-data-sources.html#page-data-schema) for more options. + * + * @memberof Options# + * @type {object} + * @default undefined + * + * @example + * ``` + * // with data schema we can start with an empty table + * data: null, + * dataSchema: {id: null, name: {first: null, last: null}, address: null}, + * colHeaders: ['ID', 'First Name', 'Last Name', 'Address'], + * columns: [ + * {data: 'id'}, + * {data: 'name.first'}, + * {data: 'name.last'}, + * {data: 'address'} + * ], + * startRows: 5, + * minSpareRows: 1 + * ``` + */ + dataSchema: void 0, + + /** + * Width of the grid. Can be a value or a function that returns a value. + * + * @memberof Options# + * @type {number|string|Function} + * @default undefined + * + * @example + * ``` + * // as a number + * width: 500, + * + * // as a string + * width: '75vw', + * + * // as a function + * width: function() { + * return 500; + * }, + * ``` + */ + width: void 0, + + /** + * Height of the grid. Can be a number or a function that returns a number. + * + * @memberof Options# + * @type {number|string|Function} + * @default undefined + * + * @example + * ```js + * // as a number + * height: 500, + * + * // as a string + * height: '75vh', + * + * // as a function + * height: function() { + * return 500; + * }, + * ``` + */ + height: void 0, + + /** + * @description + * Initial number of rows. + * + * __Note:__ This option only has effect in Handsontable constructor and only if `data` option is not provided. + * + * @memberof Options# + * @type {number} + * @default 5 + * + * @example + * ```js + * // start with 15 empty rows + * startRows: 15, + * ``` + */ + startRows: 5, + + /** + * @description + * Initial number of columns. + * + * __Note:__ This option only has effect in Handsontable constructor and only if `data` option is not provided. + * + * @memberof Options# + * @type {number} + * @default 5 + * + * @example + * ```js + * // start with 15 empty columns + * startCols: 15, + * ``` + */ + startCols: 5, + + /** + * Setting `true` or `false` will enable or disable the default row headers (1, 2, 3). + * You can also define an array `['One', 'Two', 'Three', ...]` or a function to define the headers. + * If a function is set the index of the row is passed as a parameter. + * + * @memberof Options# + * @type {boolean|string[]|Function} + * @default undefined + * + * @example + * ```js + * // as a boolean + * rowHeaders: true, + * + * // as an array + * rowHeaders: ['1', '2', '3'], + * + * // as a function + * rowHeaders: function(index) { + * return index + ': AB'; + * }, + * ``` + */ + rowHeaders: void 0, + + /** + * Setting `true` or `false` will enable or disable the default column headers (A, B, C). + * You can also define an array `['One', 'Two', 'Three', ...]` or a function to define the headers. + * If a function is set, then the index of the column is passed as a parameter. + * + * @memberof Options# + * @type {boolean|string[]|Function} + * @default null + * + * @example + * ```js + * // as a boolean + * colHeaders: true, + * + * // as an array + * colHeaders: ['A', 'B', 'C'], + * + * // as a function + * colHeaders: function(index) { + * return index + ': AB'; + * }, + * ``` + */ + colHeaders: null, + + /** + * Defines column widths in pixels. Accepts number, string (that will be converted to a number), array of numbers + * (if you want to define column width separately for each column) or a function (if you want to set column width + * dynamically on each render). + * + * @memberof Options# + * @type {number|number[]|string|string[]|Function} + * @default undefined + * + * @example + * ```js + * // as a number, for each column. + * colWidths: 100, + * + * // as a string, for each column. + * colWidths: '100px', + * + * // as an array, based on visual indexes. The rest of the columns have a default width. + * colWidths: [100, 120, 90], + * + * // as a function, based on visual indexes. + * colWidths: function(index) { + * return index * 10; + * }, + * ``` + */ + colWidths: void 0, + + /** + * Defines row heights in pixels. Accepts numbers, strings (that will be converted into a number), array of numbers + * (if you want to define row height separately for each row) or a function (if you want to set row height dynamically + * on each render). + * + * If the {@link ManualRowResize} or {@link AutoRowSize} plugins are enabled, this is also the minimum height that can + * be set via either of those two plugins. + * + * Height should be equal or greater than 23px. Table is rendered incorrectly if height is less than 23px. + * + * @memberof Options# + * @type {number|number[]|string|string[]|Function} + * @default undefined + * + * @example + * ```js + * // as a number, the same for all rows + * rowHeights: 100, + * + * // as a string, the same for all row + * rowHeights: '100px', + * + * // as an array, based on visual indexes. The rest of the rows have a default height + * rowHeights: [100, 120, 90], + * + * // as a function, based on visual indexes + * rowHeights: function(index) { + * return index * 10; + * }, + * ``` + */ + rowHeights: void 0, + + /** + * @description + * Defines the cell properties and data binding for certain columns. + * + * __Note:__ Using this option sets a fixed number of columns (options `startCols`, `minCols`, `maxCols` will be ignored). + * + * See [documentation -> datasources.html](https://docs.handsontable.com/tutorial-data-sources.html#page-nested) for examples. + * + * @memberof Options# + * @type {object[]|Function} + * @default undefined + * + * @example + * ```js + * // as an array of objects + * // order of the objects in array is representation of physical indexes. + * columns: [ + * { + * // column options for the first column + * type: 'numeric', + * numericFormat: { + * pattern: '0,0.00 $' + * } + * }, + * { + * // column options for the second column + * type: 'text', + * readOnly: true + * } + * ], + * + * // or as a function, based on physical indexes + * columns: function(index) { + * return { + * type: index > 0 ? 'numeric' : 'text', + * readOnly: index < 1 + * } + * } + * ``` + */ + columns: void 0, + + /** + * @description + * Defines the cell properties for given `row`, `col`, `prop` coordinates. Any constructor or column option may be + * overwritten for a particular cell (row/column combination) using the `cells` property in the Handsontable constructor. + * + * __Note:__ Parameters `row` and `col` always represent __physical indexes__. Example below show how to execute + * operations based on the __visual__ representation of Handsontable. + * + * Possible values of `prop`: + * - property name for column's data source object, when dataset is an [array of objects](https://handsontable.com/docs/tutorial-data-sources.html#page-object) + * - the same number as `col`, when dataset is an [array of arrays](https://handsontable.com/docs/tutorial-data-sources.html#page-array). + * + * @memberof Options# + * @type {Function} + * @default undefined + * + * @example + * ```js + * cells: function(row, column, prop) { + * const cellProperties = { readOnly: false }; + * const visualRowIndex = this.instance.toVisualRow(row); + * const visualColIndex = this.instance.toVisualColumn(column); + * + * if (visualRowIndex === 0 && visualColIndex === 0) { + * cellProperties.readOnly = true; + * } + * + * return cellProperties; + * }, + * ``` + */ + cells: void 0, + + /** + * Any constructor or column option may be overwritten for a particular cell (row/column combination), using `cell` + * array passed to the Handsontable constructor. + * + * @memberof Options# + * @type {Array[]} + * @default [] + * + * @example + * ```js + * // make cell with coordinates (0, 0) read only + * cell: [ + * { + * row: 0, + * col: 0, + * readOnly: true + * } + * ], + * ``` + */ + cell: [], + + /** + * @description + * If `true`, enables the {@link Comments} plugin, which enables an option to apply cell comments through the context menu + * (configurable with context menu keys `commentsAddEdit`, `commentsRemove`). + * + * To initialize Handsontable with predefined comments, provide cell coordinates and comment text values in a form of + * an array. + * + * See [Comments](https://docs.handsontable.com/demo-comments_.html) demo for examples. + * + * @memberof Options# + * @type {boolean|object[]} + * @default false + * + * @example + * ```js + * // enable comments plugin + * comments: true, + * + * // or an object with extra predefined plugin config: + * + * comments: { + * displayDelay: 1000 + * } + * + * // or + * // enable comments plugin and add predefined comments + * const hot = new Handsontable(document.getElementById('example'), { + * data: getData(), + * comments: true, + * cell: [ + * { row: 1, col: 1, comment: { value: 'Foo' } }, + * { row: 2, col: 2, comment: { value: 'Bar' } } + * ] + * }); + * ``` + */ + comments: false, + + /** + * @description + * If `true`, enables the {@link CustomBorders} plugin, which enables an option to apply custom borders through the context + * menu (configurable with context menu key `borders`). To initialize Handsontable with predefined custom borders, + * provide cell coordinates and border styles in a form of an array. + * + * See [Custom Borders](https://docs.handsontable.com/demo-custom-borders.html) demo for examples. + * + * @memberof Options# + * @type {boolean|object[]} + * @default false + * + * @example + * ```js + * // enable custom borders + * customBorders: true, + * + * // or + * // enable custom borders and start with predefined left border + * customBorders: [ + * { + * range: { + * from: { + * row: 1, + * col: 1 + * }, + * to: { + * row: 3, + * col: 4 + * } + * }, + * left: { + * width: 2, + * color: 'red' + * }, + * right: {}, + * top: {}, + * bottom: {} + * } + * ], + * + * // or + * customBorders: [ + * { + * row: 2, + * col: 2, + * left: { + * width: 2, + * color: 'red' + * }, + * right: { + * width: 1, + * color: 'green' + * }, + * top: '', + * bottom: '' + * } + * ], + * ``` + */ + customBorders: false, + + /** + * Minimum number of rows. At least that number of rows will be created during initialization. + * + * @memberof Options# + * @type {number} + * @default 0 + * + * @example + * ```js + * // set minimum table size to 10 rows + * minRows: 10, + * ``` + */ + minRows: 0, + + /** + * Minimum number of columns. At least that number of columns will be created during initialization. + * Works only with an array data source. When data source in an object, you can only have as many columns + * as defined in the first data row, data schema, or the `columns` setting. + * + * @memberof Options# + * @type {number} + * @default 0 + * + * @example + * ```js + * // set minimum table size to 10 columns + * minCols: 10, + * ``` + */ + minCols: 0, + + /** + * Maximum number of rows. If set to a value lower than the initial row count, the data will be trimmed to the provided + * value as the number of rows. + * + * @memberof Options# + * @type {number} + * @default Infinity + * + * @example + * ```js + * // limit table size to maximum 300 rows + * maxRows: 300, + * ``` + */ + maxRows: Infinity, + + /** + * Maximum number of cols. If set to a value lower than the initial col count, the data will be trimmed to the provided + * value as the number of cols. + * + * @memberof Options# + * @type {number} + * @default Infinity + * + * @example + * ```js + * // limit table size to maximum 300 columns + * maxCols: 300, + * ``` + */ + maxCols: Infinity, + + /** + * When set to 1 (or more), Handsontable will add a new row at the end of grid if there are no more empty rows. + * (unless the number of rows exceeds the one set in the `maxRows` property). + * + * @memberof Options# + * @type {number} + * @default 0 + * + * @example + * ```js + * // always add 3 empty rows at the table end + * minSpareRows: 3, + * ``` + */ + minSpareRows: 0, + + /** + * When set to 1 (or more), Handsontable will add a new column at the end of grid if there are no more empty columns. + * (unless the number of rows exceeds the one set in the `maxCols` property). + * + * @memberof Options# + * @type {number} + * @default 0 + * + * @example + * ```js + * // always add 3 empty columns at the table end + * minSpareCols: 3, + * ``` + */ + minSpareCols: 0, + + /** + * If set to `false`, there won't be an option to insert new rows in the Context Menu. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // hide "Insert row above" and "Insert row below" options from the Context Menu + * allowInsertRow: false, + * ``` + */ + allowInsertRow: true, + + /** + * If set to `false`, there won't be an option to insert new columns in the Context Menu. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // hide "Insert column left" and "Insert column right" options from the Context Menu + * allowInsertColumn: false, + * ``` + */ + allowInsertColumn: true, + + /** + * If set to `false`, there won't be an option to remove rows in the Context Menu. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // hide "Remove row" option from the Context Menu + * allowRemoveRow: false, + * ``` + */ + allowRemoveRow: true, + + /** + * If set to `false`, there won't be an option to remove columns in the Context Menu. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // hide "Remove column" option from the Context Menu + * allowRemoveColumn: false, + * ``` + */ + allowRemoveColumn: true, + + /** + * @description + * Defines how the table selection reacts. The selection support three different behaviors defined as: + * * `'single'` Only a single cell can be selected. + * * `'range'` Multiple cells within a single range can be selected. + * * `'multiple'` Multiple ranges of cells can be selected. + * + * To see how to interact with selection by getting selected data or change styles of the selected cells go to + * [https://docs.handsontable.com/demo-selecting-ranges.html](https://docs.handsontable.com/demo-selecting-ranges.html). + * + * @memberof Options# + * @type {string} + * @default 'multiple' + * + * @example + * ```js + * // only one cell can be selected at a time + * selectionMode: 'single', + * ``` + */ + selectionMode: 'multiple', + + /** + * Enables the fill handle (drag-down and copy-down) functionality, which shows a small rectangle in bottom + * right corner of the selected area, that let's you expand values to the adjacent cells. + * + * Setting to `true` enables the fillHandle plugin. Possible values: `true` (to enable in all directions), + * `'vertical'` or `'horizontal'` (to enable in one direction), `false` (to disable completely), an object with + * options: `autoInsertRow`, `direction`. + * + * If `autoInsertRow` option is `true`, fill-handler will create new rows till it reaches the last row. + * It is enabled by default. + * + * @memberof Options# + * @type {boolean|string|object} + * @default true + * + * @example + * ```js + * // enable plugin in all directions and with autoInsertRow as true + * fillHandle: true, + * + * // or + * // enable plugin in vertical direction and with autoInsertRow as true + * fillHandle: 'vertical', + * + * // or + * fillHandle: { + * // enable plugin in both directions and with autoInsertRow as false + * autoInsertRow: false, + * }, + * + * // or + * fillHandle: { + * // enable plugin in vertical direction and with autoInsertRow as false + * autoInsertRow: false, + * direction: 'vertical' + * }, + * ``` + */ + fillHandle: { + autoInsertRow: false + }, + + /** + * Allows to specify the number of fixed (or *frozen*) rows at the top of the table. + * + * @memberof Options# + * @type {number} + * @default 0 + * + * @example + * ```js + * // freeze the first 3 rows of the table. + * fixedRowsTop: 3, + * ``` + */ + fixedRowsTop: 0, + + /** + * Allows to specify the number of fixed (or *frozen*) rows at the bottom of the table. + * + * @memberof Options# + * @type {number} + * @default 0 + * + * @example + * ```js + * // freeze the last 3 rows of the table. + * fixedRowsBottom: 3, + * ``` + */ + fixedRowsBottom: 0, + + /** + * Allows to specify the number of fixed (or *frozen*) columns on the left of the table. + * + * @memberof Options# + * @type {number} + * @default 0 + * + * @example + * ```js + * // freeze first 3 columns of the table. + * fixedColumnsLeft: 3, + * ``` + */ + fixedColumnsLeft: 0, + + /** + * If `true`, mouse click outside the grid will deselect the current selection. Can be a function that takes the + * click event target and returns a boolean. + * + * @memberof Options# + * @type {boolean|Function} + * @default true + * + * @example + * ```js + * // don't clear current selection when mouse click was outside the grid + * outsideClickDeselects: false, + * + * // or + * outsideClickDeselects: function(event) { + * return false; + * } + * ``` + */ + outsideClickDeselects: true, + + /** + * If `true`, ENTER begins editing mode (like in Google Docs). If `false`, ENTER moves to next + * row (like Excel) and adds a new row if necessary. TAB adds new column if necessary. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * enterBeginsEditing: false, + * ``` + */ + enterBeginsEditing: true, + + /** + * Defines the cursor movement after ENTER was pressed (SHIFT + ENTER uses a negative vector). Can + * be an object or a function that returns an object. The event argument passed to the function is a DOM Event object + * received after the ENTER key has been pressed. This event object can be used to check whether user pressed + * ENTER or SHIFT + ENTER. + * + * @memberof Options# + * @type {object|Function} + * @default {col: 0, row: 1} + * + * @example + * ```js + * // move selection diagonal by 1 cell in x and y axis + * enterMoves: {col: 1, row: 1}, + * // or as a function + * enterMoves: function(event) { + * return {col: 1, row: 1}; + * }, + * ``` + */ + enterMoves: { + col: 0, + row: 1 + }, + + /** + * Defines the cursor movement after TAB is pressed (SHIFT + TAB uses a negative vector). Can + * be an object or a function that returns an object. The event argument passed to the function is a DOM Event object + * received after the TAB key has been pressed. This event object can be used to check whether user pressed + * TAB or SHIFT + TAB. + * + * @memberof Options# + * @type {object|Function} + * @default {row: 0, col: 1} + * + * @example + * ```js + * // move selection 2 cells away after TAB pressed. + * tabMoves: {row: 2, col: 2}, + * // or as a function + * tabMoves: function(event) { + * return {row: 2, col: 2}; + * }, + * ``` + */ + tabMoves: { + row: 0, + col: 1 + }, + + /** + * If `true`, pressing TAB or right arrow in the last column will move to first column in next row. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // stop TAB key navigation on the last column + * autoWrapRow: false, + * ``` + */ + autoWrapRow: true, + + /** + * If `true`, pressing ENTER or down arrow in the last row will move to the first row in the next column. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // stop ENTER key navigation on the last row + * autoWrapCol: false, + * ``` + */ + autoWrapCol: true, + + /** + * @description + * Turns on saving the state of column sorting, column positions and column sizes in local storage. + * + * You can save any sort of data in local storage to preserve table state between page reloads. In order to enable + * data storage mechanism, `persistentState` option must be set to `true` (you can set it either during Handsontable + * initialization or using the `updateSettings` method). When `persistentState` is enabled it exposes 3 hooks: + * + * __persistentStateSave__ (key: String, value: Mixed). + * + * * Saves value under given key in browser local storage. + * + * __persistentStateLoad__ (key: String, valuePlaceholder: Object). + * + * * Loads `value`, saved under given key, form browser local storage. The loaded `value` will be saved in + * `valuePlaceholder.value` (this is due to specific behaviour of `Hooks.run()` method). If no value have + * been saved under key `valuePlaceholder.value` will be `undefined`. + * + * __persistentStateReset__ (key: String). + * + * * Clears the value saved under `key`. If no `key` is given, all values associated with table will be cleared. + * + * __Note:__ The main reason behind using `persistentState` hooks rather than regular LocalStorage API is that it + * ensures separation of data stored by multiple Handsontable instances. In other words, if you have two (or more) + * instances of Handsontable on one page, data saved by one instance won't be accessible by the second instance. + * Those two instances can store data under the same key and no data would be overwritten. + * + * __Important:__ In order for the data separation to work properly, make sure that each instance of Handsontable has a unique `id`. + * + * @memberof Options# + * @type {boolean} + * @default false + * + * @example + * ```js + * // enable the persistent state plugin + * persistentState: true, + * ``` + */ + persistentState: void 0, + + /** + * Class name for all visible rows in the current selection. + * + * @memberof Options# + * @type {string} + * @default undefined + * + * @example + * ```js + * // This will add a 'currentRow' class name to appropriate table cells. + * currentRowClassName: 'currentRow', + * ``` + */ + currentRowClassName: void 0, + + /** + * Class name for all visible columns in the current selection. + * + * @memberof Options# + * @type {string} + * @default undefined + * + * @example + * ```js + * // This will add a 'currentColumn' class name to appropriate table cells. + * currentColClassName: 'currentColumn', + * ``` + */ + currentColClassName: void 0, + + /** + * Class name for all visible headers in current selection. + * + * @memberof Options# + * @type {string} + * @default 'ht__highlight' + * + * @example + * ```js + * // This will add a 'ht__highlight' class name to appropriate table headers. + * currentHeaderClassName: 'ht__highlight', + * ``` + */ + currentHeaderClassName: 'ht__highlight', + + /** + * Class name for all active headers in selections. The header will be marked with this class name + * only when a whole column or row will be selected. + * + * @memberof Options# + * @type {string} + * @since 0.38.2 + * @default 'ht__active_highlight' + * + * @example + * ```js + * // this will add a 'ht__active_highlight' class name to appropriate table headers. + * activeHeaderClassName: 'ht__active_highlight', + * ``` + */ + activeHeaderClassName: 'ht__active_highlight', + + /** + * Class name for the current element. + * The interpretation depends on the level on which this option is provided in the [cascading configuration](https://handsontable.com/docs/Options.html). + * If `className` is provided on the first (constructor) level, it is the applied to the Handsontable container. + * If `className` is provided on the second (`column`) or the third (`cell` or `cells`) level, it is applied to the table cell. + * + * @memberof Options# + * @type {string|string[]} + * @default undefined + * + * @example + * ```js + * // can be set as a string + * className: 'your__class--name', + * + * // or as an array of strings + * className: ['first-class-name', 'second-class-name'], + * ``` + */ + className: void 0, + + /** + * Class name for all tables inside container element. + * + * @memberof Options# + * @type {string|string[]} + * @default undefined + * + * @example + * ```js + * // set custom class for table element + * tableClassName: 'your__class--name', + * + * // or + * tableClassName: ['first-class-name', 'second-class-name'], + * ``` + */ + tableClassName: void 0, + + /** + * @description + * Defines how the columns react, when the declared table width is different than the calculated sum of all column widths. + * [See more](https://docs.handsontable.com/demo-stretching.html) mode. Possible values: + * * `'none'` Disable stretching + * * `'last'` Stretch only the last column + * * `'all'` Stretch all the columns evenly. + * + * @memberof Options# + * @type {string} + * @default 'none' + * + * @example + * ```js + * // fit table to the container + * stretchH: 'all', + * ``` + */ + stretchH: 'none', + + /** + * Overwrites the default `isEmptyRow` method, which checks if row at the provided index is empty. + * + * @memberof Options# + * @type {Function} + * @param {number} row Visual row index. + * @returns {boolean} + * + * @example + * ```js + * // define custom checks for empty row + * isEmptyRow: function(row) { + * ... + * }, + * ``` + */ + isEmptyRow: function isEmptyRow(row) { + var col; + var colLen; + var value; + var meta; + + for (col = 0, colLen = this.countCols(); col < colLen; col++) { + value = this.getDataAtCell(row, col); + + if (value !== '' && value !== null && isDefined(value)) { + if (_typeof$y(value) === 'object') { + meta = this.getCellMeta(row, col); + return isObjectEqual(this.getSchema()[meta.prop], value); + } + + return false; + } + } + + return true; + }, + + /** + * Overwrites the default `isEmptyCol` method, which checks if column at the provided index is empty. + * + * @memberof Options# + * @type {Function} + * @param {number} col Visual column index. + * @returns {boolean} + * + * @example + * ```js + * // define custom checks for empty column + * isEmptyCol: function(column) { + * return false; + * }, + * ``` + */ + isEmptyCol: function isEmptyCol(col) { + var row; + var rowLen; + var value; + + for (row = 0, rowLen = this.countRows(); row < rowLen; row++) { + value = this.getDataAtCell(row, col); + + if (value !== '' && value !== null && isDefined(value)) { + return false; + } + } + + return true; + }, + + /** + * When set to `true`, the table is re-rendered when it is detected that it was made visible in DOM. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // don't rerender the table on visibility changes + * observeDOMVisibility: false, + * ``` + */ + observeDOMVisibility: true, + + /** + * If set to `true`, Handsontable will accept values that were marked as invalid by the cell `validator`. It will + * result with *invalid* cells being treated as *valid* (will save the *invalid* value into the Handsontable data source). + * If set to `false`, Handsontable will *not* accept the invalid values and won't allow the user to close the editor. + * This option will be particularly useful when used with the Autocomplete's `strict` mode. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // don't save the invalid values + * allowInvalid: false, + * ``` + */ + allowInvalid: true, + + /** + * If set to `true`, Handsontable will accept values that are empty (`null`, `undefined` or `''`). If set + * to `false`, Handsontable will *not* accept the empty values and mark cell as invalid. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // allow empty values for all cells (whole table) + * allowEmpty: true, + * + * // or + * columns: [ + * { + * data: 'date', + * dateFormat: 'DD/MM/YYYY', + * // allow empty values only for the 'date' column + * allowEmpty: true + * } + * ], + * ``` + */ + allowEmpty: true, + + /** + * CSS class name for cells that did not pass validation. + * + * @memberof Options# + * @type {string} + * @default 'htInvalid' + * + * @example + * ```js + * // set custom validation error class + * invalidCellClassName: 'highlight--error', + * ``` + */ + invalidCellClassName: 'htInvalid', + + /** + * When set to an non-empty string, displayed as the cell content for empty cells. If a value of a different type is provided, + * it will be stringified and applied as a string. + * + * @memberof Options# + * @type {string} + * @default undefined + * + * @example + * ```js + * // add custom placeholder content to empty cells + * placeholder: 'Empty Cell', + * ``` + */ + placeholder: void 0, + + /** + * CSS class name for cells that have a placeholder in use. + * + * @memberof Options# + * @type {string} + * @default 'htPlaceholder' + * + * @example + * ```js + * // set custom placeholder class + * placeholderCellClassName: 'has-placeholder', + * ``` + */ + placeholderCellClassName: 'htPlaceholder', + + /** + * CSS class name for read-only cells. + * + * @memberof Options# + * @type {string} + * @default 'htDimmed' + * + * @example + * ```js + * // set custom read-only class + * readOnlyCellClassName: 'is-readOnly', + * ``` + */ + readOnlyCellClassName: 'htDimmed', + + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * @description + * If a string is provided, it may be one of the following predefined values: + * * `autocomplete`, + * * `checkbox`, + * * `html`, + * * `numeric`, + * * `password`. + * * `text`. + * + * Or you can [register](https://docs.handsontable.com/demo-custom-renderers.html) the custom renderer under specified name and use its name as an alias in your + * configuration. + * + * If a function is provided, it will receive the following arguments: + * ```js + * function(instance, TD, row, col, prop, value, cellProperties) {} + * ``` + * + * You can read more about custom renderes [in the documentation](https://docs.handsontable.com/demo-custom-renderers.html). + * + * @memberof Options# + * @type {string|Function} + * @default undefined + * + * @example + * ```js + * // register custom renderer + * Handsontable.renderers.registerRenderer('my.renderer', function(instance, TD, row, col, prop, value, cellProperties) { + * TD.innerHTML = value; + * }); + * + * // use it for selected column: + * columns: [ + * { + * // as a string with the name of build in renderer + * renderer: 'autocomplete', + * editor: 'select' + * }, + * { + * // as an alias to custom renderer registered above + * renderer: 'my.renderer' + * }, + * { + * // renderer as custom function + * renderer: function(hotInstance, TD, row, col, prop, value, cellProperties) { + * TD.style.color = 'blue'; + * TD.innerHTML = value; + * } + * } + * ], + * ``` + */ + renderer: void 0, + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + /** + * CSS class name added to the commented cells. + * + * @memberof Options# + * @type {string} + * @default 'htCommentCell' + * + * @example + * ```js + * // set custom class for commented cells + * commentedCellClassName: 'has-comment', + * ``` + */ + commentedCellClassName: 'htCommentCell', + + /** + * If set to `true`, it enables the browser's native selection of a fragment of the text within a single cell, between + * adjacent cells or in a whole table. If set to `'cell'`, it enables the possibility of selecting a fragment of the + * text within a single cell's body. + * + * @memberof Options# + * @type {boolean|string} + * @default false + * + * @example + * ```js + * // enable text selection within table + * fragmentSelection: true, + * + * // or + * // enable text selection within cells only + * fragmentSelection: 'cell', + * ``` + */ + fragmentSelection: false, + + /** + * @description + * Makes cell, column or comment [read only](https://docs.handsontable.com/demo-read-only.html). + * + * @memberof Options# + * @type {boolean} + * @default false + * + * @example + * ```js + * // set as read only + * readOnly: true, + * ``` + */ + readOnly: false, + + /** + * @description + * When added to a `column` property, it skips the column on paste and pastes the data on the next column to the right. + * + * @memberof Options# + * @type {boolean} + * @default false + * + * @example + * ```js + * columns: [ + * { + * // don't paste data to this column + * skipColumnOnPaste: true + * } + * ], + * ``` + */ + skipColumnOnPaste: false, + + /** + * @description + * When added to a cell property, it skips the row on paste and pastes the data on the following row. + * + * @memberof Options# + * @type {boolean} + * @default false + * + * @example + * ```js + * cells: function(row, column) { + * const cellProperties = {}; + * + * // don't paste data to the second row + * if (row === 1) { + * cellProperties.skipRowOnPaste = true; + * } + * + * return cellProperties; + * } + * ``` + */ + skipRowOnPaste: false, + + /** + * @description + * Setting to `true` enables the {@link Search} plugin (see [demo](https://docs.handsontable.com/demo-search-for-values.html)). + * + * @memberof Options# + * @type {boolean} + * @default false + * + * @example + * ```js + * // enable search plugin + * search: true, + * + * // or + * // as an object with detailed configuration + * search: { + * searchResultClass: 'customClass', + * queryMethod: function(queryStr, value) { + * ... + * }, + * callback: function(instance, row, column, value, result) { + * ... + * } + * } + * ``` + */ + search: false, + + /** + * @description + * Shortcut to define the combination of the cell renderer, editor and validator for the column, cell or whole table. + * + * Possible values: + * * [autocomplete](https://docs.handsontable.com/demo-autocomplete.html) + * * [checkbox](https://docs.handsontable.com/demo-checkbox.html) + * * [date](https://docs.handsontable.com/demo-date.html) + * * [dropdown](https://docs.handsontable.com/demo-dropdown.html) + * * [handsontable](https://docs.handsontable.com/demo-handsontable.html) + * * [numeric](https://docs.handsontable.com/demo-numeric.html) + * * [password](https://docs.handsontable.com/demo-password.html) + * * text + * * [time](https://docs.handsontable.com/demo-time.html). + * + * Or you can register the custom cell type under specified name and use + * its name as an alias in your configuration. + * + * @memberof Options# + * @type {string} + * @default 'text' + * + * @example + * ```js + * // register custom cell type: + * Handsontable.cellTypes.registerCellType('my.type', { + * editor: MyEditorClass, + * renderer: function(hot, td, row, col, prop, value, cellProperties) { + * td.innerHTML = value; + * }, + * validator: function(value, callback) { + * callback(value === 'foo' ? true : false); + * } + * }); + * + * // use it in column settings: + * columns: [ + * { + * type: 'text' + * }, + * { + * // an alias to custom type + * type: 'my.type' + * }, + * { + * type: 'checkbox' + * } + * ], + * ``` + */ + type: 'text', + + /** + * @description + * Makes a cell copyable (pressing CTRL + C on your keyboard moves its value to system clipboard). + * + * __Note:__ this setting is `false` by default for cells with type `password`. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * cells: [ + * { + * cell: 0, + * row: 0, + * // cell with coordinates (0, 0) can't be copied + * copyable: false, + * } + * ], + * ``` + */ + copyable: true, + + /** + * Defines the editor for the table/column/cell. + * + * If a string is provided, it may be one of the following predefined values: + * * [autocomplete](https://docs.handsontable.com/demo-autocomplete.html) + * * [checkbox](https://docs.handsontable.com/demo-checkbox.html) + * * [date](https://docs.handsontable.com/demo-date.html) + * * [dropdown](https://docs.handsontable.com/demo-dropdown.html) + * * [handsontable](https://docs.handsontable.com/demo-handsontable.html) + * * [mobile](https://docs.handsontable.com/demo-mobiles-and-tablets.html) + * * [password](https://docs.handsontable.com/demo-password.html) + * * [select](https://docs.handsontable.com/demo-select.html) + * * text. + * + * Or you can [register](https://docs.handsontable.com/tutorial-cell-editor.html#registering-an-editor) the custom editor under specified name and use its name as an alias in your + * configuration. + * + * To disable cell editing completely set `editor` property to `false`. + * + * @memberof Options# + * @type {string|Function|boolean} + * @default undefined + * + * @example + * ```js + * columns: [ + * { + * // set editor for the first column + * editor: 'select' + * }, + * { + * // disable editor for the second column + * editor: false + * } + * ], + * ``` + */ + editor: void 0, + + /** + * Control number of choices for the autocomplete (or dropdown) typed cells. After exceeding it, a scrollbar for the + * dropdown list of choices will appear. + * + * @memberof Options# + * @type {number} + * @default 10 + * + * @example + * ```js + * columns: [ + * { + * type: 'autocomplete', + * // set autocomplete options list height + * visibleRows: 15, + * } + * ], + * ``` + */ + visibleRows: 10, + + /** + * Makes autocomplete or dropdown width the same as the edited cell width. If `false` then editor will be scaled + * according to its content. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * columns: [ + * { + * type: 'autocomplete', + * // don't trim dropdown width with column width + * trimDropdown: false, + * } + * ], + * ``` + */ + trimDropdown: true, + + /** + * When set to `true`, the text of the cell content is wrapped if it does not fit in the fixed column width. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * colWidths: 100, + * columns: [ + * { + * // fixed column width is set but don't wrap the content + * wordWrap: false, + * } + * ], + * ``` + */ + wordWrap: true, + + /** + * CSS class name added to cells with cell meta `wordWrap: false`. + * + * @memberof Options# + * @type {string} + * @default 'htNoWrap' + * + * @example + * ```js + * // set custom class for cells which content won't be wrapped + * noWordWrapClassName: 'is-noWrapCell', + * ``` + */ + noWordWrapClassName: 'htNoWrap', + + /** + * @description + * Defines if the right-click context menu should be enabled. Context menu allows to create new row or column at any + * place in the grid among [other features](https://docs.handsontable.com/demo-context-menu.html). + * Possible values: + * * `true` (to enable default options), + * * `false` (to disable completely) + * * an array of [predefined options](https://docs.handsontable.com/demo-context-menu.html#page-specific), + * * an object [with defined structure](https://docs.handsontable.com/demo-context-menu.html#page-custom). + * + * If the value is an object, you can also customize the options with: + * * `disableSelection` - a `boolean`, if set to true it prevents mouseover from highlighting the item for selection + * * `isCommand` - a `boolean`, if set to false it prevents clicks from executing the command and closing the menu. + * + * See [the context menu demo](https://docs.handsontable.com/demo-context-menu.html) for examples. + * + * @memberof Options# + * @type {boolean|string[]|object} + * @default undefined + * + * @example + * ```js + * // as a boolean + * contextMenu: true, + * + * // as an array + * contextMenu: ['row_above', 'row_below', '---------', 'undo', 'redo'], + * + * // as an object (`name` attribute is required in the custom keys) + * contextMenu: { + * items: { + * "option1": { + * name: "option1" + * }, + * "option2": { + * name: "option2", + * submenu: { + * items: [ + * { + * key: "option2:suboption1", + * name: "option2:suboption1", + * callback: function(key, options) { + * ... + * } + * }, + * ... + * ] + * } + * } + * } + * }, + * ``` + */ + contextMenu: void 0, + + /** + * Disables or enables the copy/paste functionality. + * + * @memberof Options# + * @type {object|boolean} + * @default true + * + * @example + * ```js + * // disable copy and paste + * copyPaste: false, + * + * // enable copy and paste with custom configuration + * copyPaste: { + * columnsLimit: 25, + * rowsLimit: 50, + * pasteMode: 'shift_down', + * uiContainer: document.body, + * }, + * ``` + */ + copyPaste: true, + + /** + * If `true`, undo/redo functionality is enabled. + * Note: `undefined` by default but it acts as enabled. + * You need to switch it to `false` to disable it completely. + * + * @memberof Options# + * @type {boolean} + * @default undefined + * + * @example + * ```js + * // enable undo and redo + * undo: true, + * ``` + */ + undo: void 0, + + /** + * @description + * Turns on [Column sorting](https://docs.handsontable.com/demo-sorting-data.html). Can be either a boolean (`true` / `false`) or an object with a declared sorting options: + * * `initialConfig` - Object with predefined keys: + * * `column` - sorted column + * * `sortOrder` - order in which column will be sorted + * * `'asc'` = ascending + * * `'desc'` = descending + * * `indicator` - display status for sorting order indicator (an arrow icon in the column header, specifying the sorting order). + * * `true` = show sort indicator for sorted columns + * * `false` = don't show sort indicator for sorted columns + * * `headerAction` - allow to click on the headers to sort + * * `true` = turn on possibility to click on the headers to sort + * * `false` = turn off possibility to click on the headers to sort + * * `sortEmptyCells` - how empty values should be handled + * * `true` = the table sorts empty cells + * * `false` = the table moves all empty cells to the end of the table + * * `compareFunctionFactory` - curry function returning compare function; compare function should work in the same way as function which is handled by native `Array.sort` method); please take a look at below examples for more information. + * + * @memberof Options# + * @type {boolean|object} + * @default undefined + * + * @example + * ```js + * // as boolean + * columnSorting: true + * + * // as an object with initial sort config (sort ascending for column at index 1) + * columnSorting: { + * initialConfig: { + * column: 1, + * sortOrder: 'asc' + * } + * } + * + * // as an object which define specific sorting options for all columns + * columnSorting: { + * sortEmptyCells: true, // true = the table sorts empty cells, false = the table moves all empty cells to the end of the table + * indicator: true, // true = shows indicator for all columns, false = don't show indicator for columns + * headerAction: false, // true = allow to click on the headers to sort, false = turn off possibility to click on the headers to sort + * compareFunctionFactory: function(sortOrder, columnMeta) { + * return function(value, nextValue) { + * // Some value comparisons which will return -1, 0 or 1... + * } + * } + * }``` + */ + columnSorting: void 0, + + /** + * Turns on [Manual column move](https://docs.handsontable.com/demo-moving-rows-and-columns.html), if set to a boolean or define initial column order (as an array of column indexes). + * + * @memberof Options# + * @type {boolean|number[]} + * @default undefined + * + * @example + * ```js + * // as a boolean to enable column move + * manualColumnMove: true, + * + * // as a array with initial order + * // (move column index at 0 to 1 and move column index at 1 to 4) + * manualColumnMove: [1, 4], + * ``` + */ + manualColumnMove: void 0, + + /** + * @description + * Turns on [Manual column resize](https://docs.handsontable.com/demo-resizing.html), if set to a boolean or define initial column resized widths (an an array of widths). + * + * @memberof Options# + * @type {boolean|number[]} + * @default undefined + * + * @example + * ```js + * // as a boolean to enable column resize + * manualColumnResize: true, + * + * // as a array with initial widths + * // (column at 0 index has 40px and column at 1 index has 50px) + * manualColumnResize: [40, 50], + * ``` + */ + manualColumnResize: void 0, + + /** + * @description + * Turns on [Manual row move](https://docs.handsontable.com/demo-moving-rows-and-columns.html), if set to a boolean or define initial row order (as an array of row indexes). + * + * @memberof Options# + * @type {boolean|number[]} + * @default undefined + * + * @example + * ```js + * // as a boolean + * manualRowMove: true, + * + * // as a array with initial order + * // (move row index at 0 to 1 and move row index at 1 to 4) + * manualRowMove: [1, 4], + * ``` + */ + manualRowMove: void 0, + + /** + * @description + * Turns on [Manual row resize](https://docs.handsontable.com/demo-resizing.html), if set to a boolean or define initial row resized heights (as an array of heights). + * + * @memberof Options# + * @type {boolean|number[]} + * @default undefined + * + * @example + * ```js + * // as a boolean to enable row resize + * manualRowResize: true, + * + * // as an array to set initial heights + * // (row at 0 index has 40px and row at 1 index has 50px) + * manualRowResize: [40, 50], + * ``` + */ + manualRowResize: void 0, + + /** + * @description + * If set to `true`, it enables a possibility to merge cells. If set to an array of objects, it merges the cells provided + * in the objects (see the example below). More information on [the demo page](https://docs.handsontable.com/demo-merge-cells.html). + * + * @memberof Options# + * @type {boolean|object[]} + * @default false + * + * @example + * ```js + * // enables the mergeCells plugin + * margeCells: true, + * + * // declares a list of merged sections + * mergeCells: [ + * // rowspan and colspan properties declare the width and height of a merged section in cells + * {row: 1, col: 1, rowspan: 3, colspan: 3}, + * {row: 3, col: 4, rowspan: 2, colspan: 2}, + * {row: 5, col: 6, rowspan: 3, colspan: 3} + * ], + * ``` + */ + mergeCells: false, + + /** + * @description + * Turns on [Multi-column sorting](https://docs.handsontable.com/demo-multicolumn-sorting.html). Can be either a boolean (`true` / `false`) or an object with a declared sorting options: + * * `initialConfig` - Array containing objects, every with predefined keys: + * * `column` - sorted column + * * `sortOrder` - order in which column will be sorted + * * `'asc'` = ascending + * * `'desc'` = descending + * * `indicator` - display status for sorting order indicator (an arrow icon in the column header, specifying the sorting order). + * * `true` = show sort indicator for sorted columns + * * `false` = don't show sort indicator for sorted columns + * * `headerAction` - allow to click on the headers to sort + * * `true` = turn on possibility to click on the headers to sort + * * `false` = turn off possibility to click on the headers to sort + * * `sortEmptyCells` - how empty values should be handled + * * `true` = the table sorts empty cells + * * `false` = the table moves all empty cells to the end of the table + * * `compareFunctionFactory` - curry function returning compare function; compare function should work in the same way as function which is handled by native `Array.sort` method); please take a look at below examples for more information. + * + * @memberof Options# + * @type {boolean|object} + * @default undefined + * + * @example + * ```js + * // as boolean + * multiColumnSorting: true + * + * // as an object with initial sort config (sort ascending for column at index 1 and then sort descending for column at index 0) + * multiColumnSorting: { + * initialConfig: [{ + * column: 1, + * sortOrder: 'asc' + * }, { + * column: 0, + * sortOrder: 'desc' + * }] + * } + * + * // as an object which define specific sorting options for all columns + * multiColumnSorting: { + * sortEmptyCells: true, // true = the table sorts empty cells, false = the table moves all empty cells to the end of the table + * indicator: true, // true = shows indicator for all columns, false = don't show indicator for columns + * headerAction: false, // true = allow to click on the headers to sort, false = turn off possibility to click on the headers to sort + * compareFunctionFactory: function(sortOrder, columnMeta) { + * return function(value, nextValue) { + * // Some value comparisons which will return -1, 0 or 1... + * } + * } + * }``` + */ + multiColumnSorting: void 0, + + /** + * @description + * Number of rows to be rendered outside of the visible part of the table. By default, it's set to `'auto'`, which + * makes Handsontable to attempt to calculate the best offset performance-wise. + * + * You may test out different values to find the best one that works for your specific implementation. + * + * @memberof Options# + * @type {number|string} + * @default 'auto' + * + * @example + * ```js + * viewportRowRenderingOffset: 70, + * ``` + */ + viewportRowRenderingOffset: 'auto', + + /** + * @description + * Number of columns to be rendered outside of the visible part of the table. By default, it's set to `'auto'`, which + * makes Handsontable try calculating the best offset performance-wise. + * + * You may experiment with the value to find the one that works best for your specific implementation. + * + * @memberof Options# + * @type {number|string} + * @default 'auto' + * + * @example + * ```js + * viewportColumnRenderingOffset: 70, + * ``` + */ + viewportColumnRenderingOffset: 'auto', + + /** + * @description + * A function, regular expression or a string, which will be used in the process of cell validation. If a function is + * used, be sure to execute the callback argument with either `true` (`callback(true)`) if the validation passed + * or with `false` (`callback(false)`), if the validation failed. + * + * __Note__, that `this` in the function points to the `cellProperties` object. + * + * If a string is provided, it may be one of the following predefined values: + * * `autocomplete`, + * * `date`, + * * `numeric`, + * * `time`. + * + * Or you can [register](https://docs.handsontable.com/demo-data-validation.html) the validator function under specified name and use its name as an alias in your + * configuration. + * + * See more [in the demo](https://docs.handsontable.com/demo-data-validation.html). + * + * @memberof Options# + * @type {Function|RegExp|string} + * @default undefined + * + * @example + * ```js + * columns: [ + * { + * // as a function + * validator: function(value, callback) { + * ... + * } + * }, + * { + * // regular expression + * validator: /^[0-9]$/ + * }, + * { + * // as a string + * validator: 'numeric' + * } + * ], + * ``` + */ + validator: void 0, + + /** + * @description + * Disables visual cells selection. + * + * Possible values: + * * `true` - Disables any type of visual selection (current and area selection), + * * `false` - Enables any type of visual selection. This is default value. + * * `'current'` - Disables the selection of a currently selected cell, the area selection is still present. + * * `'area'` - Disables the area selection, the currently selected cell selection is still present. + * * `'header'` - Disables the headers selection, the currently selected cell selection is still present. + * + * @memberof Options# + * @type {boolean|string|string[]} + * @default false + * + * @example + * ```js + * // as a boolean + * disableVisualSelection: true, + * + * // as a string ('current', 'area' or 'header') + * disableVisualSelection: 'current', + * + * // as an array + * disableVisualSelection: ['current', 'area'], + * ``` + */ + disableVisualSelection: false, + + /** + * Disables or enables {@link ManualColumnFreeze} plugin. + * + * @memberof Options# + * @type {boolean} + * @default undefined + * + * @example + * ```js + * // enable fixed columns + * manualColumnFreeze: true, + * ``` + */ + manualColumnFreeze: void 0, + + /** + * Defines whether Handsontable should trim the whitespace at the beginning and the end of the cell contents. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * columns: [ + * { + * // don't remove whitespace + * trimWhitespace: false + * } + * ] + * ``` + */ + trimWhitespace: true, + + /** + * Defines data source for Autocomplete or Dropdown cell types. + * + * @memberof Options# + * @type {Array|Function} + * @default undefined + * + * @example + * ```js + * // source as a array + * columns: [{ + * type: 'autocomplete', + * source: ['A', 'B', 'C', 'D'] + * }], + * + * // source as a function + * columns: [{ + * type: 'autocomplete', + * source: function(query, callback) { + * fetch('https://example.com/query?q=' + query, function(response) { + * callback(response.items); + * }) + * } + * }], + * ``` + */ + source: void 0, + + /** + * @description + * Defines the column header name. + * + * @memberof Options# + * @type {string} + * @default undefined + * + * @example + * ```js + * // set header names for every column + * columns: [ + * { + * title: 'First name', + * type: 'text', + * }, + * { + * title: 'Last name', + * type: 'text', + * } + * ], + * ``` + */ + title: void 0, + + /** + * Data template for `'checkbox'` type when checkbox is checked. + * + * @memberof Options# + * @type {boolean|string|number} + * @default true + * + * @example + * ```js + * checkedTemplate: 'good' + * + * // if a checkbox-typed cell is checked, then getDataAtCell(x, y), + * // where x and y are the coordinates of the cell will return 'good'. + * ``` + */ + checkedTemplate: void 0, + + /** + * Data template for `'checkbox'` type when checkbox is unchecked. + * + * @memberof Options# + * @type {boolean|string|number} + * @default false + * + * @example + * ```js + * uncheckedTemplate: 'bad' + * + * // if a checkbox-typed cell is not checked, then getDataAtCell(x,y), + * // where x and y are the coordinates of the cell will return 'bad'. + * ``` + */ + uncheckedTemplate: void 0, + + /** + * @description + * Object which describes if renderer should create checkbox element with label element as a parent. + * + * __Note__, this option only works for [checkbox-typed](https://docs.handsontable.com/demo-checkbox.html) cells. + * + * By default the [checkbox](https://docs.handsontable.com/demo-checkbox.html) renderer renders the checkbox without a label. + * + * Possible object properties: + * * `property` - Defines the property name of the data object, which will to be used as a label. + * (eg. `label: {property: 'name.last'}`). This option works only if data was passed as an array of objects. + * * `position` - String which describes where to place the label text (before or after checkbox element). + * Valid values are `'before'` and '`after`' (defaults to `'after'`). + * * `value` - String or a Function which will be used as label text. + * + * @memberof Options# + * @type {object} + * @default undefined + * + * @example + * ```js + * columns: [{ + * type: 'checkbox', + * // add "My label:" after the checkbox + * label: {position: 'after', value: 'My label: '} + * }], + * ``` + */ + label: void 0, + + /** + * Display format for numeric typed renderers. + * + * __Note__, this option only works for [numeric-typed](https://docs.handsontable.com/demo-numeric.html) cells. + * + * Format is described by two properties: + * * `pattern` - Handled by `numbro` for purpose of formatting numbers to desired pattern. List of supported patterns can be found [here](http://numbrojs.com/format.html#numbers). + * * `culture` - Handled by `numbro` for purpose of formatting currencies. Examples showing how it works can be found [here](http://numbrojs.com/format.html#currency). List of supported cultures can be found [here](http://numbrojs.com/languages.html#supported-languages). + * + * __Note:__ Please keep in mind that this option is used only to format the displayed output! It has no effect on the input data provided for the cell. The numeric data can be entered to the table only as floats (separated by a dot or a comma) or integers, and are stored in the source dataset as JavaScript numbers. + * + * Handsontable uses [numbro](http://numbrojs.com/) as a main library for numbers formatting. + * + * @memberof Options# + * @since 0.35.0 + * @type {object} + * @default undefined + * + * @example + * ```js + * columns: [ + * { + * type: 'numeric', + * // set desired format pattern and + * numericFormat: { + * pattern: '0,00', + * culture: 'en-US' + * } + * } + * ], + * ``` + */ + numericFormat: void 0, + + /** + * Language for Handsontable translation. Possible language codes are [listed here](https://docs.handsontable.com/tutorial-internationalization.html#available-languages). + * + * @memberof Options# + * @type {string} + * @default 'en-US' + * + * @example + * ```js + * // set Polish language + * language: 'pl-PL', + * ``` + */ + language: 'en-US', + + /** + * Data source for [select-typed](https://docs.handsontable.com/demo-select.html) cells. + * + * __Note__, this option only works for [select-typed](https://docs.handsontable.com/demo-select.html) cells. + * + * @memberof Options# + * @type {string[]} + * @default undefined + * + * @example + * ```js + * columns: [ + * { + * editor: 'select', + * // add three select options to choose from + * selectOptions: ['A', 'B', 'C'], + * } + * ], + * ``` + */ + selectOptions: void 0, + + /** + * Enables or disables the {@link AutoColumnSize} plugin. Default value is `undefined`, which has the same effect as `true`, + * meaning, the `syncLimit` is set to 50. + * Disabling this plugin can increase performance, as no size-related calculations would be done. + * + * Column width calculations are divided into sync and async part. Each of those parts has their own advantages and + * disadvantages. Synchronous calculations are faster but they block the browser UI, while the slower asynchronous + * operations don't block the browser UI. + * + * To configure the sync/async distribution, you can pass an absolute value (number of columns) or a percentage value. + * + * You can also use the `useHeaders` option to take the column headers width into calculation. + * + * @memberof Options# + * @type {object|boolean} + * @default {syncLimit: 50} + * + * @example + * ```js + * // as a number (300 columns in sync, rest async) + * autoColumnSize: {syncLimit: 300}, + * + * // as a string (percent) + * autoColumnSize: {syncLimit: '40%'}, + * + * // use headers width while calculating the column width + * autoColumnSize: {useHeaders: true}, + * ``` + */ + autoColumnSize: void 0, + + /** + * Enables or disables {@link AutoRowSize} plugin. Default value is `undefined`, which has the same effect as `false` + * (disabled). Enabling this plugin can decrease performance, as size-related calculations would be performed. + * + * __Note:__ the default `syncLimit` value is set to 500 when the plugin is manually enabled by declaring it as: `autoRowSize: true`. + * + * Row height calculations are divided into sync and async stages. Each of these stages has their own advantages and + * disadvantages. Synchronous calculations are faster but they block the browser UI, while the slower asynchronous + * operations don't block the browser UI. + * + * To configure the sync/async distribution, you can pass an absolute value (number of columns) or a percentage value. + * + * @memberof Options# + * @type {object|boolean} + * @default undefined + * + * @example + * ```js + * // as a number (300 columns in sync, rest async) + * autoRowSize: {syncLimit: 300}, + * + * // as a string (percent) + * autoRowSize: {syncLimit: '40%'}, + * ``` + */ + autoRowSize: void 0, + + /** + * Date validation format. + * + * __Note__, this option only works for [date-typed](https://docs.handsontable.com/demo-date.html) cells. + * + * @memberof Options# + * @type {string} + * @default 'DD/MM/YYYY' + * + * @example + * ```js + * columns: [{ + * type: 'date', + * // localise date format + * dateFormat: 'MM/DD/YYYY' + * }], + * ``` + */ + dateFormat: 'DD/MM/YYYY', + + /** + * If `true` then dates will be automatically formatted to match the desired format. + * + * __Note__, this option only works for [date-typed](https://docs.handsontable.com/demo-date.html) cells. + * + * @memberof Options# + * @type {boolean} + * @default false + * + * @example + * ```js + * columns: [{ + * type: 'date', + * dateFormat: 'YYYY-MM-DD', + * // force selected date format + * correctFormat: true + * }], + * ``` + */ + correctFormat: false, + + /** + * Definition of default value which will fill the empty cells. + * + * __Note__, this option only works for [date-typed](https://docs.handsontable.com/demo-date.html) cells. + * + * @memberof Options# + * @type {string} + * @default undefined + * + * @example + * ```js + * columns: [ + * { + * type: 'date', + * // always set this date for empty cells + * defaultDate: '2015-02-02' + * } + * ], + * ``` + */ + defaultDate: void 0, + + /** + * If set to `true`, the value entered into the cell must match (case-sensitive) the autocomplete source. + * Otherwise, cell won't pass the validation. When filtering the autocomplete source list, the editor will + * be working in case-insensitive mode. + * + * __Note__, this option only works for [autocomplete-typed](https://docs.handsontable.com/demo-autocomplete.html) cells. + * + * @memberof Options# + * @type {boolean} + * @default undefined + * + * @example + * ```js + * columns: [{ + * type: 'autocomplete', + * source: ['A', 'B', 'C'], + * // force selected value to match the source list + * strict: true + * }], + * ``` + */ + strict: void 0, + + /** + * If set to `true`, data defined in `source` of the autocomplete or dropdown cell will be treated as HTML. + * + * __Warning:__ Enabling this option can cause serious XSS vulnerabilities. + * + * __Note__, this option only works for [autocomplete-typed](https://docs.handsontable.com/demo-autocomplete.html) cells. + * + * @memberof Options# + * @type {boolean} + * @default false + * + * @example + * ```js + * columns: [{ + * type: 'autocomplete', + * // use HTML in the source list + * allowHtml: true, + * source: ['foo', 'bar'] + * }], + * ``` + */ + allowHtml: false, + + /** + * If typed `true` then virtual rendering mechanism for handsontable will be disabled. + * + * @memberof Options# + * @type {boolean} + * @default undefined + * + * @example + * ```js + * // disable virtual rows rendering + * renderAllRows: true, + * ``` + */ + renderAllRows: void 0, + + /** + * Prevents table to overlap outside the parent element. If `'horizontal'` option is chosen then table will show + * a horizontal scrollbar if parent's width is narrower then table's width. + * + * Possible values: + * * `false` - Disables functionality. + * * `horizontal` - Prevents horizontal overflow table. + * * `vertical` - Prevents vertical overflow table. + * + * @memberof Options# + * @type {string|boolean} + * @default false + * + * @example + * ```js + * preventOverflow: 'horizontal', + * ``` + */ + preventOverflow: false, + + /** + * Prevents wheel event on overlays for doing default action. + * + * @memberof Options# + * @private + * @type {boolean} + * @default false + * + * @example + * ```js + * preventWheel: false, + * ``` + */ + preventWheel: false, + + /** + * @description + * Enables the functionality of the {@link BindRowsWithHeaders} plugin which allows binding the table rows with their headers. + * If the plugin is enabled, the table row headers will "stick" to the rows, when they are hidden/moved. Basically, + * if at the initialization row 0 has a header titled "A", it will have it no matter what you do with the table. + * + * @memberof Options# + * @type {boolean|string} + * @default undefined + * + * @example + * ```js + * // keep row data and row headers in sync + * bindRowsWithHeaders: true + * ``` + */ + bindRowsWithHeaders: void 0, + + /** + * @description + * The {@link CollapsibleColumns} plugin allows collapsing of columns, covered by a header with the `colspan` property + * defined. + * + * Clicking the "collapse/expand" button collapses (or expands) all "child" headers except the first one. + * + * Setting the `collapsibleColumns` property to `true` will display a "collapse/expand" button in every + * header with a defined colspan` property. + * + * To limit this functionality to a smaller group of headers, define the `collapsibleColumns` property + * as an array of objects, as in the example below. + * + * @memberof Options# + * @type {boolean|object[]} + * @default undefined + * + * @example + * ```js + * // enable collapsing for all headers + * collapsibleColumns: true, + * + * // or + * // enable collapsing for selected headers + * collapsibleColumns: [ + * {row: -4, col: 1, collapsible: true}, + * {row: -3, col: 5, collapsible: true} + * ], + * ``` + */ + collapsibleColumns: void 0, + + /** + * @description + * Allows making pre-defined calculations on the cell values and display the results within Handsontable. + * + * Possible types: + * * `'sum'` + * * `'min'` + * * `'max'` + * * `'count'` + * * `'average'` + * * `'custom'` - add `customFunction`. + * + * [See the demo for more information](https://docs.handsontable.com/demo-summary-calculations.html). + * + * @memberof Options# + * @type {object[]|Function} + * @default undefined + * + * @example + * ``` + * columnSummary: [ + * { + * destinationRow: 4, + * destinationColumn: 1, + * forceNumeric: true, + * reversedRowCoords: true, + * suppressDataTypeErrors: false, + * readOnly: true, + * roundFloat: false, + * type: 'custom', + * customFunction: function(endpoint) { + * return 100; + * } + * } + * ], + * ``` + */ + columnSummary: void 0, + + /** + * This plugin allows adding a configurable dropdown menu to the table's column headers. The dropdown menu acts like + * the {@link Options#contextMenu}, but is triggered by clicking the button in the header. + * + * @memberof Options# + * @type {boolean|object|string[]} + * @default undefined + * + * @example + * ```js + * // enable dropdown menu + * dropdownMenu: true, + * + * // or + * // enable and configure dropdown menu options + * dropdownMenu: ['remove_col', '---------', 'make_read_only', 'alignment'] + * ``` + */ + dropdownMenu: void 0, + + /** + * The {@link Filters} plugin allows filtering the table data either by the built-in component or with the API. + * + * @memberof Options# + * @type {boolean} + * @default undefined + * + * @example + * ```js + * // enable filters + * filters: true, + * ``` + */ + filters: void 0, + + /** + * The {@link Formulas} plugin allows Handsontable to process formula expressions defined in the provided data. + * + * @memberof Options# + * @type {boolean|object} + * @default undefined + * + * @example + * ```js + * // enable formulas plugin + * formulas: true, + * + * // or as an object with custom variables to be used in formula expressions + * formulas: { + * variables: { + * FOO: 64, + * BAR: 'baz', + * } + * }, + * ``` + */ + formulas: void 0, + + /** + * @description + * Allows adding a tooltip to the table headers. + * + * Available options: + * * the `rows` property defines if tooltips should be added to row headers, + * * the `columns` property defines if tooltips should be added to column headers, + * * the `onlyTrimmed` property defines if tooltips should be added only to headers, which content is trimmed by the header itself (the content being wider then the header). + * + * @memberof Options# + * @type {boolean|object} + * @default undefined + * @deprecated This plugin is deprecated and will be removed in the next major release. + * + * @example + * ```js + * // enable tooltips for all headers + * headerTooltips: true, + * + * // or + * headerTooltips: { + * rows: false, + * columns: true, + * onlyTrimmed: true + * } + * ``` + */ + headerTooltips: void 0, + + /** + * The {@link HiddenColumns} plugin allows hiding of certain columns. You can pass additional configuration with an + * object notation. Options that are then available are: + * * `columns` - an array of rows that should be hidden on plugin initialization + * * `indicators` - enables small ui markers to indicate where are hidden columns. + * + * @memberof Options# + * @type {boolean|object} + * @default undefined + * + * @example + * ```js + * // enable column hiding + * hiddenColumns: true, + * + * // or + * hiddenColumns: { + * // set columns that are hidden by default + * columns: [5, 10, 15], + * // show where are hidden columns + * indicators: true + * } + * ``` + */ + hiddenColumns: void 0, + + /** + * The {@link HiddenRows} plugin allows hiding of certain rows. You can pass additional configuration with an + * object notation. Options that are then available are: + * * `rows` - an array of rows that should be hidden on plugin initialization + * * `indicators` - enables small ui markers to indicate where are hidden columns. + * + * @memberof Options# + * @type {boolean|object} + * @default undefined + * + * @example + * ```js + * // enable row hiding + * hiddenRows: true, + * + * // or + * hiddenRows: { + * // set rows that are hidden by default + * rows: [5, 10, 15], + * // show where are hidden rows + * indicators: true + * } + * ``` + */ + hiddenRows: void 0, + + /** + * @description + * Allows creating a nested header structure, using the HTML's colspan attribute. + * + * @memberof Options# + * @type {Array[]} + * @default undefined + * + * @example + * ``` + * nestedHeaders: [ + * ['A', {label: 'B', colspan: 8}, 'C'], + * ['D', {label: 'E', colspan: 4}, {label: 'F', colspan: 4}, 'G'], + * ['H', 'I', 'J', 'K', 'L', 'M', 'N', 'R', 'S', 'T'] + * ], + * ``` + */ + nestedHeaders: void 0, + + /** + * @description + * Plugin allowing hiding of certain rows. + * + * @memberof Options# + * @type {boolean|number[]} + * @default undefined + * + * @example + * ```js + * // enable plugin + * trimRows: true, + * + * // or + * // trim selected rows on table initialization + * trimRows: [5, 10, 15], + * ``` + */ + trimRows: void 0, + + /** + * @description + * Allows setting a custom width of the row headers. You can provide a number or an array of widths, if many row + * header levels are defined. + * + * @memberof Options# + * @type {number|number[]} + * @default undefined + * + * @example + * ```js + * // set width for all row headers + * rowHeaderWidth: 25, + * + * // or + * // set width for selected headers only + * rowHeaderWidth: [25, 30, 55], + * ``` + */ + rowHeaderWidth: void 0, + + /** + * @description + * Allows setting a custom height of the column headers. You can provide a number or an array of heights, if many + * column header levels are defined. + * + * @memberof Options# + * @type {number|number[]} + * @default undefined + * + * @example + * ```js + * // set shared height for all headers + * columnHeaderHeight: 35, + * + * // or + * // set height for each header individually + * columnHeaderHeight: [35, 20, 55], + * + * // or + * // skipped headers will fallback to default value + * columnHeaderHeight: [35, undefined, 55], + * ``` + */ + columnHeaderHeight: void 0, + + /** + * @description + * Enables the {@link ObserveChanges} plugin switches table into one-way data binding where changes are applied into + * data source (from outside table) will be automatically reflected in the table. + * + * For every data change [afterChangesObserved](Hooks.html#event:afterChangesObserved) hook will be fired. + * + * @memberof Options# + * @type {boolean} + * @default undefined + * @deprecated This plugin is deprecated and will be removed in the next major release. + * + * @example + * ```js + * observeChanges: true, + * ``` + */ + observeChanges: void 0, + + /** + * If defined as `true`, the Autocomplete's suggestion list would be sorted by relevance (the closer to the left the + * match is, the higher the suggestion). + * + * __Note__, this option only works for [autocomplete-typed](https://docs.handsontable.com/demo-autocomplete.html) cells. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * columns: [ + * { + * type: 'autocomplete', + * source: [ ... ], + * // keep options order as they were defined + * sortByRelevance: false + * } + * ], + * ``` + */ + sortByRelevance: true, + + /** + * If defined as `true`, when the user types into the input area the Autocomplete's suggestion list is updated to only + * include those choices starting with what has been typed; if defined as `false` all suggestions remain shown, with + * those matching what has been typed marked in bold. + * + * __Note__, this option only works for [autocomplete-typed](https://docs.handsontable.com/demo-autocomplete.html) cells. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * columns: [ + * { + * type: 'autocomplete', + * source: [ ... ], + * // don't hide options that don't match search query + * filter: false + * } + * ], + * ``` + */ + filter: true, + + /** + * If defined as `true`, filtering in the Autocomplete Editor will be case-sensitive. + * + * __Note__, this option only works for [autocomplete-typed](https://docs.handsontable.com/demo-autocomplete.html) cells. + * + * @memberof Options# + * @type {boolean} + * @default false + * + * @example + * ```js + * columns: [ + * { + * type: 'autocomplete', + * source: [ ... ], + * // match case while searching autocomplete options + * filteringCaseSensitive: true + * } + * ], + * ``` + */ + filteringCaseSensitive: false, + + /** + * @description + * Disables or enables the drag to scroll functionality. + * + * @memberof Options# + * @type {boolean} + * @default true + * + * @example + * ```js + * // don't scroll the viewport when selection gets to the viewport edge + * dragToScroll: false, + * ``` + */ + dragToScroll: true, + + /** + * @description + * Disable or enable the nested rows functionality - displaying nested structures in a two-dimensional data table. + * + * See [quick setup of the Nested rows](https://handsontable.com/docs/demo-nested-rows.html). + * @example + * ```js + * nestedRows: true, + * ``` + * + * @memberof Options# + * @type {boolean} + * @default false + */ + nestedRows: void 0 + }; +}); + +function _defineProperties$W(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); } } + +function _createClass$W(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$W(Constructor.prototype, protoProps); if (staticProps) _defineProperties$W(Constructor, staticProps); return Constructor; } + +function _classCallCheck$$(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +/** + * @returns {TableMeta} Returns an empty object. The holder for global meta object. + */ + +function createTableMetaEmptyClass() { + return function TableMeta() { + _classCallCheck$$(this, TableMeta); + }; +} +/** + * The global meta object is a root of all default settings, which are recognizable by Handsontable. + * Other layers are inherited from this object. Adding, removing, or changing property in that + * object has a direct reflection to all layers such as: TableMeta, ColumnMeta, or CellMeta layers. + * + * +-------------+. + * │ GlobalMeta │ + * │ (prototype) │ + * +-------------+\ + * │ \ + * │ \ + * \│/ _\| + * +-------------+ +-------------+. + * │ TableMeta │ │ ColumnMeta │ + * │ (instance) │ │ (prototype) │ + * +-------------+ +-------------+. + * │ + * │ + * \│/ + * +-------------+. + * │ CellMeta │ + * │ (instance) │ + * +-------------+. + */ + + +var GlobalMeta = /*#__PURE__*/function () { + function GlobalMeta() { + _classCallCheck$$(this, GlobalMeta); + + /** + * An alias for the constructor. Necessary for inheritance for creating new layers. + * + * @type {TableMeta} + */ + this.metaCtor = createTableMetaEmptyClass(); + /** + * Main object (prototype of the internal TableMeta class), holder for all default settings. + * + * @type {object} + */ + + this.meta = this.metaCtor.prototype; + extend(this.meta, metaSchemaFactory()); + } + /** + * Gets constructor of the global meta object. Necessary for inheritance for creating the next meta layers. + * + * @returns {Function} + */ + + + _createClass$W(GlobalMeta, [{ + key: "getMetaConstructor", + value: function getMetaConstructor() { + return this.metaCtor; + } + /** + * Gets settings object for this layer. + * + * @returns {object} + */ + + }, { + key: "getMeta", + value: function getMeta() { + return this.meta; + } + /** + * Updates global settings object by merging settings with the current state. + * + * @param {object} settings An object to merge with. + */ + + }, { + key: "updateMeta", + value: function updateMeta(settings) { + extend(this.meta, settings); + extend(this.meta, expandMetaType(settings.type, settings)); + } + }]); + + return GlobalMeta; +}(); + +function _classCallCheck$10(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$X(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); } } + +function _createClass$X(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$X(Constructor.prototype, protoProps); if (staticProps) _defineProperties$X(Constructor, staticProps); return Constructor; } +/** + * The table meta object is a layer that keeps all settings of the Handsontable that was passed in + * the constructor. That layer contains all default settings inherited from the GlobalMeta layer + * merged with settings passed by the developer. Adding, removing, or changing property in that + * object has no direct reflection on any other layers. + * + * +-------------+. + * │ GlobalMeta │ + * │ (prototype) │ + * +-------------+\ + * │ \ + * │ \ + * \│/ _\| + * +-------------+ +-------------+. + * │ TableMeta │ │ ColumnMeta │ + * │ (instance) │ │ (prototype) │ + * +-------------+ +-------------+. + * │ + * │ + * \│/ + * +-------------+. + * │ CellMeta │ + * │ (instance) │ + * +-------------+. + */ + +var TableMeta = /*#__PURE__*/function () { + function TableMeta(globalMeta) { + _classCallCheck$10(this, TableMeta); + + var MetaCtor = globalMeta.getMetaConstructor(); + /** + * Main object (instance of the internal TableMeta class from GlobalMeta), holder for all settings defined in the table scope. + * + * @type {object} + */ + + this.meta = new MetaCtor(); + } + /** + * Gets settings object for this layer. + * + * @returns {object} + */ + + + _createClass$X(TableMeta, [{ + key: "getMeta", + value: function getMeta() { + return this.meta; + } + /** + * Updates table settings object by merging settings with the current state. + * + * @param {object} settings An object to merge with. + */ + + }, { + key: "updateMeta", + value: function updateMeta(settings) { + extend(this.meta, settings); + extend(this.meta, expandMetaType(settings.type, settings)); + } + }]); + + return TableMeta; +}(); + +function _classCallCheck$11(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$Y(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); } } + +function _createClass$Y(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$Y(Constructor.prototype, protoProps); if (staticProps) _defineProperties$Y(Constructor, staticProps); return Constructor; } +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @class LazyFactoryMap + * + * The LazyFactoryMap object holds key-value pairs in the structure similar to the + * regular Map. Once created, items can be moved around a grid depending on the operations + * performed on that grid - adding or removing rows. The collection requires "key" + * to be a zero-based index. + * + * It's essential to notice that the "key" index under which the item was created + * is volatile. After altering the grid, the "key" index can change. + * + * Having created N items with corresponding example data where the data has 10 + * holes (`undefined` values) within (that's why internal storage index counts from 10). + * +------+------+------+------+------+. + * | 0/10 | 1/11 | 2/12 | 3/13 | 4/14 | Keys (volatile zero-based index / internal storage index) + * +------+------+------+------+------+. + * │ │ │ │ │ + * +------+------+------+------+------+. + * | AAA | BBB | CCC | DDD | EEE | Data + * +------+------+------+------+------+. + * + * Map.obtain(0) // returns "AAA" + * map.obtain(2) // returns "CCC". + * + * After inserting 2 new rows, keys that hold the data positioned after the place + * where the new rows are added are upshifted by 2. + * │ + * │ Insert 2 rows + * \│/ + * +------+------+------+------+------+. + * | 0/10 | 1/11 | 2/12 | 3/13 | 4/14 | Keys before + * +------+------+------+------+------+. + * + * / 2 new rows \ + * +------+------+------+------+------+------+------+. + * | 0/10 | 1/11 | 2/15 | 3/16 | 4/12 | 5/13 | 6/14 | Keys after + * +------+------+------+------+------+------+------+. + * │ │ │ │ │ │ │ + * │ │ └──────┼──────┼──────┼┠│ + * │ │ └──────┼──────┼┼────┼┠+ * │ │ ┌─────────────┘ ││ ││ + * │ │ │ ┌─────────────┘│ ││ + * │ │ │ │ ┌───────┼────┘│ + * │ │ │ │ │ │ │ + * +------+------+------+------+------+------+------+. + * | AAA | BBB | CCC | DDD | EEE | FFF | GGG | Data + * +------+------+------+------+------+------+------+ + * + * Now at index 2 and 3 we have access to new items. + * + * map.obtain(2) // returns new value "FFF" for newly created row. + * map.obtain(4) // index shifted by 2 has access to the old "CCC" value, as before inserting. + * + * after removing 4 rows, keys that hold the data positioned after the place where the + * rows are removed are downshifted by 4. + * │ + * │ Remove 4 rows + * ├───────────────────────────┠+ * \│/ │ + * +------+------+------+------+------+------+------+ + * | 0/10 | 1/11 | 2/15 | 3/16 | 4/12 | 5/13 | 6/14 | Keys after + * +------+------+------+------+------+------+------+ + * │ │ │ │ │ │ │ + * │ │ └──────┼──────┼──────┼┠│ + * │ │ └──────┼──────┼┼────┼┠+ * │ │ ┌─────────────┘ ││ ││ + * │ │ │ ┌─────────────┘│ ││ + * │ │ │ │ ┌───────┼────┘│ + * │ │ │ │ │ │ │ + * +------+------+------+------+------+------+------+ + * | AAA | BBB | CCC | DDD | EEE | FFF | GGG | Data + * +------+------+------+------+------+------+------+ + * + * +------+------+------+ + * | 0/10 | 1/13 | 2/14 | Keys after + * +------+------+------+ + * │ │ │ + * │ │ └─────────────┠+ * │ └────────────┠│ + * │ │ │ + * │ │ │ + * │ │ │ + * │ │ │ + * +------+------+------+------+------+------+------+ + * | AAA | BBB | CCC | DDD | EEE | FFF | GGG | Data + * +------+------+------+------+------+------+------+ + * /│\ /│\ /│\ /│\ + * └──┬──┘ └──┬──┘ + * This data is marked as "hole" which + * means that can be replaced by new item + * when that will be created. + * + * map.obtain(2) // returns the value ("EEE") as it should. Access to the value is + * // changed (the key was downshifted). However, the internal index has not changed, + * // which means that the data does not need to be changed (spliced) too. + * + * After previous remove operation which creates some "holes" obtaining new + * items replaces that "holes" as follows: + * + * // Obtains new item + * map.obtain(90) // Returns "NEW" value + * + * +------+------+------+...+------+ + * | 0/10 | 1/13 | 2/14 | | 90/0 | Keys after + * +------+------+------+...+------+ + * │ │ │ │ + * │ │ └──────────┼────────────┠+ * │ └─────────────────┼─────┠│ + * └──────────┠│ │ │ + * │ │ │ │ + * ┌──────────┼──────────────┘ │ │ + * │ │ │ │ + * +------+...+------+------+------+------+------+-----+ + * | NEW | | AAA | BBB | CCC | DDD | EEE | FFF | Data + * +------+...+------+------+------+------+------+-----+ + * /│\ + * │ + * The first "hole" (at index 0) item is permanently removed and replaced by a new item. + * The hole index is taken from the hole collection which act as FIFO (First In First Out). + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var LazyFactoryMap = /*#__PURE__*/function () { + function LazyFactoryMap(valueFactory) { + _classCallCheck$11(this, LazyFactoryMap); + + this.valueFactory = valueFactory; + /** + * An array which contains data. + * + * @type {Array} + */ + + this.data = []; + /** + * An array of indexes where the key of the array is mapped to the value which points to the + * specific position of the data array. + * + * @type {number[]} + */ + + this.index = []; + /** + * The collection of indexes that points to the data items which can be replaced by obtaining new + * ones. The "holes" are an intended effect of deleting entries. + * + * The idea of "holes" generally allows us to not modify the "data" structure while removing + * items from the collection. + * + * @type {Set} + */ + + this.holes = new Set(); + } + /** + * Gets or if data not exist creates and returns new data. + * + * @param {number} key The item key as zero-based index. + * @returns {*} + */ + + + _createClass$Y(LazyFactoryMap, [{ + key: "obtain", + value: function obtain(key) { + assert(function () { + return isUnsignedNumber(key); + }, 'Expecting an unsigned number.'); + + var dataIndex = this._getStorageIndexByKey(key); + + var result; + + if (dataIndex >= 0) { + result = this.data[dataIndex]; + + if (result === void 0) { + result = this.valueFactory(key); + this.data[dataIndex] = result; + } + } else { + result = this.valueFactory(key); + + if (this.holes.size > 0) { + var reuseIndex = this.holes.values().next().value; // Gets first item from the collection + + this.holes.delete(reuseIndex); + this.data[reuseIndex] = result; + this.index[key] = reuseIndex; + } else { + this.data.push(result); + this.index[key] = this.data.length - 1; + } + } + + return result; + } + /** + * Inserts an empty data to the map. This method creates an empty space for obtaining + * new data. + * + * @param {number} key The key as volatile zero-based index at which to begin inserting space for new data. + * @param {number} [amount=1] Ammount of data to insert. + */ + + }, { + key: "insert", + value: function insert(key) { + var _this$index; + + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + assert(function () { + return isUnsignedNumber(key) || isNullish(key); + }, 'Expecting an unsigned number or null/undefined argument.'); + var newIndexes = []; + var dataLength = this.data.length; + + for (var i = 0; i < amount; i++) { + newIndexes.push(dataLength + i); + this.data.push(void 0); + } + + (_this$index = this.index).splice.apply(_this$index, [isNullish(key) ? this.index.length : key, 0].concat(newIndexes)); + } + /** + * Removes (soft remove) data from "index" and according to the amount of data. + * + * @param {number} key The key as volatile zero-based index at which to begin removing the data. + * @param {number} [amount=1] Ammount data to remove. + */ + + }, { + key: "remove", + value: function remove(key) { + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + assert(function () { + return isUnsignedNumber(key) || isNullish(key); + }, 'Expecting an unsigned number or null/undefined argument.'); + var removed = this.index.splice(isNullish(key) ? this.index.length - amount : key, amount); + + for (var i = 0; i < removed.length; i++) { + var removedIndex = removed[i]; + + if (typeof removedIndex === 'number') { + this.holes.add(removedIndex); + } + } + } + /** + * Returns the size of the data which this map holds. + * + * @returns {number} + */ + + }, { + key: "size", + value: function size() { + return this.data.length - this.holes.size; + } + /** + * Returns a new Iterator object that contains the values for each item in the LazyMap object. + * + * @returns {Iterator} + */ + + }, { + key: "values", + value: function values() { + var _this = this; + + return arrayFilter(this.data, function (_, index) { + return !_this.holes.has(index); + })[Symbol.iterator](); + } + /** + * Returns a new Iterator object that contains an array of `[index, value]` for each item in the LazyMap object. + * + * @returns {Iterator} + */ + + }, { + key: "entries", + value: function entries() { + var validEntries = []; + + for (var i = 0; i < this.data.length; i++) { + var keyIndex = this._getKeyByStorageIndex(i); + + if (keyIndex !== -1) { + validEntries.push([keyIndex, this.data[i]]); + } + } + + var dataIndex = 0; + return { + next: function next() { + if (dataIndex < validEntries.length) { + var value = validEntries[dataIndex]; + dataIndex += 1; + return { + value: value, + done: false + }; + } + + return { + done: true + }; + } + }; + } + /** + * Clears the map. + */ + + }, { + key: "clear", + value: function clear() { + this.data = []; + this.index = []; + this.holes.clear(); + } + /** + * Gets storage index calculated from the key associated with the specified value. + * + * @param {number} key Volatile zero-based index. + * @returns {number} Returns index 0-N or -1 if no storage index found. + */ + + }, { + key: "_getStorageIndexByKey", + value: function _getStorageIndexByKey(key) { + return this.index.length > key ? this.index[key] : -1; + } + /** + * Gets the key associated with the specified value calculated from storage index. + * + * @param {number} dataIndex Zero-based storage index. + * @returns {number} Returns index 0-N or -1 if no key found. + */ + + }, { + key: "_getKeyByStorageIndex", + value: function _getKeyByStorageIndex(dataIndex) { + return this.index.indexOf(dataIndex); + } + /** + * Makes this object iterable. + * + * @returns {Iterator} + */ + + }, { + key: Symbol.iterator, + value: function value() { + return this.entries(); + } + }]); + + return LazyFactoryMap; +}(); + +function _classCallCheck$12(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$Z(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); } } + +function _createClass$Z(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$Z(Constructor.prototype, protoProps); if (staticProps) _defineProperties$Z(Constructor, staticProps); return Constructor; } +/** + * List of props which have to be cleared in the column meta-layer. That props have a + * different meaning when using in column meta. + * + * @type {string[]} + */ + +var COLUMNS_PROPS_CONFLICTS = ['data', 'width']; +/** + * The column meta object is a root of all settings defined in the column property of the Handsontable + * settings. Each column in the Handsontable is associated with a unique meta object which is managed by + * this layer. Adding, removing, or changing property in that object has a direct reflection only for + * the CellMeta layer. The reflection will be visible only if the property doesn't exist in the lower + * layers (prototype lookup). + * + * +-------------+. + * │ GlobalMeta │ + * │ (prototype) │ + * +-------------+\ + * │ \ + * │ \ + * \│/ _\| + * +-------------+ +-------------+. + * │ TableMeta │ │ ColumnMeta │ + * │ (instance) │ │ (prototype) │ + * +-------------+ +-------------+. + * │ + * │ + * \│/ + * +-------------+. + * │ CellMeta │ + * │ (instance) │ + * +-------------+. + */ + +var ColumnMeta = /*#__PURE__*/function () { + function ColumnMeta(globalMeta) { + var _this = this; + + _classCallCheck$12(this, ColumnMeta); + + /** + * Reference to the GlobalMeta layer. While creating new column meta objects, all new objects + * inherit properties from the GlobalMeta layer. + * + * @type {GlobalMeta} + */ + this.globalMeta = globalMeta; + /** + * The LazyFactoryMap structure, holder for column meta objects where each column meta is + * stored under the physical column index. + * + * @type {LazyFactoryMap} + */ + + this.metas = new LazyFactoryMap(function () { + return _this._createMeta(); + }); + } + /** + * Updates column meta object by merging settings with the current state. + * + * @param {number} physicalColumn The physical column index which points what column meta object is updated. + * @param {object} settings An object to merge with. + */ + + + _createClass$Z(ColumnMeta, [{ + key: "updateMeta", + value: function updateMeta(physicalColumn, settings) { + var meta = this.getMeta(physicalColumn); + extend(meta, settings); + extend(meta, expandMetaType(settings.type, meta)); + } + /** + * Creates one or more columns at specific position. + * + * @param {number} physicalColumn The physical column index which points from what position the column is added. + * @param {number} amount An amount of columns to add. + */ + + }, { + key: "createColumn", + value: function createColumn(physicalColumn, amount) { + this.metas.insert(physicalColumn, amount); + } + /** + * Removes one or more columns from the collection. + * + * @param {number} physicalColumn The physical column index which points from what position the column is removed. + * @param {number} amount An amount columns to remove. + */ + + }, { + key: "removeColumn", + value: function removeColumn(physicalColumn, amount) { + this.metas.remove(physicalColumn, amount); + } + /** + * Gets settings object for this layer. + * + * @param {number} physicalColumn The physical column index. + * @returns {object} + */ + + }, { + key: "getMeta", + value: function getMeta(physicalColumn) { + return this.metas.obtain(physicalColumn); + } + /** + * Gets constructor of the column meta object. Necessary for inheritance - creating the next meta layers. + * + * @param {number} physicalColumn The physical column index. + * @returns {Function} + */ + + }, { + key: "getMetaConstructor", + value: function getMetaConstructor(physicalColumn) { + return this.metas.obtain(physicalColumn).constructor; + } + /** + * Clears all saved column meta objects. + */ + + }, { + key: "clearCache", + value: function clearCache() { + this.metas.clear(); + } + /** + * Creates and returns new column meta object with properties inherited from the global meta layer. + * + * @private + * @returns {object} + */ + + }, { + key: "_createMeta", + value: function _createMeta() { + return columnFactory(this.globalMeta.getMetaConstructor(), COLUMNS_PROPS_CONFLICTS).prototype; + } + }]); + + return ColumnMeta; +}(); + +function _toConsumableArray$g(arr) { return _arrayWithoutHoles$e(arr) || _iterableToArray$e(arr) || _unsupportedIterableToArray$l(arr) || _nonIterableSpread$e(); } + +function _nonIterableSpread$e() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$l(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$l(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$l(o, minLen); } + +function _iterableToArray$e(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$e(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$l(arr); } + +function _arrayLikeToArray$l(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$13(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } } + +function _createClass$_(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$_(Constructor.prototype, protoProps); if (staticProps) _defineProperties$_(Constructor, staticProps); return Constructor; } +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @class CellMeta + * + * The cell meta object is a root of all settings defined for the specific cell rendered by the + * Handsontable. Each cell meta inherits settings from higher layers. When a property doesn't + * exist in that layer, it is looked up through a prototype to the highest layer. Starting + * from CellMeta -> ColumnMeta and ending to GlobalMeta, which stores default settings. Adding, + * removing, or changing property in that object has no direct reflection on any other layers. + * + * +-------------+ + * │ GlobalMeta │ + * │ (prototype) │ + * +-------------+\ + * │ \ + * │ \ + * \│/ _\| + * +-------------+ +-------------+ + * │ TableMeta │ │ ColumnMeta │ + * │ (instance) │ │ (prototype) │ + * +-------------+ +-------------+ + * │ + * │ + * \│/ + * +-------------+ + * │ CellMeta │ + * │ (instance) │ + * +-------------+ + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var CellMeta = /*#__PURE__*/function () { + function CellMeta(columnMeta) { + var _this = this; + + _classCallCheck$13(this, CellMeta); + + /** + * Reference to the ColumnMeta layer. While creating new cell meta objects, all new objects + * inherit properties from the ColumnMeta layer. + * + * @type {ColumnMeta} + */ + this.columnMeta = columnMeta; + /** + * Holder for cell meta objects, organized as a grid of LazyFactoryMap of LazyFactoryMaps. + * The access to the cell meta object is done through access to the row defined by the physical + * row index and then by accessing the second LazyFactory Map under the physical column index. + * + * @type {LazyFactoryMap>} + */ + + this.metas = new LazyFactoryMap(function () { + return _this._createRow(); + }); + } + /** + * Updates cell meta object by merging settings with the current state. + * + * @param {number} physicalRow The physical row index which points what cell meta object is updated. + * @param {number} physicalColumn The physical column index which points what cell meta object is updated. + * @param {object} settings An object to merge with. + */ + + + _createClass$_(CellMeta, [{ + key: "updateMeta", + value: function updateMeta(physicalRow, physicalColumn, settings) { + var meta = this.getMeta(physicalRow, physicalColumn); + extend(meta, settings); + extend(meta, expandMetaType(settings.type, meta)); + } + /** + * Creates one or more rows at specific position. + * + * @param {number} physicalRow The physical row index which points from what position the row is added. + * @param {number} amount An amount of rows to add. + */ + + }, { + key: "createRow", + value: function createRow(physicalRow, amount) { + this.metas.insert(physicalRow, amount); + } + /** + * Creates one or more columns at specific position. + * + * @param {number} physicalColumn The physical column index which points from what position the column is added. + * @param {number} amount An amount of columns to add. + */ + + }, { + key: "createColumn", + value: function createColumn(physicalColumn, amount) { + for (var i = 0; i < this.metas.size(); i++) { + this.metas.obtain(i).insert(physicalColumn, amount); + } + } + /** + * Removes one or more rows from the collection. + * + * @param {number} physicalRow The physical row index which points from what position the row is removed. + * @param {number} amount An amount of rows to remove. + */ + + }, { + key: "removeRow", + value: function removeRow(physicalRow, amount) { + this.metas.remove(physicalRow, amount); + } + /** + * Removes one or more columns from the collection. + * + * @param {number} physicalColumn The physical column index which points from what position the column is removed. + * @param {number} amount An amount of columns to remove. + */ + + }, { + key: "removeColumn", + value: function removeColumn(physicalColumn, amount) { + for (var i = 0; i < this.metas.size(); i++) { + this.metas.obtain(i).remove(physicalColumn, amount); + } + } + /** + * Gets settings object for this layer. + * + * @param {number} physicalRow The physical row index. + * @param {number} physicalColumn The physical column index. + * @param {string} [key] If the key exists its value will be returned, otherwise the whole cell meta object. + * @returns {object} + */ + + }, { + key: "getMeta", + value: function getMeta(physicalRow, physicalColumn, key) { + var cellMeta = this.metas.obtain(physicalRow).obtain(physicalColumn); + + if (key === void 0) { + return cellMeta; + } + + return cellMeta[key]; + } + /** + * Sets settings object for this layer defined by "key" property. + * + * @param {number} physicalRow The physical row index. + * @param {number} physicalColumn The physical column index. + * @param {string} key The property name to set. + * @param {*} value Value to save. + */ + + }, { + key: "setMeta", + value: function setMeta(physicalRow, physicalColumn, key, value) { + var cellMeta = this.metas.obtain(physicalRow).obtain(physicalColumn); + cellMeta[key] = value; + } + /** + * Removes a property defined by the "key" argument from the cell meta object. + * + * @param {number} physicalRow The physical row index. + * @param {number} physicalColumn The physical column index. + * @param {string} key The property name to remove. + */ + + }, { + key: "removeMeta", + value: function removeMeta(physicalRow, physicalColumn, key) { + var cellMeta = this.metas.obtain(physicalRow).obtain(physicalColumn); + delete cellMeta[key]; + } + /** + * Returns all cell meta objects that were created during the Handsontable operation. As cell meta + * objects are created lazy, the length of the returned collection depends on how and when the + * table has asked for access to that meta objects. + * + * @returns {object[]} + */ + + }, { + key: "getMetas", + value: function getMetas() { + var metas = []; + var rows = Array.from(this.metas.values()); + + for (var row = 0; row < rows.length; row++) { + metas.push.apply(metas, _toConsumableArray$g(rows[row].values())); + } + + return metas; + } + /** + * Returns all cell meta objects that were created during the Handsontable operation but for + * specyfic row index. + * + * @param {number} physicalRow The physical row index. + * @returns {object[]} + */ + + }, { + key: "getMetasAtRow", + value: function getMetasAtRow(physicalRow) { + assert(function () { + return isUnsignedNumber(physicalRow); + }, 'Expecting an unsigned number.'); + var rowsMeta = new Map(this.metas); + return rowsMeta.has(physicalRow) ? Array.from(rowsMeta.get(physicalRow).values()) : []; + } + /** + * Clears all saved cell meta objects. + */ + + }, { + key: "clearCache", + value: function clearCache() { + this.metas.clear(); + } + /** + * Creates and returns new structure for cell meta objects stored in columnar axis. + * + * @private + * @returns {object} + */ + + }, { + key: "_createRow", + value: function _createRow() { + var _this2 = this; + + return new LazyFactoryMap(function (physicalColumn) { + return _this2._createMeta(physicalColumn); + }); + } + /** + * Creates and returns new cell meta object with properties inherited from the column meta layer. + * + * @private + * @param {number} physicalColumn The physical column index. + * @returns {object} + */ + + }, { + key: "_createMeta", + value: function _createMeta(physicalColumn) { + var ColumnMeta = this.columnMeta.getMetaConstructor(physicalColumn); + return new ColumnMeta(); + } + }]); + + return CellMeta; +}(); + +function _classCallCheck$14(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } } + +function _createClass$$(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$$(Constructor.prototype, protoProps); if (staticProps) _defineProperties$$(Constructor, staticProps); return Constructor; } +/** + * With the Meta Manager class, it can be possible to manage with meta objects for different layers in + * one place. All coordinates used to fetch, updating, removing, or creating rows or columns have to + * be passed as physical values. + * + * The diagram of the meta layers: + * +-------------+. + * │ GlobalMeta │ + * │ (prototype) │ + * +-------------+\ + * │ \ + * │ \ + * \│/ _\| + * +-------------+ +-------------+. + * │ TableMeta │ │ ColumnMeta │ + * │ (instance) │ │ (prototype) │ + * +-------------+ +-------------+. + * │ + * │ + * \│/ + * +-------------+. + * │ CellMeta │ + * │ (instance) │ + * +-------------+. + * + * A more detailed description of the specific layers can be found in the "metaLayers/" modules description. + */ + +var MetaManager = /*#__PURE__*/function () { + function MetaManager() { + var customSettings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + _classCallCheck$14(this, MetaManager); + + /** + * @type {GlobalMeta} + */ + this.globalMeta = new GlobalMeta(); + this.globalMeta.updateMeta(customSettings); + /** + * @type {TableMeta} + */ + + this.tableMeta = new TableMeta(this.globalMeta); + /** + * @type {ColumnMeta} + */ + + this.columnMeta = new ColumnMeta(this.globalMeta); + /** + * @type {CellMeta} + */ + + this.cellMeta = new CellMeta(this.columnMeta); + } + /** + * Gets the global meta object that is a root of all default settings, which are recognizable by Handsontable. + * Other layers inherites all properties from this. Adding, removing, or changing property in that + * object has a direct reflection to all layers. + * + * @returns {object} + */ + + + _createClass$$(MetaManager, [{ + key: "getGlobalMeta", + value: function getGlobalMeta() { + return this.globalMeta.getMeta(); + } + /** + * Updates global settings object by merging settings with the current state. + * + * @param {object} settings An object to merge with. + */ + + }, { + key: "updateGlobalMeta", + value: function updateGlobalMeta(settings) { + this.globalMeta.updateMeta(settings); + } + /** + * Gets settings object that was passed in the Handsontable constructor. That layer contains all + * default settings inherited from the GlobalMeta layer merged with settings passed by the developer. + * Adding, removing, or changing property in that object has no direct reflection on any other layers. + * + * @returns {object} + */ + + }, { + key: "getTableMeta", + value: function getTableMeta() { + return this.tableMeta.getMeta(); + } + /** + * Updates table settings object by merging settings with the current state. + * + * @param {object} settings An object to merge with. + */ + + }, { + key: "updateTableMeta", + value: function updateTableMeta(settings) { + this.tableMeta.updateMeta(settings); + } + /** + * Gets column meta object that is a root of all settings defined in the column property of the Handsontable + * settings. Each column in the Handsontable is associated with a unique meta object which identified by + * the physical column index. Adding, removing, or changing property in that object has a direct reflection + * only for the CellMeta layer. The reflection will be visible only if the property doesn't exist in the lower + * layers (prototype lookup). + * + * @param {number} physicalColumn The physical column index. + * @returns {object} + */ + + }, { + key: "getColumnMeta", + value: function getColumnMeta(physicalColumn) { + return this.columnMeta.getMeta(physicalColumn); + } + /** + * Updates column meta object by merging settings with the current state. + * + * @param {number} physicalColumn The physical column index which points what column meta object is updated. + * @param {object} settings An object to merge with. + */ + + }, { + key: "updateColumnMeta", + value: function updateColumnMeta(physicalColumn, settings) { + this.columnMeta.updateMeta(physicalColumn, settings); + } + /** + * Gets the cell meta object that is a root of all settings defined for the specific cell rendered by + * the Handsontable. Each cell meta inherits settings from higher layers. When a property doesn't + * exist in that layer, it is looked up through a prototype to the highest layer. Starting + * from CellMeta -> ColumnMeta and ending to GlobalMeta, which stores default settings. Adding, + * removing, or changing property in that object has no direct reflection on any other layers. + * + * @param {number} physicalRow The physical row index. + * @param {number} physicalColumn The physical column index. + * @param {string} [key] If the key exists its value will be returned, otherwise the whole cell meta object. + * @returns {object} + */ + + }, { + key: "getCellMeta", + value: function getCellMeta(physicalRow, physicalColumn, key) { + return this.cellMeta.getMeta(physicalRow, physicalColumn, key); + } + /** + * Sets settings object for cell meta object defined by "key" property. + * + * @param {number} physicalRow The physical row index. + * @param {number} physicalColumn The physical column index. + * @param {string} key The property name to set. + * @param {*} value Value to save. + */ + + }, { + key: "setCellMeta", + value: function setCellMeta(physicalRow, physicalColumn, key, value) { + this.cellMeta.setMeta(physicalRow, physicalColumn, key, value); + } + /** + * Updates cell meta object by merging settings with the current state. + * + * @param {number} physicalRow The physical row index which points what cell meta object is updated. + * @param {number} physicalColumn The physical column index which points what cell meta object is updated. + * @param {object} settings An object to merge with. + */ + + }, { + key: "updateCellMeta", + value: function updateCellMeta(physicalRow, physicalColumn, settings) { + this.cellMeta.updateMeta(physicalRow, physicalColumn, settings); + } + /** + * Removes a property defined by the "key" argument from the cell meta object. + * + * @param {number} physicalRow The physical row index. + * @param {number} physicalColumn The physical column index. + * @param {string} key The property name to remove. + */ + + }, { + key: "removeCellMeta", + value: function removeCellMeta(physicalRow, physicalColumn, key) { + this.cellMeta.removeMeta(physicalRow, physicalColumn, key); + } + /** + * Returns all cell meta objects that were created during the Handsontable operation. As cell meta + * objects are created lazy, the length of the returned collection depends on how and when the + * table has asked for access to that meta objects. + * + * @returns {object[]} + */ + + }, { + key: "getCellsMeta", + value: function getCellsMeta() { + return this.cellMeta.getMetas(); + } + /** + * Returns all cell meta objects that were created during the Handsontable operation but for + * specyfic row index. + * + * @param {number} physicalRow The physical row index. + * @returns {object[]} + */ + + }, { + key: "getCellsMetaAtRow", + value: function getCellsMetaAtRow(physicalRow) { + return this.cellMeta.getMetasAtRow(physicalRow); + } + /** + * Creates one or more rows at specific position. + * + * @param {number} physicalRow The physical row index which points from what position the row is added. + * @param {number} [amount=1] An amount of rows to add. + */ + + }, { + key: "createRow", + value: function createRow(physicalRow) { + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + this.cellMeta.createRow(physicalRow, amount); + } + /** + * Removes one or more rows from the collection. + * + * @param {number} physicalRow The physical row index which points from what position the row is removed. + * @param {number} [amount=1] An amount rows to remove. + */ + + }, { + key: "removeRow", + value: function removeRow(physicalRow) { + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + this.cellMeta.removeRow(physicalRow, amount); + } + /** + * Creates one or more columns at specific position. + * + * @param {number} physicalColumn The physical column index which points from what position the column is added. + * @param {number} [amount=1] An amount of columns to add. + */ + + }, { + key: "createColumn", + value: function createColumn(physicalColumn) { + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + this.cellMeta.createColumn(physicalColumn, amount); + this.columnMeta.createColumn(physicalColumn, amount); + } + /** + * Removes one or more columns from the collection. + * + * @param {number} physicalColumn The physical column index which points from what position the column is removed. + * @param {number} [amount=1] An amount of columns to remove. + */ + + }, { + key: "removeColumn", + value: function removeColumn(physicalColumn) { + var amount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + this.cellMeta.removeColumn(physicalColumn, amount); + this.columnMeta.removeColumn(physicalColumn, amount); + } + /** + * Clears all saved cell meta objects. It keeps column meta, table meta, and global meta intact. + */ + + }, { + key: "clearCellsCache", + value: function clearCellsCache() { + this.cellMeta.clearCache(); + } + /** + * Clears all saved cell and columns meta objects. + */ + + }, { + key: "clearCache", + value: function clearCache() { + this.cellMeta.clearCache(); + this.columnMeta.clearCache(); + } + }]); + + return MetaManager; +}(); + +function _typeof$z(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$z = function _typeof(obj) { return typeof obj; }; } else { _typeof$z = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$z(obj); } + +function _slicedToArray$c(arr, i) { return _arrayWithHoles$c(arr) || _iterableToArrayLimit$c(arr, i) || _unsupportedIterableToArray$m(arr, i) || _nonIterableRest$c(); } + +function _nonIterableRest$c() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArrayLimit$c(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$c(arr) { if (Array.isArray(arr)) return arr; } + +function _toConsumableArray$h(arr) { return _arrayWithoutHoles$f(arr) || _iterableToArray$f(arr) || _unsupportedIterableToArray$m(arr) || _nonIterableSpread$f(); } + +function _nonIterableSpread$f() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$m(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$m(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$m(o, minLen); } + +function _iterableToArray$f(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$f(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$m(arr); } + +function _arrayLikeToArray$m(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } +var activeGuid = null; +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * Handsontable constructor. + * + * @core + * @class Core + * @description + * After Handsontable is constructed, you can modify the grid behavior using the available public methods. + * + * ## How to call methods. + * + * These are 2 equal ways to call a Handsontable method: + * + * ```js + * // all following examples assume that you constructed Handsontable like this + * const hot = new Handsontable(document.getElementById('example1'), options); + * + * // now, to use setDataAtCell method, you can either: + * hot.setDataAtCell(0, 0, 'new value'); + * ``` + * + * Alternatively, you can call the method using jQuery wrapper (__obsolete__, requires initialization using our jQuery guide + * ```js + * $('#example1').handsontable('setDataAtCell', 0, 0, 'new value'); + * ``` + * + * @param {HTMLElement} rootElement The element to which the Handsontable instance is injected. + * @param {object} userSettings The user defined options. + * @param {boolean} [rootInstanceSymbol=false] Indicates if the instance is root of all later instances created. + */ + +function Core(rootElement, userSettings) { + var _this = this; + + var rootInstanceSymbol = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var preventScrollingToCell = false; + var instance = this; + var eventManager = new EventManager(instance); + var datamap; + var dataSource; + var grid; + var editorManager; + var firstRun = true; + userSettings.language = getValidLanguageCode(userSettings.language); + var metaManager = new MetaManager(userSettings); + var tableMeta = metaManager.getTableMeta(); + var globalMeta = metaManager.getGlobalMeta(); + var pluginsRegistry = createUniqueMap(); + + if (hasValidParameter(rootInstanceSymbol)) { + registerAsRootInstance(this); + } // TODO: check if references to DOM elements should be move to UI layer (Walkontable) + + /** + * Reference to the container element. + * + * @private + * @type {HTMLElement} + */ + + + this.rootElement = rootElement; + /* eslint-enable jsdoc/require-description-complete-sentence */ + + /** + * The nearest document over container. + * + * @private + * @type {Document} + */ + + this.rootDocument = rootElement.ownerDocument; + /** + * Window object over container's document. + * + * @private + * @type {Window} + */ + + this.rootWindow = this.rootDocument.defaultView; + /** + * A boolean to tell if the Handsontable has been fully destroyed. This is set to `true` + * after `afterDestroy` hook is called. + * + * @memberof Core# + * @member isDestroyed + * @type {boolean} + */ + + this.isDestroyed = false; + /** + * The counter determines how many times the render suspending was called. It allows + * tracking the nested suspending calls. For each render suspend resuming call the + * counter is decremented. The value equal to 0 means the render suspending feature + * is disabled. + * + * @private + * @type {number} + */ + + this.renderSuspendedCounter = 0; + /** + * The counter determines how many times the execution suspending was called. It allows + * tracking the nested suspending calls. For each execution suspend resuming call the + * counter is decremented. The value equal to 0 means the execution suspending feature + * is disabled. + * + * @private + * @type {number} + */ + + this.executionSuspendedCounter = 0; + startObserving(this.rootDocument); + this.container = this.rootDocument.createElement('div'); + this.renderCall = false; + rootElement.insertBefore(this.container, rootElement.firstChild); + + if (isRootInstance(this)) { + _injectProductInfo(userSettings.licenseKey, rootElement); + } + + this.guid = "ht_".concat(randomString()); // this is the namespace for global events + + /** + * Instance of index mapper which is responsible for managing the column indexes. + * + * @memberof Core# + * @member columnIndexMapper + * @type {IndexMapper} + */ + + this.columnIndexMapper = new IndexMapper(); + /** + * Instance of index mapper which is responsible for managing the row indexes. + * + * @memberof Core# + * @member rowIndexMapper + * @type {IndexMapper} + */ + + this.rowIndexMapper = new IndexMapper(); + dataSource = new DataSource(instance); + + if (!this.rootElement.id || this.rootElement.id.substring(0, 3) === 'ht_') { + this.rootElement.id = this.guid; // if root element does not have an id, assign a random id + } + + var visualToRenderableCoords = function visualToRenderableCoords(coords) { + var visualRow = coords.row, + visualColumn = coords.col; + return new CellCoords( // We just store indexes for rows and columns without headers. + visualRow >= 0 ? instance.rowIndexMapper.getRenderableFromVisualIndex(visualRow) : visualRow, visualColumn >= 0 ? instance.columnIndexMapper.getRenderableFromVisualIndex(visualColumn) : visualColumn); + }; + + var renderableToVisualCoords = function renderableToVisualCoords(coords) { + var renderableRow = coords.row, + renderableColumn = coords.col; + return new CellCoords( // We just store indexes for rows and columns without headers. + renderableRow >= 0 ? instance.rowIndexMapper.getVisualFromRenderableIndex(renderableRow) : renderableRow, renderableColumn >= 0 ? instance.columnIndexMapper.getVisualFromRenderableIndex(renderableColumn) : renderableColumn // eslint-disable-line max-len + ); + }; + + var selection = new Selection$1(tableMeta, { + countCols: function countCols() { + return instance.countCols(); + }, + countRows: function countRows() { + return instance.countRows(); + }, + propToCol: function propToCol(prop) { + return datamap.propToCol(prop); + }, + isEditorOpened: function isEditorOpened() { + return instance.getActiveEditor() ? instance.getActiveEditor().isOpened() : false; + }, + countColsTranslated: function countColsTranslated() { + return _this.view.countRenderableColumns(); + }, + countRowsTranslated: function countRowsTranslated() { + return _this.view.countRenderableRows(); + }, + visualToRenderableCoords: visualToRenderableCoords, + renderableToVisualCoords: renderableToVisualCoords + }); + this.selection = selection; + + var onIndexMapperCacheUpdate = function onIndexMapperCacheUpdate(flag1, flag2, hiddenIndexesChanged) { + if (hiddenIndexesChanged) { + _this.selection.refresh(); + } + }; + + this.columnIndexMapper.addLocalHook('cacheUpdated', onIndexMapperCacheUpdate); + this.rowIndexMapper.addLocalHook('cacheUpdated', onIndexMapperCacheUpdate); + this.selection.addLocalHook('beforeSetRangeStart', function (cellCoords) { + _this.runHooks('beforeSetRangeStart', cellCoords); + }); + this.selection.addLocalHook('beforeSetRangeStartOnly', function (cellCoords) { + _this.runHooks('beforeSetRangeStartOnly', cellCoords); + }); + this.selection.addLocalHook('beforeSetRangeEnd', function (cellCoords) { + _this.runHooks('beforeSetRangeEnd', cellCoords); + + if (cellCoords.row < 0) { + cellCoords.row = _this.view.wt.wtTable.getFirstVisibleRow(); + } + + if (cellCoords.col < 0) { + cellCoords.col = _this.view.wt.wtTable.getFirstVisibleColumn(); + } + }); + this.selection.addLocalHook('afterSetRangeEnd', function (cellCoords) { + var preventScrolling = createObjectPropListener(false); + + var selectionRange = _this.selection.getSelectedRange(); + + var _selectionRange$curre = selectionRange.current(), + from = _selectionRange$curre.from, + to = _selectionRange$curre.to; + + var selectionLayerLevel = selectionRange.size() - 1; + + _this.runHooks('afterSelection', from.row, from.col, to.row, to.col, preventScrolling, selectionLayerLevel); + + _this.runHooks('afterSelectionByProp', from.row, instance.colToProp(from.col), to.row, instance.colToProp(to.col), preventScrolling, selectionLayerLevel); // eslint-disable-line max-len + + + var isSelectedByAnyHeader = _this.selection.isSelectedByAnyHeader(); + + var currentSelectedRange = _this.selection.selectedRange.current(); + + var scrollToCell = true; + + if (preventScrollingToCell) { + scrollToCell = false; + } + + if (preventScrolling.isTouched()) { + scrollToCell = !preventScrolling.value; + } + + var isSelectedByRowHeader = _this.selection.isSelectedByRowHeader(); + + var isSelectedByColumnHeader = _this.selection.isSelectedByColumnHeader(); + + if (scrollToCell !== false) { + if (!isSelectedByAnyHeader) { + if (currentSelectedRange && !_this.selection.isMultiple()) { + _this.view.scrollViewport(visualToRenderableCoords(currentSelectedRange.from)); + } else { + _this.view.scrollViewport(visualToRenderableCoords(cellCoords)); + } + } else if (isSelectedByRowHeader) { + _this.view.scrollViewportVertically(instance.rowIndexMapper.getRenderableFromVisualIndex(cellCoords.row)); + } else if (isSelectedByColumnHeader) { + _this.view.scrollViewportHorizontally(instance.columnIndexMapper.getRenderableFromVisualIndex(cellCoords.col)); + } + } // @TODO: These CSS classes are no longer needed anymore. They are used only as a indicator of the selected + // rows/columns in the MergedCells plugin (via border.js#L520 in the walkontable module). After fixing + // the Border class this should be removed. + + + if (isSelectedByRowHeader && isSelectedByColumnHeader) { + addClass(_this.rootElement, ['ht__selection--rows', 'ht__selection--columns']); + } else if (isSelectedByRowHeader) { + removeClass(_this.rootElement, 'ht__selection--columns'); + addClass(_this.rootElement, 'ht__selection--rows'); + } else if (isSelectedByColumnHeader) { + removeClass(_this.rootElement, 'ht__selection--rows'); + addClass(_this.rootElement, 'ht__selection--columns'); + } else { + removeClass(_this.rootElement, ['ht__selection--rows', 'ht__selection--columns']); + } + + _this._refreshBorders(null); + }); + this.selection.addLocalHook('afterSelectionFinished', function (cellRanges) { + var selectionLayerLevel = cellRanges.length - 1; + var _cellRanges$selection = cellRanges[selectionLayerLevel], + from = _cellRanges$selection.from, + to = _cellRanges$selection.to; + + _this.runHooks('afterSelectionEnd', from.row, from.col, to.row, to.col, selectionLayerLevel); + + _this.runHooks('afterSelectionEndByProp', from.row, instance.colToProp(from.col), to.row, instance.colToProp(to.col), selectionLayerLevel); + }); + this.selection.addLocalHook('afterIsMultipleSelection', function (isMultiple) { + var changedIsMultiple = _this.runHooks('afterIsMultipleSelection', isMultiple.value); + + if (isMultiple.value) { + isMultiple.value = changedIsMultiple; + } + }); + this.selection.addLocalHook('beforeModifyTransformStart', function (cellCoordsDelta) { + _this.runHooks('modifyTransformStart', cellCoordsDelta); + }); + this.selection.addLocalHook('afterModifyTransformStart', function (coords, rowTransformDir, colTransformDir) { + _this.runHooks('afterModifyTransformStart', coords, rowTransformDir, colTransformDir); + }); + this.selection.addLocalHook('beforeModifyTransformEnd', function (cellCoordsDelta) { + _this.runHooks('modifyTransformEnd', cellCoordsDelta); + }); + this.selection.addLocalHook('afterModifyTransformEnd', function (coords, rowTransformDir, colTransformDir) { + _this.runHooks('afterModifyTransformEnd', coords, rowTransformDir, colTransformDir); + }); + this.selection.addLocalHook('afterDeselect', function () { + editorManager.destroyEditor(); + + _this._refreshBorders(); + + removeClass(_this.rootElement, ['ht__selection--rows', 'ht__selection--columns']); + + _this.runHooks('afterDeselect'); + }); + this.selection.addLocalHook('insertRowRequire', function (totalRows) { + _this.alter('insert_row', totalRows, 1, 'auto'); + }); + this.selection.addLocalHook('insertColRequire', function (totalCols) { + _this.alter('insert_col', totalCols, 1, 'auto'); + }); + grid = { + /** + * Inserts or removes rows and columns. + * + * @memberof Core# + * @function alter + * @private + * @param {string} action Possible values: "insert_row", "insert_col", "remove_row", "remove_col". + * @param {number|Array} index Row or column visual index which from the alter action will be triggered. + * Alter actions such as "remove_row" and "remove_col" support array indexes in the + * format `[[index, amount], [index, amount]...]` this can be used to remove + * non-consecutive columns or rows in one call. + * @param {number} [amount=1] Ammount rows or columns to remove. + * @param {string} [source] Optional. Source of hook runner. + * @param {boolean} [keepEmptyRows] Optional. Flag for preventing deletion of empty rows. + */ + alter: function alter(action, index) { + var amount = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1; + var source = arguments.length > 3 ? arguments[3] : undefined; + var keepEmptyRows = arguments.length > 4 ? arguments[4] : undefined; + var delta; + + var normalizeIndexesGroup = function normalizeIndexesGroup(indexes) { + if (indexes.length === 0) { + return []; + } + + var sortedIndexes = _toConsumableArray$h(indexes); // Sort the indexes in ascending order. + + + sortedIndexes.sort(function (_ref, _ref2) { + var _ref3 = _slicedToArray$c(_ref, 1), + indexA = _ref3[0]; + + var _ref4 = _slicedToArray$c(_ref2, 1), + indexB = _ref4[0]; + + if (indexA === indexB) { + return 0; + } + + return indexA > indexB ? 1 : -1; + }); // Normalize the {index, amount} groups into bigger groups. + + var normalizedIndexes = arrayReduce(sortedIndexes, function (acc, _ref5) { + var _ref6 = _slicedToArray$c(_ref5, 2), + groupIndex = _ref6[0], + groupAmount = _ref6[1]; + + var previousItem = acc[acc.length - 1]; + + var _previousItem = _slicedToArray$c(previousItem, 2), + prevIndex = _previousItem[0], + prevAmount = _previousItem[1]; + + var prevLastIndex = prevIndex + prevAmount; + + if (groupIndex <= prevLastIndex) { + var amountToAdd = Math.max(groupAmount - (prevLastIndex - groupIndex), 0); + previousItem[1] += amountToAdd; + } else { + acc.push([groupIndex, groupAmount]); + } + + return acc; + }, [sortedIndexes[0]]); + return normalizedIndexes; + }; + /* eslint-disable no-case-declarations */ + + + switch (action) { + case 'insert_row': + var numberOfSourceRows = instance.countSourceRows(); + + if (tableMeta.maxRows === numberOfSourceRows) { + return; + } // eslint-disable-next-line no-param-reassign + + + index = isDefined(index) ? index : numberOfSourceRows; + delta = datamap.createRow(index, amount, source); + + if (delta) { + metaManager.createRow(instance.toPhysicalRow(index), amount); + var currentSelectedRange = selection.selectedRange.current(); + var currentFromRange = currentSelectedRange === null || currentSelectedRange === void 0 ? void 0 : currentSelectedRange.from; + var currentFromRow = currentFromRange === null || currentFromRange === void 0 ? void 0 : currentFromRange.row; // Moving down the selection (when it exist). It should be present on the "old" row. + // TODO: The logic here should be handled by selection module. + + if (isDefined(currentFromRow) && currentFromRow >= index) { + var _currentSelectedRange = currentSelectedRange.to, + currentToRow = _currentSelectedRange.row, + currentToColumn = _currentSelectedRange.col; + var currentFromColumn = currentFromRange.col; // Workaround: headers are not stored inside selection. + + if (selection.isSelectedByRowHeader()) { + currentFromColumn = -1; + } // Remove from the stack the last added selection as that selection below will be + // replaced by new transformed selection. + + + selection.getSelectedRange().pop(); // I can't use transforms as they don't work in negative indexes. + + selection.setRangeStartOnly(new CellCoords(currentFromRow + delta, currentFromColumn), true); + selection.setRangeEnd(new CellCoords(currentToRow + delta, currentToColumn)); // will call render() internally + } else { + instance._refreshBorders(); // it will call render and prepare methods + + } + } + + break; + + case 'insert_col': + delta = datamap.createCol(index, amount, source); + + if (delta) { + metaManager.createColumn(instance.toPhysicalColumn(index), amount); + + if (Array.isArray(tableMeta.colHeaders)) { + var spliceArray = [index, 0]; + spliceArray.length += delta; // inserts empty (undefined) elements at the end of an array + + Array.prototype.splice.apply(tableMeta.colHeaders, spliceArray); // inserts empty (undefined) elements into the colHeader array + } + + var _currentSelectedRange2 = selection.selectedRange.current(); + + var _currentFromRange = _currentSelectedRange2 === null || _currentSelectedRange2 === void 0 ? void 0 : _currentSelectedRange2.from; + + var _currentFromColumn = _currentFromRange === null || _currentFromRange === void 0 ? void 0 : _currentFromRange.col; // Moving right the selection (when it exist). It should be present on the "old" row. + // TODO: The logic here should be handled by selection module. + + + if (isDefined(_currentFromColumn) && _currentFromColumn >= index) { + var _currentSelectedRange3 = _currentSelectedRange2.to, + _currentToRow = _currentSelectedRange3.row, + _currentToColumn = _currentSelectedRange3.col; + var _currentFromRow = _currentFromRange.row; // Workaround: headers are not stored inside selection. + + if (selection.isSelectedByColumnHeader()) { + _currentFromRow = -1; + } // Remove from the stack the last added selection as that selection below will be + // replaced by new transformed selection. + + + selection.getSelectedRange().pop(); // I can't use transforms as they don't work in negative indexes. + + selection.setRangeStartOnly(new CellCoords(_currentFromRow, _currentFromColumn + delta), true); + selection.setRangeEnd(new CellCoords(_currentToRow, _currentToColumn + delta)); // will call render() internally + } else { + instance._refreshBorders(); // it will call render and prepare methods + + } + } + + break; + + case 'remove_row': + var removeRow = function removeRow(indexes) { + var offset = 0; // Normalize the {index, amount} groups into bigger groups. + + arrayEach(indexes, function (_ref7) { + var _ref8 = _slicedToArray$c(_ref7, 2), + groupIndex = _ref8[0], + groupAmount = _ref8[1]; + + var calcIndex = isEmpty(groupIndex) ? instance.countRows() - 1 : Math.max(groupIndex - offset, 0); // If the 'index' is an integer decrease it by 'offset' otherwise pass it through to make the value + // compatible with datamap.removeCol method. + + if (Number.isInteger(groupIndex)) { + // eslint-disable-next-line no-param-reassign + groupIndex = Math.max(groupIndex - offset, 0); + } // TODO: for datamap.removeRow index should be passed as it is (with undefined and null values). If not, the logic + // inside the datamap.removeRow breaks the removing functionality. + + + var wasRemoved = datamap.removeRow(groupIndex, groupAmount, source); + + if (!wasRemoved) { + return; + } + + metaManager.removeRow(instance.toPhysicalRow(calcIndex), groupAmount); + var totalRows = instance.countRows(); + var fixedRowsTop = tableMeta.fixedRowsTop; + + if (fixedRowsTop >= calcIndex + 1) { + tableMeta.fixedRowsTop -= Math.min(groupAmount, fixedRowsTop - calcIndex); + } + + var fixedRowsBottom = tableMeta.fixedRowsBottom; + + if (fixedRowsBottom && calcIndex >= totalRows - fixedRowsBottom) { + tableMeta.fixedRowsBottom -= Math.min(groupAmount, fixedRowsBottom); + } + + offset += groupAmount; + }); + }; + + if (Array.isArray(index)) { + removeRow(normalizeIndexesGroup(index)); + } else { + removeRow([[index, amount]]); + } + + grid.adjustRowsAndCols(); + + instance._refreshBorders(); // it will call render and prepare methods + + + break; + + case 'remove_col': + var removeCol = function removeCol(indexes) { + var offset = 0; // Normalize the {index, amount} groups into bigger groups. + + arrayEach(indexes, function (_ref9) { + var _ref10 = _slicedToArray$c(_ref9, 2), + groupIndex = _ref10[0], + groupAmount = _ref10[1]; + + var calcIndex = isEmpty(groupIndex) ? instance.countCols() - 1 : Math.max(groupIndex - offset, 0); + var physicalColumnIndex = instance.toPhysicalColumn(calcIndex); // If the 'index' is an integer decrease it by 'offset' otherwise pass it through to make the value + // compatible with datamap.removeCol method. + + if (Number.isInteger(groupIndex)) { + // eslint-disable-next-line no-param-reassign + groupIndex = Math.max(groupIndex - offset, 0); + } // TODO: for datamap.removeCol index should be passed as it is (with undefined and null values). If not, the logic + // inside the datamap.removeCol breaks the removing functionality. + + + var wasRemoved = datamap.removeCol(groupIndex, groupAmount, source); + + if (!wasRemoved) { + return; + } + + metaManager.removeColumn(physicalColumnIndex, groupAmount); + var fixedColumnsLeft = tableMeta.fixedColumnsLeft; + + if (fixedColumnsLeft >= calcIndex + 1) { + tableMeta.fixedColumnsLeft -= Math.min(groupAmount, fixedColumnsLeft - calcIndex); + } + + if (Array.isArray(tableMeta.colHeaders)) { + if (typeof physicalColumnIndex === 'undefined') { + physicalColumnIndex = -1; + } + + tableMeta.colHeaders.splice(physicalColumnIndex, groupAmount); + } + + offset += groupAmount; + }); + }; + + if (Array.isArray(index)) { + removeCol(normalizeIndexesGroup(index)); + } else { + removeCol([[index, amount]]); + } + + grid.adjustRowsAndCols(); + + instance._refreshBorders(); // it will call render and prepare methods + + + break; + + default: + throw new Error("There is no such action \"".concat(action, "\"")); + } + + if (!keepEmptyRows) { + grid.adjustRowsAndCols(); // makes sure that we did not add rows that will be removed in next refresh + } + }, + + /** + * Makes sure there are empty rows at the bottom of the table. + */ + adjustRowsAndCols: function adjustRowsAndCols() { + var minRows = tableMeta.minRows; + var minSpareRows = tableMeta.minSpareRows; + var minCols = tableMeta.minCols; + var minSpareCols = tableMeta.minSpareCols; + + if (minRows) { + // should I add empty rows to data source to meet minRows? + var nrOfRows = instance.countRows(); + + if (nrOfRows < minRows) { + // The synchronization with cell meta is not desired here. For `minRows` option, + // we don't want to touch/shift cell meta objects. + datamap.createRow(nrOfRows, minRows - nrOfRows, 'auto'); + } + } + + if (minSpareRows) { + var emptyRows = instance.countEmptyRows(true); // should I add empty rows to meet minSpareRows? + + if (emptyRows < minSpareRows) { + var emptyRowsMissing = minSpareRows - emptyRows; + var rowsToCreate = Math.min(emptyRowsMissing, tableMeta.maxRows - instance.countSourceRows()); // The synchronization with cell meta is not desired here. For `minSpareRows` option, + // we don't want to touch/shift cell meta objects. + + datamap.createRow(instance.countRows(), rowsToCreate, 'auto'); + } + } + + { + var emptyCols; // count currently empty cols + + if (minCols || minSpareCols) { + emptyCols = instance.countEmptyCols(true); + } + + var nrOfColumns = instance.countCols(); // should I add empty cols to meet minCols? + + if (minCols && !tableMeta.columns && nrOfColumns < minCols) { + // The synchronization with cell meta is not desired here. For `minSpareRows` option, + // we don't want to touch/shift cell meta objects. + var colsToCreate = minCols - nrOfColumns; + emptyCols += colsToCreate; + datamap.createCol(nrOfColumns, colsToCreate, 'auto'); + } // should I add empty cols to meet minSpareCols? + + + if (minSpareCols && !tableMeta.columns && instance.dataType === 'array' && emptyCols < minSpareCols) { + nrOfColumns = instance.countCols(); + var emptyColsMissing = minSpareCols - emptyCols; + + var _colsToCreate = Math.min(emptyColsMissing, tableMeta.maxCols - nrOfColumns); // The synchronization with cell meta is not desired here. For `minSpareRows` option, + // we don't want to touch/shift cell meta objects. + + + datamap.createCol(nrOfColumns, _colsToCreate, 'auto'); + } + } + var rowCount = instance.countRows(); + var colCount = instance.countCols(); + + if (rowCount === 0 || colCount === 0) { + selection.deselect(); + } + + if (selection.isSelected()) { + arrayEach(selection.selectedRange, function (range) { + var selectionChanged = false; + var fromRow = range.from.row; + var fromCol = range.from.col; + var toRow = range.to.row; + var toCol = range.to.col; // if selection is outside, move selection to last row + + if (fromRow > rowCount - 1) { + fromRow = rowCount - 1; + selectionChanged = true; + + if (toRow > fromRow) { + toRow = fromRow; + } + } else if (toRow > rowCount - 1) { + toRow = rowCount - 1; + selectionChanged = true; + + if (fromRow > toRow) { + fromRow = toRow; + } + } // if selection is outside, move selection to last row + + + if (fromCol > colCount - 1) { + fromCol = colCount - 1; + selectionChanged = true; + + if (toCol > fromCol) { + toCol = fromCol; + } + } else if (toCol > colCount - 1) { + toCol = colCount - 1; + selectionChanged = true; + + if (fromCol > toCol) { + fromCol = toCol; + } + } + + if (selectionChanged) { + instance.selectCell(fromRow, fromCol, toRow, toCol); + } + }); + } + + if (instance.view) { + instance.view.adjustElementsSize(); + } + }, + + /** + * Populate the data from the provided 2d array from the given cell coordinates. + * + * @private + * @param {object} start Start selection position. Visual indexes. + * @param {Array} input 2d data array. + * @param {object} [end] End selection position (only for drag-down mode). Visual indexes. + * @param {string} [source="populateFromArray"] Source information string. + * @param {string} [method="overwrite"] Populate method. Possible options: `shift_down`, `shift_right`, `overwrite`. + * @param {string} direction (left|right|up|down) String specifying the direction. + * @param {Array} deltas The deltas array. A difference between values of adjacent cells. + * Useful **only** when the type of handled cells is `numeric`. + * @returns {object|undefined} Ending td in pasted area (only if any cell was changed). + */ + populateFromArray: function populateFromArray(start, input, end, source, method, direction, deltas) { + // TODO: either remove or implement the `direction` argument. Currently it's not working at all. + var r; + var rlen; + var c; + var clen; + var setData = []; + var current = {}; + rlen = input.length; + + if (rlen === 0) { + return false; + } + + var repeatCol; + var repeatRow; + var cmax; + var rmax; + /* eslint-disable no-case-declarations */ + // insert data with specified pasteMode method + + switch (method) { + case 'shift_down': + repeatCol = end ? end.col - start.col + 1 : 0; + repeatRow = end ? end.row - start.row + 1 : 0; // eslint-disable-next-line no-param-reassign + + input = translateRowsToColumns(input); + + for (c = 0, clen = input.length, cmax = Math.max(clen, repeatCol); c < cmax; c++) { + if (c < clen) { + var _instance; + + for (r = 0, rlen = input[c].length; r < repeatRow - rlen; r++) { + input[c].push(input[c][r % rlen]); + } + + input[c].unshift(start.col + c, start.row, 0); + + (_instance = instance).spliceCol.apply(_instance, _toConsumableArray$h(input[c])); + } else { + var _instance2; + + input[c % clen][0] = start.col + c; + + (_instance2 = instance).spliceCol.apply(_instance2, _toConsumableArray$h(input[c % clen])); + } + } + + break; + + case 'shift_right': + repeatCol = end ? end.col - start.col + 1 : 0; + repeatRow = end ? end.row - start.row + 1 : 0; + + for (r = 0, rlen = input.length, rmax = Math.max(rlen, repeatRow); r < rmax; r++) { + if (r < rlen) { + var _instance3; + + for (c = 0, clen = input[r].length; c < repeatCol - clen; c++) { + input[r].push(input[r][c % clen]); + } + + input[r].unshift(start.row + r, start.col, 0); + + (_instance3 = instance).spliceRow.apply(_instance3, _toConsumableArray$h(input[r])); + } else { + var _instance4; + + input[r % rlen][0] = start.row + r; + + (_instance4 = instance).spliceRow.apply(_instance4, _toConsumableArray$h(input[r % rlen])); + } + } + + break; + + case 'overwrite': + default: + // overwrite and other not specified options + current.row = start.row; + current.col = start.col; + var selected = { + // selected range + row: end && start ? end.row - start.row + 1 : 1, + col: end && start ? end.col - start.col + 1 : 1 + }; + var skippedRow = 0; + var skippedColumn = 0; + var pushData = true; + var cellMeta; + + var getInputValue = function getInputValue(row) { + var col = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var rowValue = input[row % input.length]; + + if (col !== null) { + return rowValue[col % rowValue.length]; + } + + return rowValue; + }; + + var rowInputLength = input.length; + var rowSelectionLength = end ? end.row - start.row + 1 : 0; + + if (end) { + rlen = rowSelectionLength; + } else { + rlen = Math.max(rowInputLength, rowSelectionLength); + } + + for (r = 0; r < rlen; r++) { + if (end && current.row > end.row && rowSelectionLength > rowInputLength || !tableMeta.allowInsertRow && current.row > instance.countRows() - 1 || current.row >= tableMeta.maxRows) { + break; + } + + var visualRow = r - skippedRow; + var colInputLength = getInputValue(visualRow).length; + var colSelectionLength = end ? end.col - start.col + 1 : 0; + + if (end) { + clen = colSelectionLength; + } else { + clen = Math.max(colInputLength, colSelectionLength); + } + + current.col = start.col; + cellMeta = instance.getCellMeta(current.row, current.col); + + if ((source === 'CopyPaste.paste' || source === 'Autofill.fill') && cellMeta.skipRowOnPaste) { + skippedRow += 1; + current.row += 1; + rlen += 1; + /* eslint-disable no-continue */ + + continue; + } + + skippedColumn = 0; + + for (c = 0; c < clen; c++) { + if (end && current.col > end.col && colSelectionLength > colInputLength || !tableMeta.allowInsertColumn && current.col > instance.countCols() - 1 || current.col >= tableMeta.maxCols) { + break; + } + + cellMeta = instance.getCellMeta(current.row, current.col); + + if ((source === 'CopyPaste.paste' || source === 'Autofill.fill') && cellMeta.skipColumnOnPaste) { + skippedColumn += 1; + current.col += 1; + clen += 1; + continue; + } + + if (cellMeta.readOnly) { + current.col += 1; + /* eslint-disable no-continue */ + + continue; + } + + var visualColumn = c - skippedColumn; + var value = getInputValue(visualRow, visualColumn); + var orgValue = instance.getDataAtCell(current.row, current.col); + var index = { + row: visualRow, + col: visualColumn + }; + + if (source === 'Autofill.fill') { + var result = instance.runHooks('beforeAutofillInsidePopulate', index, direction, input, deltas, {}, selected); + + if (result) { + value = isUndefined(result.value) ? value : result.value; + } + } + + if (value !== null && _typeof$z(value) === 'object') { + // when 'value' is array and 'orgValue' is null, set 'orgValue' to + // an empty array so that the null value can be compared to 'value' + // as an empty value for the array context + if (Array.isArray(value) && orgValue === null) orgValue = []; + + if (orgValue === null || _typeof$z(orgValue) !== 'object') { + pushData = false; + } else { + var orgValueSchema = duckSchema(Array.isArray(orgValue) ? orgValue : orgValue[0] || orgValue); + var valueSchema = duckSchema(Array.isArray(value) ? value : value[0] || value); + /* eslint-disable max-depth */ + + if (isObjectEqual(orgValueSchema, valueSchema)) { + value = deepClone(value); + } else { + pushData = false; + } + } + } else if (orgValue !== null && _typeof$z(orgValue) === 'object') { + pushData = false; + } + + if (pushData) { + setData.push([current.row, current.col, value]); + } + + pushData = true; + current.col += 1; + } + + current.row += 1; + } + + instance.setDataAtCell(setData, null, null, source || 'populateFromArray'); + break; + } + } + }; + /** + * Internal function to set `language` key of settings. + * + * @private + * @param {string} languageCode Language code for specific language i.e. 'en-US', 'pt-BR', 'de-DE'. + * @fires Hooks#afterLanguageChange + */ + + function setLanguage(languageCode) { + var normalizedLanguageCode = normalizeLanguageCode(languageCode); + + if (hasLanguageDictionary(normalizedLanguageCode)) { + instance.runHooks('beforeLanguageChange', normalizedLanguageCode); + globalMeta.language = normalizedLanguageCode; + instance.runHooks('afterLanguageChange', normalizedLanguageCode); + } else { + warnUserAboutLanguageRegistration(languageCode); + } + } + /** + * Internal function to set `className` or `tableClassName`, depending on the key from the settings object. + * + * @private + * @param {string} className `className` or `tableClassName` from the key in the settings object. + * @param {string|string[]} classSettings String or array of strings. Contains class name(s) from settings object. + */ + + + function setClassName(className, classSettings) { + var element = className === 'className' ? instance.rootElement : instance.table; + + if (firstRun) { + addClass(element, classSettings); + } else { + var globalMetaSettingsArray = []; + var settingsArray = []; + + if (globalMeta[className]) { + globalMetaSettingsArray = Array.isArray(globalMeta[className]) ? globalMeta[className] : stringToArray(globalMeta[className]); + } + + if (classSettings) { + settingsArray = Array.isArray(classSettings) ? classSettings : stringToArray(classSettings); + } + + var classNameToRemove = getDifferenceOfArrays(globalMetaSettingsArray, settingsArray); + var classNameToAdd = getDifferenceOfArrays(settingsArray, globalMetaSettingsArray); + + if (classNameToRemove.length) { + removeClass(element, classNameToRemove); + } + + if (classNameToAdd.length) { + addClass(element, classNameToAdd); + } + } + + globalMeta[className] = classSettings; + } + + this.init = function () { + dataSource.setData(tableMeta.data); + instance.runHooks('beforeInit'); + + if (isMobileBrowser()) { + addClass(instance.rootElement, 'mobile'); + } + + this.updateSettings(tableMeta, true); + this.view = new TableView(this); + editorManager = EditorManager.getInstance(instance, tableMeta, selection); + instance.runHooks('init'); + this.forceFullRender = true; // used when data was changed + + this.view.render(); + + if (_typeof$z(firstRun) === 'object') { + instance.runHooks('afterChange', firstRun[0], firstRun[1]); + firstRun = false; + } + + instance.runHooks('afterInit'); + }; + /** + * @ignore + * @returns {object} + */ + + + function ValidatorsQueue() { + // moved this one level up so it can be used in any function here. Probably this should be moved to a separate file + var resolved = false; + return { + validatorsInQueue: 0, + valid: true, + addValidatorToQueue: function addValidatorToQueue() { + this.validatorsInQueue += 1; + resolved = false; + }, + removeValidatorFormQueue: function removeValidatorFormQueue() { + this.validatorsInQueue = this.validatorsInQueue - 1 < 0 ? 0 : this.validatorsInQueue - 1; + this.checkIfQueueIsEmpty(); + }, + onQueueEmpty: function onQueueEmpty() {}, + checkIfQueueIsEmpty: function checkIfQueueIsEmpty() { + if (this.validatorsInQueue === 0 && resolved === false) { + resolved = true; + this.onQueueEmpty(this.valid); + } + } + }; + } + /** + * Get parsed number from numeric string. + * + * @private + * @param {string} numericData Float (separated by a dot or a comma) or integer. + * @returns {number} Number if we get data in parsable format, not changed value otherwise. + */ + + + function getParsedNumber(numericData) { + // Unifying "float like" string. Change from value with comma determiner to value with dot determiner, + // for example from `450,65` to `450.65`. + var unifiedNumericData = numericData.replace(',', '.'); + + if (isNaN(parseFloat(unifiedNumericData)) === false) { + return parseFloat(unifiedNumericData); + } + + return numericData; + } + /** + * @ignore + * @param {Array} changes The 2D array containing information about each of the edited cells. + * @param {string} source The string that identifies source of validation. + * @param {Function} callback The callback function fot async validation. + */ + + + function validateChanges(changes, source, callback) { + if (!changes.length) { + return; + } + + var activeEditor = instance.getActiveEditor(); + var beforeChangeResult = instance.runHooks('beforeChange', changes, source || 'edit'); + var shouldBeCanceled = true; + + if (beforeChangeResult === false) { + if (activeEditor) { + activeEditor.cancelChanges(); + } + + return; + } + + var waitingForValidator = new ValidatorsQueue(); + + var isNumericData = function isNumericData(value) { + return value.length > 0 && /^\s*[+-.]?\s*(?:(?:\d+(?:(\.|,)\d+)?(?:e[+-]?\d+)?)|(?:0x[a-f\d]+))\s*$/.test(value); + }; + + waitingForValidator.onQueueEmpty = function (isValid) { + if (activeEditor && shouldBeCanceled) { + activeEditor.cancelChanges(); + } + + callback(isValid); // called when async validators are resolved and beforeChange was not async + }; + + for (var i = changes.length - 1; i >= 0; i--) { + if (changes[i] === null) { + changes.splice(i, 1); + } else { + var _changes$i = _slicedToArray$c(changes[i], 4), + row = _changes$i[0], + prop = _changes$i[1], + newValue = _changes$i[3]; + + var col = datamap.propToCol(prop); + var cellProperties = instance.getCellMeta(row, col); + + if (cellProperties.type === 'numeric' && typeof newValue === 'string' && isNumericData(newValue)) { + changes[i][3] = getParsedNumber(newValue); + } + /* eslint-disable no-loop-func */ + + + if (instance.getCellValidator(cellProperties)) { + waitingForValidator.addValidatorToQueue(); + instance.validateCell(changes[i][3], cellProperties, function (index, cellPropertiesReference) { + return function (result) { + if (typeof result !== 'boolean') { + throw new Error('Validation error: result is not boolean'); + } + + if (result === false && cellPropertiesReference.allowInvalid === false) { + shouldBeCanceled = false; + changes.splice(index, 1); // cancel the change + + cellPropertiesReference.valid = true; // we cancelled the change, so cell value is still valid + + var cell = instance.getCell(cellPropertiesReference.visualRow, cellPropertiesReference.visualCol); + + if (cell !== null) { + removeClass(cell, tableMeta.invalidCellClassName); + } // index -= 1; + + } + + waitingForValidator.removeValidatorFormQueue(); + }; + }(i, cellProperties), source); + } + } + } + + waitingForValidator.checkIfQueueIsEmpty(); + } + /** + * Internal function to apply changes. Called after validateChanges. + * + * @private + * @param {Array} changes Array in form of [row, prop, oldValue, newValue]. + * @param {string} source String that identifies how this change will be described in changes array (useful in onChange callback). + * @fires Hooks#beforeChangeRender + * @fires Hooks#afterChange + */ + + + function applyChanges(changes, source) { + var i = changes.length - 1; + + if (i < 0) { + return; + } + + for (; i >= 0; i--) { + var skipThisChange = false; + + if (changes[i] === null) { + changes.splice(i, 1); + /* eslint-disable no-continue */ + + continue; + } + + if ((changes[i][2] === null || changes[i][2] === void 0) && (changes[i][3] === null || changes[i][3] === void 0)) { + /* eslint-disable no-continue */ + continue; + } + + if (tableMeta.allowInsertRow) { + while (changes[i][0] > instance.countRows() - 1) { + var numberOfCreatedRows = datamap.createRow(void 0, void 0, source); + + if (numberOfCreatedRows >= 1) { + metaManager.createRow(null, numberOfCreatedRows); + } else { + skipThisChange = true; + break; + } + } + } + + if (instance.dataType === 'array' && (!tableMeta.columns || tableMeta.columns.length === 0) && tableMeta.allowInsertColumn) { + while (datamap.propToCol(changes[i][1]) > instance.countCols() - 1) { + var numberOfCreatedColumns = datamap.createCol(void 0, void 0, source); + + if (numberOfCreatedColumns >= 1) { + metaManager.createColumn(null, numberOfCreatedColumns); + } else { + skipThisChange = true; + break; + } + } + } + + if (skipThisChange) { + /* eslint-disable no-continue */ + continue; + } + + datamap.set(changes[i][0], changes[i][1], changes[i][3]); + } + + instance.forceFullRender = true; // used when data was changed + + grid.adjustRowsAndCols(); + instance.runHooks('beforeChangeRender', changes, source); + editorManager.lockEditor(); + + instance._refreshBorders(null); + + editorManager.unlockEditor(); + instance.view.adjustElementsSize(); + instance.runHooks('afterChange', changes, source || 'edit'); + var activeEditor = instance.getActiveEditor(); + + if (activeEditor && isDefined(activeEditor.refreshValue)) { + activeEditor.refreshValue(); + } + } + /** + * Validate a single cell. + * + * @param {string|number} value The value to validate. + * @param {object} cellProperties The cell meta which corresponds with the value. + * @param {Function} callback The callback function. + * @param {string} source The string that identifies source of the validation. + */ + + + this.validateCell = function (value, cellProperties, callback, source) { + var validator = instance.getCellValidator(cellProperties); // the `canBeValidated = false` argument suggests, that the cell passes validation by default. + + /** + * @param {boolean} valid Indicates if the validation was successful. + * @param {boolean} [canBeValidated=true] Flag which controls the validation process. + */ + + function done(valid) { + var canBeValidated = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + + // Fixes GH#3903 + if (!canBeValidated || cellProperties.hidden === true) { + callback(valid); + return; + } + + var col = cellProperties.visualCol; + var row = cellProperties.visualRow; + var td = instance.getCell(row, col, true); + + if (td && td.nodeName !== 'TH') { + var renderableRow = instance.rowIndexMapper.getRenderableFromVisualIndex(row); + var renderableColumn = instance.columnIndexMapper.getRenderableFromVisualIndex(col); + instance.view.wt.wtSettings.settings.cellRenderer(renderableRow, renderableColumn, td); + } + + callback(valid); + } + + if (isRegExp(validator)) { + validator = function (expression) { + return function (cellValue, validatorCallback) { + validatorCallback(expression.test(cellValue)); + }; + }(validator); + } + + if (isFunction(validator)) { + // eslint-disable-next-line no-param-reassign + value = instance.runHooks('beforeValidate', value, cellProperties.visualRow, cellProperties.prop, source); // To provide consistent behaviour, validation should be always asynchronous + + instance._registerImmediate(function () { + validator.call(cellProperties, value, function (valid) { + if (!instance) { + return; + } // eslint-disable-next-line no-param-reassign + + + valid = instance.runHooks('afterValidate', valid, value, cellProperties.visualRow, cellProperties.prop, source); + cellProperties.valid = valid; + done(valid); + instance.runHooks('postAfterValidate', valid, value, cellProperties.visualRow, cellProperties.prop, source); + }); + }); + } else { + // resolve callback even if validator function was not found + instance._registerImmediate(function () { + cellProperties.valid = true; + done(cellProperties.valid, false); + }); + } + }; + /** + * @ignore + * @param {number} row The visual row index. + * @param {string|number} propOrCol The visual prop or column index. + * @param {*} value The cell value. + * @returns {Array} + */ + + + function setDataInputToArray(row, propOrCol, value) { + if (Array.isArray(row)) { + // it's an array of changes + return row; + } + + return [[row, propOrCol, value]]; + } + /** + * @description + * Set new value to a cell. To change many cells at once (recommended way), pass an array of `changes` in format + * `[[row, col, value],...]` as the first argument. + * + * @memberof Core# + * @function setDataAtCell + * @param {number|Array} row Visual row index or array of changes in format `[[row, col, value],...]`. + * @param {number} [column] Visual column index. + * @param {string} [value] New value. + * @param {string} [source] String that identifies how this change will be described in the changes array (useful in afterChange or beforeChange callback). Set to 'edit' if left empty. + */ + + + this.setDataAtCell = function (row, column, value, source) { + var input = setDataInputToArray(row, column, value); + var changes = []; + var changeSource = source; + var i; + var ilen; + var prop; + + for (i = 0, ilen = input.length; i < ilen; i++) { + if (_typeof$z(input[i]) !== 'object') { + throw new Error('Method `setDataAtCell` accepts row number or changes array of arrays as its first parameter'); + } + + if (typeof input[i][1] !== 'number') { + throw new Error('Method `setDataAtCell` accepts row and column number as its parameters. If you want to use object property name, use method `setDataAtRowProp`'); // eslint-disable-line max-len + } + + if (input[i][1] >= this.countCols()) { + prop = input[i][1]; + } else { + prop = datamap.colToProp(input[i][1]); + } + + changes.push([input[i][0], prop, dataSource.getAtCell(this.toPhysicalRow(input[i][0]), input[i][1]), input[i][2]]); + } + + if (!changeSource && _typeof$z(row) === 'object') { + changeSource = column; + } + + instance.runHooks('afterSetDataAtCell', changes, changeSource); + validateChanges(changes, changeSource, function () { + applyChanges(changes, changeSource); + }); + }; + /** + * @description + * Set new value to a cell. To change many cells at once (recommended way), pass an array of `changes` in format + * `[[row, prop, value],...]` as the first argument. + * + * @memberof Core# + * @function setDataAtRowProp + * @param {number|Array} row Visual row index or array of changes in format `[[row, prop, value], ...]`. + * @param {string} prop Property name or the source string (e.g. `'first.name'` or `'0'`). + * @param {string} value Value to be set. + * @param {string} [source] String that identifies how this change will be described in changes array (useful in onChange callback). + */ + + + this.setDataAtRowProp = function (row, prop, value, source) { + var input = setDataInputToArray(row, prop, value); + var changes = []; + var changeSource = source; + var i; + var ilen; + + for (i = 0, ilen = input.length; i < ilen; i++) { + changes.push([input[i][0], input[i][1], dataSource.getAtCell(this.toPhysicalRow(input[i][0]), input[i][1]), input[i][2]]); + } + + if (!changeSource && _typeof$z(row) === 'object') { + changeSource = prop; + } + + instance.runHooks('afterSetDataAtRowProp', changes, changeSource); + validateChanges(changes, changeSource, function () { + applyChanges(changes, changeSource); + }); + }; + /** + * Listen to the keyboard input on document body. This allows Handsontable to capture keyboard events and respond + * in the right way. + * + * @memberof Core# + * @function listen + * @fires Hooks#afterListen + */ + + + this.listen = function () { + if (instance && !instance.isListening()) { + activeGuid = instance.guid; + instance.runHooks('afterListen'); + } + }; + /** + * Stop listening to keyboard input on the document body. Calling this method makes the Handsontable inactive for + * any keyboard events. + * + * @memberof Core# + * @function unlisten + */ + + + this.unlisten = function () { + if (this.isListening()) { + activeGuid = null; + instance.runHooks('afterUnlisten'); + } + }; + /** + * Returns `true` if the current Handsontable instance is listening to keyboard input on document body. + * + * @memberof Core# + * @function isListening + * @returns {boolean} `true` if the instance is listening, `false` otherwise. + */ + + + this.isListening = function () { + return activeGuid === instance.guid; + }; + /** + * Destroys the current editor, render the table and prepares the editor of the newly selected cell. + * + * @memberof Core# + * @function destroyEditor + * @param {boolean} [revertOriginal=false] If `true`, the previous value will be restored. Otherwise, the edited value will be saved. + * @param {boolean} [prepareEditorIfNeeded=true] If `true` the editor under the selected cell will be prepared to open. + */ + + + this.destroyEditor = function () { + var revertOriginal = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var prepareEditorIfNeeded = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + + instance._refreshBorders(revertOriginal, prepareEditorIfNeeded); + }; + /** + * Populate cells at position with 2D input array (e.g. `[[1, 2], [3, 4]]`). Use `endRow`, `endCol` when you + * want to cut input when a certain row is reached. + * + * Optional `method` argument has the same effect as pasteMode option (see {@link Options#pasteMode}). + * + * @memberof Core# + * @function populateFromArray + * @param {number} row Start visual row index. + * @param {number} column Start visual column index. + * @param {Array} input 2d array. + * @param {number} [endRow] End visual row index (use when you want to cut input when certain row is reached). + * @param {number} [endCol] End visual column index (use when you want to cut input when certain column is reached). + * @param {string} [source=populateFromArray] Used to identify this call in the resulting events (beforeChange, afterChange). + * @param {string} [method=overwrite] Populate method, possible values: `'shift_down'`, `'shift_right'`, `'overwrite'`. + * @param {string} direction Populate direction, possible values: `'left'`, `'right'`, `'up'`, `'down'`. + * @param {Array} deltas The deltas array. A difference between values of adjacent cells. + * Useful **only** when the type of handled cells is `numeric`. + * @returns {object|undefined} Ending td in pasted area (only if any cell was changed). + */ + + + this.populateFromArray = function (row, column, input, endRow, endCol, source, method, direction, deltas) { + if (!(_typeof$z(input) === 'object' && _typeof$z(input[0]) === 'object')) { + throw new Error('populateFromArray parameter `input` must be an array of arrays'); // API changed in 0.9-beta2, let's check if you use it correctly + } + + var c = typeof endRow === 'number' ? new CellCoords(endRow, endCol) : null; + return grid.populateFromArray(new CellCoords(row, column), input, c, source, method, direction, deltas); + }; + /** + * Adds/removes data from the column. This method works the same as Array.splice for arrays (see {@link DataMap#spliceCol}). + * + * @memberof Core# + * @function spliceCol + * @param {number} column Index of the column in which do you want to do splice. + * @param {number} index Index at which to start changing the array. If negative, will begin that many elements from the end. + * @param {number} amount An integer indicating the number of old array elements to remove. If amount is 0, no elements are removed. + * @param {...number} [elements] The elements to add to the array. If you don't specify any elements, spliceCol simply removes elements from the array. + * @returns {Array} Returns removed portion of columns. + */ + + + this.spliceCol = function (column, index, amount) { + var _datamap; + + for (var _len = arguments.length, elements = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) { + elements[_key - 3] = arguments[_key]; + } + + return (_datamap = datamap).spliceCol.apply(_datamap, [column, index, amount].concat(elements)); + }; + /** + * Adds/removes data from the row. This method works the same as Array.splice for arrays (see {@link DataMap#spliceRow}). + * + * @memberof Core# + * @function spliceRow + * @param {number} row Index of column in which do you want to do splice. + * @param {number} index Index at which to start changing the array. If negative, will begin that many elements from the end. + * @param {number} amount An integer indicating the number of old array elements to remove. If amount is 0, no elements are removed. + * @param {...number} [elements] The elements to add to the array. If you don't specify any elements, spliceCol simply removes elements from the array. + * @returns {Array} Returns removed portion of rows. + */ + + + this.spliceRow = function (row, index, amount) { + var _datamap2; + + for (var _len2 = arguments.length, elements = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) { + elements[_key2 - 3] = arguments[_key2]; + } + + return (_datamap2 = datamap).spliceRow.apply(_datamap2, [row, index, amount].concat(elements)); + }; + /** + * Returns indexes of the currently selected cells as an array of arrays `[[startRow, startCol, endRow, endCol],...]`. + * + * Start row and start column are the coordinates of the active cell (where the selection was started). + * + * The version 0.36.0 adds a non-consecutive selection feature. Since this version, the method returns an array of arrays. + * Additionally to collect the coordinates of the currently selected area (as it was previously done by the method) + * you need to use `getSelectedLast` method. + * + * @memberof Core# + * @function getSelected + * @returns {Array[]|undefined} An array of arrays of the selection's coordinates. + */ + + + this.getSelected = function () { + // https://github.com/handsontable/handsontable/issues/44 //cjl + if (selection.isSelected()) { + return arrayMap(selection.getSelectedRange(), function (_ref11) { + var from = _ref11.from, + to = _ref11.to; + return [from.row, from.col, to.row, to.col]; + }); + } + }; + /** + * Returns the last coordinates applied to the table as a an array `[startRow, startCol, endRow, endCol]`. + * + * @since 0.36.0 + * @memberof Core# + * @function getSelectedLast + * @returns {Array|undefined} An array of the selection's coordinates. + */ + + + this.getSelectedLast = function () { + var selected = this.getSelected(); + var result; + + if (selected && selected.length > 0) { + result = selected[selected.length - 1]; + } + + return result; + }; + /** + * Returns the current selection as an array of CellRange objects. + * + * The version 0.36.0 adds a non-consecutive selection feature. Since this version, the method returns an array of arrays. + * Additionally to collect the coordinates of the currently selected area (as it was previously done by the method) + * you need to use `getSelectedRangeLast` method. + * + * @memberof Core# + * @function getSelectedRange + * @returns {CellRange[]|undefined} Selected range object or undefined if there is no selection. + */ + + + this.getSelectedRange = function () { + // https://github.com/handsontable/handsontable/issues/44 //cjl + if (selection.isSelected()) { + return Array.from(selection.getSelectedRange()); + } + }; + /** + * Returns the last coordinates applied to the table as a CellRange object. + * + * @memberof Core# + * @function getSelectedRangeLast + * @since 0.36.0 + * @returns {CellRange|undefined} Selected range object or undefined` if there is no selection. + */ + + + this.getSelectedRangeLast = function () { + var selectedRange = this.getSelectedRange(); + var result; + + if (selectedRange && selectedRange.length > 0) { + result = selectedRange[selectedRange.length - 1]; + } + + return result; + }; + /** + * Erases content from cells that have been selected in the table. + * + * @memberof Core# + * @function emptySelectedCells + * @param {string} [source] String that identifies how this change will be described in the changes array (useful in afterChange or beforeChange callback). Set to 'edit' if left empty. + * @since 0.36.0 + */ + + + this.emptySelectedCells = function (source) { + var _this2 = this; + + if (!selection.isSelected() || this.countRows() === 0 || this.countCols() === 0) { + return; + } + + var changes = []; + arrayEach(selection.getSelectedRange(), function (cellRange) { + var topLeft = cellRange.getTopLeftCorner(); + var bottomRight = cellRange.getBottomRightCorner(); + rangeEach(topLeft.row, bottomRight.row, function (row) { + rangeEach(topLeft.col, bottomRight.col, function (column) { + if (!_this2.getCellMeta(row, column).readOnly) { + changes.push([row, column, null]); + } + }); + }); + }); + + if (changes.length > 0) { + this.setDataAtCell(changes, source); + } + }; + /** + * Checks if the table rendering process was suspended. See explanation in {@link Core#suspendRender}. + * + * @memberof Core# + * @function isRenderSuspended + * @since 8.3.0 + * @returns {boolean} + */ + + + this.isRenderSuspended = function () { + return this.renderSuspendedCounter > 0; + }; + /** + * Suspends the rendering process. It's helpful to wrap the table render + * cycles triggered by API calls or UI actions (or both) and call the "render" + * once in the end. As a result, it improves the performance of wrapped operations. + * When the table is in the suspend state, most operations will have no visual + * effect until the rendering state is resumed. Resuming the state automatically + * invokes the table rendering. To make sure that after executing all operations, + * the table will be rendered, it's highly recommended to use the {@link Core#batchRender} + * method or {@link Core#batch}, which additionally aggregates the logic execution + * that happens behind the table. + * + * The method is intended to be used by advanced users. Suspending the rendering + * process could cause visual glitches when wrongly implemented. + * + * @memberof Core# + * @function suspendRender + * @since 8.3.0 + * @example + * ```js + * hot.suspendRender(); + * hot.alter('insert_row', 5, 45); + * hot.alter('insert_col', 10, 40); + * hot.setDataAtCell(1, 1, 'John'); + * hot.setDataAtCell(2, 2, 'Mark'); + * hot.setDataAtCell(3, 3, 'Ann'); + * hot.setDataAtCell(4, 4, 'Sophia'); + * hot.setDataAtCell(5, 5, 'Mia'); + * hot.selectCell(0, 0); + * hot.resumeRender(); // It re-renders the table internally + * ``` + */ + + + this.suspendRender = function () { + this.renderSuspendedCounter += 1; + }; + /** + * Resumes the rendering process. In combination with the {@link Core#suspendRender} + * method it allows aggregating the table render cycles triggered by API calls or UI + * actions (or both) and calls the "render" once in the end. When the table is in + * the suspend state, most operations will have no visual effect until the rendering + * state is resumed. Resuming the state automatically invokes the table rendering. + * + * The method is intended to be used by advanced users. Suspending the rendering + * process could cause visual glitches when wrongly implemented. + * + * @memberof Core# + * @function resumeRender + * @since 8.3.0 + * @example + * ```js + * hot.suspendRender(); + * hot.alter('insert_row', 5, 45); + * hot.alter('insert_col', 10, 40); + * hot.setDataAtCell(1, 1, 'John'); + * hot.setDataAtCell(2, 2, 'Mark'); + * hot.setDataAtCell(3, 3, 'Ann'); + * hot.setDataAtCell(4, 4, 'Sophia'); + * hot.setDataAtCell(5, 5, 'Mia'); + * hot.selectCell(0, 0); + * hot.resumeRender(); // It re-renders the table internally + * ``` + */ + + + this.resumeRender = function () { + var nextValue = this.renderSuspendedCounter - 1; + this.renderSuspendedCounter = Math.max(nextValue, 0); + + if (!this.isRenderSuspended() && nextValue === this.renderSuspendedCounter) { + if (this.renderCall) { + this.render(); + } else { + this._refreshBorders(null); + } + } + }; + /** + * Rerender the table. Calling this method starts the process of recalculating, redrawing and applying the changes + * to the DOM. While rendering the table all cell renderers are recalled. + * + * Calling this method manually is not recommended. Handsontable tries to render itself by choosing the most + * optimal moments in its lifecycle. + * + * @memberof Core# + * @function render + */ + + + this.render = function () { + if (this.view) { + this.renderCall = true; + this.forceFullRender = true; // used when data was changed + + if (!this.isRenderSuspended()) { + editorManager.lockEditor(); + + this._refreshBorders(null); + + editorManager.unlockEditor(); + } + } + }; + /** + * The method aggregates multi-line API calls into a callback and postpones the + * table rendering process. After the execution of the operations, the table is + * rendered once. As a result, it improves the performance of wrapped operations. + * Without batching, a similar case could trigger multiple table render calls. + * + * @memberof Core# + * @function batchRender + * @param {Function} wrappedOperations Batched operations wrapped in a function. + * @returns {*} Returns result from the wrappedOperations callback. + * @since 8.3.0 + * @example + * ```js + * hot.batchRender(() => { + * hot.alter('insert_row', 5, 45); + * hot.alter('insert_col', 10, 40); + * hot.setDataAtCell(1, 1, 'John'); + * hot.setDataAtCell(2, 2, 'Mark'); + * hot.setDataAtCell(3, 3, 'Ann'); + * hot.setDataAtCell(4, 4, 'Sophia'); + * hot.setDataAtCell(5, 5, 'Mia'); + * hot.selectCell(0, 0); + * // The table will be rendered once after executing the callback + * }); + * ``` + */ + + + this.batchRender = function (wrappedOperations) { + this.suspendRender(); + var result = wrappedOperations(); + this.resumeRender(); + return result; + }; + /** + * Checks if the table indexes recalculation process was suspended. See explanation + * in {@link Core#suspendExecution}. + * + * @memberof Core# + * @function isExecutionSuspended + * @since 8.3.0 + * @returns {boolean} + */ + + + this.isExecutionSuspended = function () { + return this.executionSuspendedCounter > 0; + }; + /** + * Suspends the execution process. It's helpful to wrap the table logic changes + * such as index changes into one call after which the cache is updated. As a result, + * it improves the performance of wrapped operations. + * + * The method is intended to be used by advanced users. Suspending the execution + * process could cause visual glitches caused by not updated the internal table cache. + * + * @memberof Core# + * @function suspendExecution + * @since 8.3.0 + * @example + * ```js + * hot.suspendExecution(); + * const filters = hot.getPlugin('filters'); + * + * filters.addCondition(2, 'contains', ['3']); + * filters.filter(); + * hot.getPlugin('columnSorting').sort({ column: 1, sortOrder: 'desc' }); + * hot.resumeExecution(); // It updates the cache internally + * ``` + */ + + + this.suspendExecution = function () { + this.executionSuspendedCounter += 1; + this.columnIndexMapper.suspendOperations(); + this.rowIndexMapper.suspendOperations(); + }; + /** + * Resumes the execution process. In combination with the {@link Core#suspendExecution} + * method it allows aggregating the table logic changes after which the cache is + * updated. Resuming the state automatically invokes the table cache updating process. + * + * The method is intended to be used by advanced users. Suspending the execution + * process could cause visual glitches caused by not updated the internal table cache. + * + * @memberof Core# + * @function resumeExecution + * @param {boolean} [forceFlushChanges=false] If `true`, the table internal data cache + * is recalculated after the execution of the batched operations. For nested + * {@link Core#batchExecution} calls, it can be desire to recalculate the table + * after each batch. + * @since 8.3.0 + * @example + * ```js + * hot.suspendExecution(); + * const filters = hot.getPlugin('filters'); + * + * filters.addCondition(2, 'contains', ['3']); + * filters.filter(); + * hot.getPlugin('columnSorting').sort({ column: 1, sortOrder: 'desc' }); + * hot.resumeExecution(); // It updates the cache internally + * ``` + */ + + + this.resumeExecution = function () { + var forceFlushChanges = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var nextValue = this.executionSuspendedCounter - 1; + this.executionSuspendedCounter = Math.max(nextValue, 0); + + if (!this.isExecutionSuspended() && nextValue === this.executionSuspendedCounter || forceFlushChanges) { + this.columnIndexMapper.resumeOperations(); + this.rowIndexMapper.resumeOperations(); + } + }; + /** + * The method aggregates multi-line API calls into a callback and postpones the + * table execution process. After the execution of the operations, the internal table + * cache is recalculated once. As a result, it improves the performance of wrapped + * operations. Without batching, a similar case could trigger multiple table cache rebuilds. + * + * @memberof Core# + * @function batchExecution + * @param {Function} wrappedOperations Batched operations wrapped in a function. + * @param {boolean} [forceFlushChanges=false] If `true`, the table internal data cache + * is recalculated after the execution of the batched operations. For nested calls, + * it can be a desire to recalculate the table after each batch. + * @returns {*} Returns result from the wrappedOperations callback. + * @since 8.3.0 + * @example + * ```js + * hot.batchExecution(() => { + * const filters = hot.getPlugin('filters'); + * + * filters.addCondition(2, 'contains', ['3']); + * filters.filter(); + * hot.getPlugin('columnSorting').sort({ column: 1, sortOrder: 'desc' }); + * // The table cache will be recalculated once after executing the callback + * }); + * ``` + */ + + + this.batchExecution = function (wrappedOperations) { + var forceFlushChanges = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + this.suspendExecution(); + var result = wrappedOperations(); + this.resumeExecution(forceFlushChanges); + return result; + }; + /** + * It batches the rendering process and index recalculations. The method aggregates + * multi-line API calls into a callback and postpones the table rendering process + * as well aggregates the table logic changes such as index changes into one call + * after which the cache is updated. After the execution of the operations, the + * table is rendered, and the cache is updated once. As a result, it improves the + * performance of wrapped operations. + * + * @memberof Core# + * @function batch + * @param {Function} wrappedOperations Batched operations wrapped in a function. + * @returns {*} Returns result from the wrappedOperations callback. + * @since 8.3.0 + * @example + * ```js + * hot.batch(() => { + * hot.alter('insert_row', 5, 45); + * hot.alter('insert_col', 10, 40); + * hot.setDataAtCell(1, 1, 'x'); + * hot.setDataAtCell(2, 2, 'c'); + * hot.setDataAtCell(3, 3, 'v'); + * hot.setDataAtCell(4, 4, 'b'); + * hot.setDataAtCell(5, 5, 'n'); + * hot.selectCell(0, 0); + * + * const filters = hot.getPlugin('filters'); + * + * filters.addCondition(2, 'contains', ['3']); + * filters.filter(); + * hot.getPlugin('columnSorting').sort({ column: 1, sortOrder: 'desc' }); + * // The table will be re-rendered and cache will be recalculated once after executing the callback + * }); + * ``` + */ + + + this.batch = function (wrappedOperations) { + this.suspendRender(); + this.suspendExecution(); + var result = wrappedOperations(); + this.resumeExecution(); + this.resumeRender(); + return result; + }; + /** + * Updates dimensions of the table. The method compares previous dimensions with the current ones and updates accordingly. + * + * @memberof Core# + * @function refreshDimensions + * @fires Hooks#beforeRefreshDimensions + * @fires Hooks#afterRefreshDimensions + */ + + + this.refreshDimensions = function () { + if (!instance.view) { + return; + } + + var _instance$view$getLas = instance.view.getLastSize(), + lastWidth = _instance$view$getLas.width, + lastHeight = _instance$view$getLas.height; + + var _instance$rootElement = instance.rootElement.getBoundingClientRect(), + width = _instance$rootElement.width, + height = _instance$rootElement.height; + + var isSizeChanged = width !== lastWidth || height !== lastHeight; + var isResizeBlocked = instance.runHooks('beforeRefreshDimensions', { + width: lastWidth, + height: lastHeight + }, { + width: width, + height: height + }, isSizeChanged) === false; + + if (isResizeBlocked) { + return; + } + + if (isSizeChanged || instance.view.wt.wtOverlays.scrollableElement === instance.rootWindow) { + instance.view.setLastSize(width, height); + instance.render(); + } + + instance.runHooks('afterRefreshDimensions', { + width: lastWidth, + height: lastHeight + }, { + width: width, + height: height + }, isSizeChanged); + }; + /** + * Loads new data to Handsontable. Loading new data resets the cell meta. + * Since 8.0.0 loading new data also resets states corresponding to rows and columns + * (for example, row/column sequence, column width, row height, frozen columns etc.). + * + * @memberof Core# + * @function loadData + * @param {Array} data Array of arrays or array of objects containing data. + * @fires Hooks#beforeLoadData + * @fires Hooks#afterLoadData + * @fires Hooks#afterChange + */ + + + this.loadData = function (data) { + if (Array.isArray(tableMeta.dataSchema)) { + instance.dataType = 'array'; + } else if (isFunction(tableMeta.dataSchema)) { + instance.dataType = 'function'; + } else { + instance.dataType = 'object'; + } + + if (datamap) { + datamap.destroy(); + } + + datamap = new DataMap(instance, data, tableMeta); + + if (_typeof$z(data) === 'object' && data !== null) { + if (!(data.push && data.splice)) { + // check if data is array. Must use duck-type check so Backbone Collections also pass it + // when data is not an array, attempt to make a single-row array of it + // eslint-disable-next-line no-param-reassign + data = [data]; + } + } else if (data === null) { + var dataSchema = datamap.getSchema(); // eslint-disable-next-line no-param-reassign + + data = []; + var row; + var r = 0; + var rlen = 0; + + for (r = 0, rlen = tableMeta.startRows; r < rlen; r++) { + if ((instance.dataType === 'object' || instance.dataType === 'function') && tableMeta.dataSchema) { + row = deepClone(dataSchema); + data.push(row); + } else if (instance.dataType === 'array') { + row = deepClone(dataSchema[0]); + data.push(row); + } else { + row = []; + + for (var c = 0, clen = tableMeta.startCols; c < clen; c++) { + row.push(null); + } + + data.push(row); + } + } + } else { + throw new Error("loadData only accepts array of objects or array of arrays (".concat(_typeof$z(data), " given)")); + } + + if (Array.isArray(data[0])) { + instance.dataType = 'array'; + } + + tableMeta.data = data; + instance.runHooks('beforeLoadData', data, firstRun); + datamap.dataSource = data; + dataSource.data = data; + dataSource.dataType = instance.dataType; + dataSource.colToProp = datamap.colToProp.bind(datamap); + dataSource.propToCol = datamap.propToCol.bind(datamap); + dataSource.countCachedColumns = datamap.countCachedColumns.bind(datamap); + metaManager.clearCellsCache(); + instance.initIndexMappers(); + grid.adjustRowsAndCols(); + instance.runHooks('afterLoadData', data, firstRun); + + if (firstRun) { + firstRun = [null, 'loadData']; + } else { + instance.runHooks('afterChange', null, 'loadData'); + instance.render(); + } + }; + /** + * Init index mapper which manage indexes assigned to the data. + * + * @private + */ + + + this.initIndexMappers = function () { + var columnsSettings = tableMeta.columns; + var finalNrOfColumns = 0; // We will check number of columns when the `columns` property was defined as an array. Columns option may + // narrow down or expand displayed dataset in that case. + + if (Array.isArray(columnsSettings)) { + finalNrOfColumns = columnsSettings.length; + } else if (isFunction(columnsSettings)) { + if (instance.dataType === 'array') { + var nrOfSourceColumns = this.countSourceCols(); + + for (var columnIndex = 0; columnIndex < nrOfSourceColumns; columnIndex += 1) { + if (columnsSettings(columnIndex)) { + finalNrOfColumns += 1; + } + } // Extended dataset by the `columns` property? Moved code right from the refactored `countCols` method. + + } else if (instance.dataType === 'object' || instance.dataType === 'function') { + finalNrOfColumns = datamap.colToPropCache.length; + } // In some cases we need to check columns length from the schema, i.e. `data` may be empty. + + } else if (isDefined(tableMeta.dataSchema)) { + var schema = datamap.getSchema(); // Schema may be defined as an array of objects. Each object will define column. + + finalNrOfColumns = Array.isArray(schema) ? schema.length : deepObjectSize(schema); + } else { + // We init index mappers by length of source data to provide indexes also for skipped indexes. + finalNrOfColumns = this.countSourceCols(); + } + + this.columnIndexMapper.initToLength(finalNrOfColumns); + this.rowIndexMapper.initToLength(this.countSourceRows()); + }; + /** + * Returns the current data object (the same one that was passed by `data` configuration option or `loadData` method, + * unless some modifications have been applied (i.e. Sequence of rows/columns was changed, some row/column was skipped). + * If that's the case - use the {@link Core#getSourceData} method.). + * + * Optionally you can provide cell range by defining `row`, `column`, `row2`, `column2` to get only a fragment of table data. + * + * @memberof Core# + * @function getData + * @param {number} [row] From visual row index. + * @param {number} [column] From visual column index. + * @param {number} [row2] To visual row index. + * @param {number} [column2] To visual column index. + * @returns {Array[]} Array with the data. + * @example + * ```js + * // Get all data (in order how it is rendered in the table). + * hot.getData(); + * // Get data fragment (from top-left 0, 0 to bottom-right 3, 3). + * hot.getData(3, 3); + * // Get data fragment (from top-left 2, 1 to bottom-right 3, 3). + * hot.getData(2, 1, 3, 3); + * ``` + */ + + + this.getData = function (row, column, row2, column2) { + if (isUndefined(row)) { + return datamap.getAll(); + } + + return datamap.getRange(new CellCoords(row, column), new CellCoords(row2, column2), datamap.DESTINATION_RENDERER); + }; + /** + * Returns a string value of the selected range. Each column is separated by tab, each row is separated by a new + * line character (see {@link DataMap#getCopyableText}). + * + * @memberof Core# + * @function getCopyableText + * @param {number} startRow From visual row index. + * @param {number} startCol From visual column index. + * @param {number} endRow To visual row index. + * @param {number} endCol To visual column index. + * @returns {string} + */ + + + this.getCopyableText = function (startRow, startCol, endRow, endCol) { + return datamap.getCopyableText(new CellCoords(startRow, startCol), new CellCoords(endRow, endCol)); + }; + /** + * Returns the data's copyable value at specified `row` and `column` index (see {@link DataMap#getCopyable}). + * + * @memberof Core# + * @function getCopyableData + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @returns {string} + */ + + + this.getCopyableData = function (row, column) { + return datamap.getCopyable(row, datamap.colToProp(column)); + }; + /** + * Returns schema provided by constructor settings. If it doesn't exist then it returns the schema based on the data + * structure in the first row. + * + * @memberof Core# + * @function getSchema + * @returns {object} Schema object. + */ + + + this.getSchema = function () { + return datamap.getSchema(); + }; + /** + * Use it if you need to change configuration after initialization. The `settings` argument is an object containing the new + * settings, declared the same way as in the initial settings object. + * + * __Note__, that although the `updateSettings` method doesn't overwrite the previously declared settings, it might reset + * the settings made post-initialization. (for example - ignore changes made using the columnResize feature). + * + * Since 8.0.0 passing `columns` or `data` inside `settings` objects will result in resetting states corresponding to rows and columns + * (for example, row/column sequence, column width, row height, frozen columns etc.). + * + * @memberof Core# + * @function updateSettings + * @param {object} settings New settings object (see {@link Options}). + * @param {boolean} [init=false] Internally used for in initialization mode. + * @example + * ```js + * hot.updateSettings({ + * contextMenu: true, + * colHeaders: true, + * fixedRowsTop: 2 + * }); + * ``` + * @fires Hooks#afterCellMetaReset + * @fires Hooks#afterUpdateSettings + */ + + + this.updateSettings = function (settings) { + var init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var columnsAsFunc = false; + var i; + var j; + + if (isDefined(settings.rows)) { + throw new Error('The "rows" setting is no longer supported. Do you mean startRows, minRows or maxRows?'); + } + + if (isDefined(settings.cols)) { + throw new Error('The "cols" setting is no longer supported. Do you mean startCols, minCols or maxCols?'); + } + + if (isDefined(settings.ganttChart)) { + throw new Error('Since 8.0.0 the "ganttChart" setting is no longer supported.'); + } // eslint-disable-next-line no-restricted-syntax + + + for (i in settings) { + if (i === 'data') { + /* eslint-disable-next-line no-continue */ + continue; // loadData will be triggered later + } else if (i === 'language') { + setLanguage(settings.language); + /* eslint-disable-next-line no-continue */ + + continue; + } else if (i === 'className') { + setClassName('className', settings.className); + } else if (i === 'tableClassName' && instance.table) { + setClassName('tableClassName', settings.tableClassName); + instance.view.wt.wtOverlays.syncOverlayTableClassNames(); + } else if (Hooks.getSingleton().isRegistered(i) || Hooks.getSingleton().isDeprecated(i)) { + if (isFunction(settings[i]) || Array.isArray(settings[i])) { + settings[i].initialHook = true; + instance.addHook(i, settings[i]); + } + } else if (!init && hasOwnProperty$1(settings, i)) { + // Update settings + globalMeta[i] = settings[i]; + } + } // Load data or create data map + + + if (settings.data === void 0 && tableMeta.data === void 0) { + instance.loadData(null); // data source created just now + } else if (settings.data !== void 0) { + instance.loadData(settings.data); // data source given as option + } else if (settings.columns !== void 0) { + datamap.createMap(); // The `column` property has changed - dataset may be expanded or narrowed down. The `loadData` do the same. + + instance.initIndexMappers(); + } + + var clen = instance.countCols(); + var columnSetting = tableMeta.columns; // Init columns constructors configuration + + if (columnSetting && isFunction(columnSetting)) { + columnsAsFunc = true; + } // Clear cell meta cache + + + if (settings.cell !== void 0 || settings.cells !== void 0 || settings.columns !== void 0) { + metaManager.clearCache(); + } + + if (clen > 0) { + for (i = 0, j = 0; i < clen; i++) { + // Use settings provided by user + if (columnSetting) { + var column = columnsAsFunc ? columnSetting(i) : columnSetting[j]; + + if (column) { + metaManager.updateColumnMeta(j, column); + } + } + + j += 1; + } + } + + if (isDefined(settings.cell)) { + objectEach(settings.cell, function (cell) { + instance.setCellMetaObject(cell.row, cell.col, cell); + }); + } + + instance.runHooks('afterCellMetaReset'); + var currentHeight = instance.rootElement.style.height; + + if (currentHeight !== '') { + currentHeight = parseInt(instance.rootElement.style.height, 10); + } + + var height = settings.height; + + if (isFunction(height)) { + height = height(); + } + + if (init) { + var initialStyle = instance.rootElement.getAttribute('style'); + + if (initialStyle) { + instance.rootElement.setAttribute('data-initialstyle', instance.rootElement.getAttribute('style')); + } + } + + if (height === null) { + var _initialStyle = instance.rootElement.getAttribute('data-initialstyle'); + + if (_initialStyle && (_initialStyle.indexOf('height') > -1 || _initialStyle.indexOf('overflow') > -1)) { + instance.rootElement.setAttribute('style', _initialStyle); + } else { + instance.rootElement.style.height = ''; + instance.rootElement.style.overflow = ''; + } + } else if (height !== void 0) { + instance.rootElement.style.height = isNaN(height) ? "".concat(height) : "".concat(height, "px"); + instance.rootElement.style.overflow = 'hidden'; + } + + if (typeof settings.width !== 'undefined') { + var width = settings.width; + + if (isFunction(width)) { + width = width(); + } + + instance.rootElement.style.width = isNaN(width) ? "".concat(width) : "".concat(width, "px"); + } + + if (!init) { + if (instance.view) { + instance.view.wt.wtViewport.resetHasOversizedColumnHeadersMarked(); + instance.view.wt.exportSettingsAsClassNames(); + } + + instance.runHooks('afterUpdateSettings', settings); + } + + grid.adjustRowsAndCols(); + + if (instance.view && !firstRun) { + instance.forceFullRender = true; // used when data was changed + + editorManager.lockEditor(); + + instance._refreshBorders(null); + + editorManager.unlockEditor(); + } + + if (!init && instance.view && (currentHeight === '' || height === '' || height === void 0) && currentHeight !== height) { + instance.view.wt.wtOverlays.updateMainScrollableElements(); + } + }; + /** + * Get value from the selected cell. + * + * @memberof Core# + * @function getValue + * @returns {*} Value of selected cell. + */ + + + this.getValue = function () { + var sel = instance.getSelectedLast(); + + if (tableMeta.getValue) { + if (isFunction(tableMeta.getValue)) { + return tableMeta.getValue.call(instance); + } else if (sel) { + return instance.getData()[sel[0][0]][tableMeta.getValue]; + } + } else if (sel) { + return instance.getDataAtCell(sel[0], sel[1]); + } + }; + /** + * Returns the object settings. + * + * @memberof Core# + * @function getSettings + * @returns {object} Object containing the current table settings. + */ + + + this.getSettings = function () { + return tableMeta; + }; + /** + * Clears the data from the table (the table settings remain intact). + * + * @memberof Core# + * @function clear + */ + + + this.clear = function () { + this.selectAll(); + this.emptySelectedCells(); + }; + /** + * Allows altering the table structure by either inserting/removing rows or columns. + * This method works with an array data structure only. + * + * @memberof Core# + * @function alter + * @param {string} action Possible alter operations: + * * `'insert_row'` + * * `'insert_col'` + * * `'remove_row'` + * * `'remove_col'`. + * @param {number|number[]} index Visual index of the row/column before which the new row/column will be + * inserted/removed or an array of arrays in format `[[index, amount],...]`. + * @param {number} [amount=1] Amount of rows/columns to be inserted or removed. + * @param {string} [source] Source indicator. + * @param {boolean} [keepEmptyRows] Flag for preventing deletion of empty rows. + * @example + * ```js + * // Insert new row above the row at given visual index. + * hot.alter('insert_row', 10); + * // Insert 3 new columns before 10th column. + * hot.alter('insert_col', 10, 3); + * // Remove 2 rows starting from 10th row. + * hot.alter('remove_row', 10, 2); + * // Remove 5 non-contiquous rows (it removes 3 rows from visual index 1 and 2 rows from visual index 5). + * hot.alter('remove_row', [[1, 3], [5, 2]]); + * ``` + */ + + + this.alter = function (action, index, amount, source, keepEmptyRows) { + grid.alter(action, index, amount, source, keepEmptyRows); + }; + /** + * Returns a TD element for the given `row` and `column` arguments, if it is rendered on screen. + * Returns `null` if the TD is not rendered on screen (probably because that part of the table is not visible). + * + * @memberof Core# + * @function getCell + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {boolean} [topmost=false] If set to `true`, it returns the TD element from the topmost overlay. For example, + * if the wanted cell is in the range of fixed rows, it will return a TD element from the `top` overlay. + * @returns {HTMLTableCellElement|null} The cell's TD element. + */ + + + this.getCell = function (row, column) { + var topmost = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var renderableColumnIndex = column; // Handling also column headers. + + var renderableRowIndex = row; // Handling also row headers. + + if (column >= 0) { + if (this.columnIndexMapper.isHidden(this.toPhysicalColumn(column))) { + return null; + } + + renderableColumnIndex = this.columnIndexMapper.getRenderableFromVisualIndex(column); + } + + if (row >= 0) { + if (this.rowIndexMapper.isHidden(this.toPhysicalRow(row))) { + return null; + } + + renderableRowIndex = this.rowIndexMapper.getRenderableFromVisualIndex(row); + } + + if (renderableRowIndex === null || renderableColumnIndex === null) { + return null; + } + + return instance.view.getCellAtCoords(new CellCoords(renderableRowIndex, renderableColumnIndex), topmost); + }; + /** + * Returns the coordinates of the cell, provided as a HTML table cell element. + * + * @memberof Core# + * @function getCoords + * @param {HTMLTableCellElement} element The HTML Element representing the cell. + * @returns {CellCoords|null} Visual coordinates object. + * @example + * ```js + * hot.getCoords(hot.getCell(1, 1)); + * // it returns CellCoords object instance with props row: 1 and col: 1. + * ``` + */ + + + this.getCoords = function (element) { + var renderableCoords = this.view.wt.wtTable.getCoords(element); + + if (renderableCoords === null) { + return null; + } + + var renderableRow = renderableCoords.row, + renderableColumn = renderableCoords.col; + var visualRow = renderableRow; + var visualColumn = renderableColumn; + + if (renderableRow >= 0) { + visualRow = this.rowIndexMapper.getVisualFromRenderableIndex(renderableRow); + } + + if (renderableColumn >= 0) { + visualColumn = this.columnIndexMapper.getVisualFromRenderableIndex(renderableColumn); + } + + return new CellCoords(visualRow, visualColumn); + }; + /** + * Returns the property name that corresponds with the given column index (see {@link DataMap#colToProp}). + * If the data source is an array of arrays, it returns the columns index. + * + * @memberof Core# + * @function colToProp + * @param {number} column Visual column index. + * @returns {string|number} Column property or physical column index. + */ + + + this.colToProp = function (column) { + return datamap.colToProp(column); + }; + /** + * Returns column index that corresponds with the given property (see {@link DataMap#propToCol}). + * + * @memberof Core# + * @function propToCol + * @param {string|number} prop Property name or physical column index. + * @returns {number} Visual column index. + */ + + + this.propToCol = function (prop) { + return datamap.propToCol(prop); + }; + /** + * Translate physical row index into visual. + * + * This method is useful when you want to retrieve visual row index which can be reordered, moved or trimmed + * based on a physical index. + * + * @memberof Core# + * @function toVisualRow + * @param {number} row Physical row index. + * @returns {number} Returns visual row index. + */ + + + this.toVisualRow = function (row) { + return _this.rowIndexMapper.getVisualFromPhysicalIndex(row); + }; + /** + * Translate physical column index into visual. + * + * This method is useful when you want to retrieve visual column index which can be reordered, moved or trimmed + * based on a physical index. + * + * @memberof Core# + * @function toVisualColumn + * @param {number} column Physical column index. + * @returns {number} Returns visual column index. + */ + + + this.toVisualColumn = function (column) { + return _this.columnIndexMapper.getVisualFromPhysicalIndex(column); + }; + /** + * Translate visual row index into physical. + * + * This method is useful when you want to retrieve physical row index based on a visual index which can be + * reordered, moved or trimmed. + * + * @memberof Core# + * @function toPhysicalRow + * @param {number} row Visual row index. + * @returns {number} Returns physical row index. + */ + + + this.toPhysicalRow = function (row) { + return _this.rowIndexMapper.getPhysicalFromVisualIndex(row); + }; + /** + * Translate visual column index into physical. + * + * This method is useful when you want to retrieve physical column index based on a visual index which can be + * reordered, moved or trimmed. + * + * @memberof Core# + * @function toPhysicalColumn + * @param {number} column Visual column index. + * @returns {number} Returns physical column index. + */ + + + this.toPhysicalColumn = function (column) { + return _this.columnIndexMapper.getPhysicalFromVisualIndex(column); + }; + /** + * @description + * Returns the cell value at `row`, `column`. + * + * __Note__: If data is reordered, sorted or trimmed, the currently visible order will be used. + * + * @memberof Core# + * @function getDataAtCell + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @returns {*} Data at cell. + */ + + + this.getDataAtCell = function (row, column) { + return datamap.get(row, datamap.colToProp(column)); + }; + /** + * Returns value at visual `row` and `prop` indexes (see {@link DataMap#get}). + * + * __Note__: If data is reordered, sorted or trimmed, the currently visible order will be used. + * + * @memberof Core# + * @function getDataAtRowProp + * @param {number} row Visual row index. + * @param {string} prop Property name. + * @returns {*} Cell value. + */ + + + this.getDataAtRowProp = function (row, prop) { + return datamap.get(row, prop); + }; + /** + * @description + * Returns array of column values from the data source. + * + * __Note__: If columns were reordered or sorted, the currently visible order will be used. + * + * @memberof Core# + * @function getDataAtCol + * @param {number} column Visual column index. + * @returns {Array} Array of cell values. + */ + + + this.getDataAtCol = function (column) { + var _ref12; + + return (_ref12 = []).concat.apply(_ref12, _toConsumableArray$h(datamap.getRange(new CellCoords(0, column), new CellCoords(tableMeta.data.length - 1, column), datamap.DESTINATION_RENDERER))); + }; + /** + * Given the object property name (e.g. `'first.name'` or `'0'`), returns an array of column's values from the table data. + * You can also provide a column index as the first argument. + * + * @memberof Core# + * @function getDataAtProp + * @param {string|number} prop Property name or physical column index. + * @returns {Array} Array of cell values. + */ + // TODO: Getting data from `datamap` should work on visual indexes. + + + this.getDataAtProp = function (prop) { + var _ref13; + + var range = datamap.getRange(new CellCoords(0, datamap.propToCol(prop)), new CellCoords(tableMeta.data.length - 1, datamap.propToCol(prop)), datamap.DESTINATION_RENDERER); + return (_ref13 = []).concat.apply(_ref13, _toConsumableArray$h(range)); + }; + /** + * Returns a clone of the source data object. + * Optionally you can provide a cell range by using the `row`, `column`, `row2`, `column2` arguments, to get only a + * fragment of the table data. + * + * __Note__: This method does not participate in data transformation. If the visual data of the table is reordered, + * sorted or trimmed only physical indexes are correct. + * + * @memberof Core# + * @function getSourceData + * @param {number} [row] From physical row index. + * @param {number} [column] From physical column index (or visual index, if data type is an array of objects). + * @param {number} [row2] To physical row index. + * @param {number} [column2] To physical column index (or visual index, if data type is an array of objects). + * @returns {Array[]|object[]} The table data. + */ + + + this.getSourceData = function (row, column, row2, column2) { + var data; + + if (row === void 0) { + data = dataSource.getData(); + } else { + data = dataSource.getByRange(new CellCoords(row, column), new CellCoords(row2, column2)); + } + + return data; + }; + /** + * Returns the source data object as an arrays of arrays format even when source data was provided in another format. + * Optionally you can provide a cell range by using the `row`, `column`, `row2`, `column2` arguments, to get only a + * fragment of the table data. + * + * __Note__: This method does not participate in data transformation. If the visual data of the table is reordered, + * sorted or trimmed only physical indexes are correct. + * + * @memberof Core# + * @function getSourceDataArray + * @param {number} [row] From physical row index. + * @param {number} [column] From physical column index (or visual index, if data type is an array of objects). + * @param {number} [row2] To physical row index. + * @param {number} [column2] To physical column index (or visual index, if data type is an array of objects). + * @returns {Array} An array of arrays. + */ + + + this.getSourceDataArray = function (row, column, row2, column2) { + var data; + + if (row === void 0) { + data = dataSource.getData(true); + } else { + data = dataSource.getByRange(new CellCoords(row, column), new CellCoords(row2, column2), true); + } + + return data; + }; + /** + * Returns an array of column values from the data source. + * + * @memberof Core# + * @function getSourceDataAtCol + * @param {number} column Visual column index. + * @returns {Array} Array of the column's cell values. + */ + // TODO: Getting data from `sourceData` should work always on physical indexes. + + + this.getSourceDataAtCol = function (column) { + return dataSource.getAtColumn(column); + }; + /* eslint-disable jsdoc/require-param */ + + /** + * Set the provided value in the source data set at the provided coordinates. + * + * @memberof Core# + * @function setSourceDataAtCell + * @param {number|Array} row Physical row index or array of changes in format `[[row, prop, value], ...]`. + * @param {number|string} column Physical column index / prop name. + * @param {*} value The value to be set at the provided coordinates. + * @param {string} [source] Source of the change as a string. + */ + + /* eslint-enable jsdoc/require-param */ + + + this.setSourceDataAtCell = function (row, column, value, source) { + var input = setDataInputToArray(row, column, value); + var isThereAnySetSourceListener = this.hasHook('afterSetSourceDataAtCell'); + var changesForHook = []; + + if (isThereAnySetSourceListener) { + arrayEach(input, function (_ref14) { + var _ref15 = _slicedToArray$c(_ref14, 3), + changeRow = _ref15[0], + changeProp = _ref15[1], + changeValue = _ref15[2]; + + changesForHook.push([changeRow, changeProp, dataSource.getAtCell(changeRow, changeProp), // The previous value. + changeValue]); + }); + } + + arrayEach(input, function (_ref16) { + var _ref17 = _slicedToArray$c(_ref16, 3), + changeRow = _ref17[0], + changeProp = _ref17[1], + changeValue = _ref17[2]; + + dataSource.setAtCell(changeRow, changeProp, changeValue); + }); + + if (isThereAnySetSourceListener) { + this.runHooks('afterSetSourceDataAtCell', changesForHook, source); + } + + this.render(); + var activeEditor = instance.getActiveEditor(); + + if (activeEditor && isDefined(activeEditor.refreshValue)) { + activeEditor.refreshValue(); + } + }; + /** + * Returns a single row of the data (array or object, depending on what data format you use). + * + * __Note__: This method does not participate in data transformation. If the visual data of the table is reordered, + * sorted or trimmed only physical indexes are correct. + * + * @memberof Core# + * @function getSourceDataAtRow + * @param {number} row Physical row index. + * @returns {Array|object} Single row of data. + */ + + + this.getSourceDataAtRow = function (row) { + return dataSource.getAtRow(row); + }; + /** + * Returns a single value from the data source. + * + * @memberof Core# + * @function getSourceDataAtCell + * @param {number} row Physical row index. + * @param {number} column Visual column index. + * @returns {*} Cell data. + */ + // TODO: Getting data from `sourceData` should work always on physical indexes. + + + this.getSourceDataAtCell = function (row, column) { + return dataSource.getAtCell(row, column); + }; + /** + * @description + * Returns a single row of the data. + * + * __Note__: If rows were reordered, sorted or trimmed, the currently visible order will be used. + * + * @memberof Core# + * @function getDataAtRow + * @param {number} row Visual row index. + * @returns {Array} Array of row's cell data. + */ + + + this.getDataAtRow = function (row) { + var data = datamap.getRange(new CellCoords(row, 0), new CellCoords(row, this.countCols() - 1), datamap.DESTINATION_RENDERER); + return data[0] || []; + }; + /** + * @description + * Returns a data type defined in the Handsontable settings under the `type` key ([Options#type](https://handsontable.com/docs/Options.html#type)). + * If there are cells with different types in the selected range, it returns `'mixed'`. + * + * __Note__: If data is reordered, sorted or trimmed, the currently visible order will be used. + * + * @memberof Core# + * @function getDataType + * @param {number} rowFrom From visual row index. + * @param {number} columnFrom From visual column index. + * @param {number} rowTo To visual row index. + * @param {number} columnTo To visual column index. + * @returns {string} Cell type (e.q: `'mixed'`, `'text'`, `'numeric'`, `'autocomplete'`). + */ + + + this.getDataType = function (rowFrom, columnFrom, rowTo, columnTo) { + var _this3 = this; + + var coords = rowFrom === void 0 ? [0, 0, this.countRows(), this.countCols()] : [rowFrom, columnFrom, rowTo, columnTo]; + var rowStart = coords[0], + columnStart = coords[1]; + var rowEnd = coords[2], + columnEnd = coords[3]; + var previousType = null; + var currentType = null; + + if (rowEnd === void 0) { + rowEnd = rowStart; + } + + if (columnEnd === void 0) { + columnEnd = columnStart; + } + + var type = 'mixed'; + rangeEach(Math.max(Math.min(rowStart, rowEnd), 0), Math.max(rowStart, rowEnd), function (row) { + var isTypeEqual = true; + rangeEach(Math.max(Math.min(columnStart, columnEnd), 0), Math.max(columnStart, columnEnd), function (column) { + var cellType = _this3.getCellMeta(row, column); + + currentType = cellType.type; + + if (previousType) { + isTypeEqual = previousType === currentType; + } else { + previousType = currentType; + } + + return isTypeEqual; + }); + type = isTypeEqual ? currentType : 'mixed'; + return isTypeEqual; + }); + return type; + }; + /** + * Remove a property defined by the `key` argument from the cell meta object for the provided `row` and `column` coordinates. + * + * @memberof Core# + * @function removeCellMeta + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string} key Property name. + * @fires Hooks#beforeRemoveCellMeta + * @fires Hooks#afterRemoveCellMeta + */ + + + this.removeCellMeta = function (row, column, key) { + var _ref18 = [this.toPhysicalRow(row), this.toPhysicalColumn(column)], + physicalRow = _ref18[0], + physicalColumn = _ref18[1]; + var cachedValue = metaManager.getCellMeta(physicalRow, physicalColumn, key); + var hookResult = instance.runHooks('beforeRemoveCellMeta', row, column, key, cachedValue); + + if (hookResult !== false) { + metaManager.removeCellMeta(physicalRow, physicalColumn, key); + instance.runHooks('afterRemoveCellMeta', row, column, key, cachedValue); + } + + cachedValue = null; + }; + /** + * Removes or adds one or more rows of the cell meta objects to the cell meta collections. + * + * @since 0.30.0 + * @memberof Core# + * @function spliceCellsMeta + * @param {number} visualIndex A visual index that specifies at what position to add/remove items. + * @param {number} [deleteAmount=0] The number of items to be removed. If set to 0, no cell meta objects will be removed. + * @param {...object} [cellMetaRows] The new cell meta row objects to be added to the cell meta collection. + */ + + + this.spliceCellsMeta = function (visualIndex) { + var _this4 = this; + + var deleteAmount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + + for (var _len3 = arguments.length, cellMetaRows = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) { + cellMetaRows[_key3 - 2] = arguments[_key3]; + } + + if (cellMetaRows.length > 0 && !Array.isArray(cellMetaRows[0])) { + throw new Error('The 3rd argument (cellMetaRows) has to be passed as an array of cell meta objects array.'); + } + + if (deleteAmount > 0) { + metaManager.removeRow(this.toPhysicalRow(visualIndex), deleteAmount); + } + + if (cellMetaRows.length > 0) { + arrayEach(cellMetaRows.reverse(), function (cellMetaRow) { + metaManager.createRow(_this4.toPhysicalRow(visualIndex)); + arrayEach(cellMetaRow, function (cellMeta, columnIndex) { + return _this4.setCellMetaObject(visualIndex, columnIndex, cellMeta); + }); + }); + } + }; + /** + * Set cell meta data object defined by `prop` to the corresponding params `row` and `column`. + * + * @memberof Core# + * @function setCellMetaObject + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {object} prop Meta object. + */ + + + this.setCellMetaObject = function (row, column, prop) { + var _this5 = this; + + if (_typeof$z(prop) === 'object') { + objectEach(prop, function (value, key) { + _this5.setCellMeta(row, column, key, value); + }); + } + }; + /** + * Sets a property defined by the `key` property to the meta object of a cell corresponding to params `row` and `column`. + * + * @memberof Core# + * @function setCellMeta + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string} key Property name. + * @param {string} value Property value. + * @fires Hooks#beforeSetCellMeta + * @fires Hooks#afterSetCellMeta + */ + + + this.setCellMeta = function (row, column, key, value) { + var allowSetCellMeta = instance.runHooks('beforeSetCellMeta', row, column, key, value); + + if (allowSetCellMeta === false) { + return; + } + + var physicalRow = row; + var physicalColumn = column; + + if (row < this.countRows()) { + physicalRow = this.toPhysicalRow(row); + } + + if (column < this.countCols()) { + physicalColumn = this.toPhysicalColumn(column); + } + + metaManager.setCellMeta(physicalRow, physicalColumn, key, value); + instance.runHooks('afterSetCellMeta', row, column, key, value); + }; + /** + * Get all the cells meta settings at least once generated in the table (in order of cell initialization). + * + * @memberof Core# + * @function getCellsMeta + * @returns {Array} Returns an array of ColumnSettings object instances. + */ + + + this.getCellsMeta = function () { + return metaManager.getCellsMeta(); + }; + /** + * Returns the cell properties object for the given `row` and `column` coordinates. + * + * @memberof Core# + * @function getCellMeta + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @returns {object} The cell properties object. + * @fires Hooks#beforeGetCellMeta + * @fires Hooks#afterGetCellMeta + */ + + + this.getCellMeta = function (row, column) { + var physicalRow = this.toPhysicalRow(row); + var physicalColumn = this.toPhysicalColumn(column); + + if (physicalRow === null) { + physicalRow = row; + } + + if (physicalColumn === null) { + physicalColumn = column; + } + + var prop = datamap.colToProp(column); + var cellProperties = metaManager.getCellMeta(physicalRow, physicalColumn); // TODO(perf): Add assigning this props and executing below code only once per table render cycle. + + cellProperties.row = physicalRow; + cellProperties.col = physicalColumn; + cellProperties.visualRow = row; + cellProperties.visualCol = column; + cellProperties.prop = prop; + cellProperties.instance = instance; + instance.runHooks('beforeGetCellMeta', row, column, cellProperties); // for `type` added or changed in beforeGetCellMeta + + if (instance.hasHook('beforeGetCellMeta') && hasOwnProperty$1(cellProperties, 'type')) { + metaManager.updateCellMeta(physicalRow, physicalColumn, { + type: cellProperties.type + }); + } + + if (cellProperties.cells) { + var settings = cellProperties.cells(physicalRow, physicalColumn, prop); + + if (settings) { + metaManager.updateCellMeta(physicalRow, physicalColumn, settings); + } + } + + instance.runHooks('afterGetCellMeta', row, column, cellProperties); + return cellProperties; + }; + /** + * Returns an array of cell meta objects for specified physical row index. + * + * @memberof Core# + * @function getCellMetaAtRow + * @param {number} row Physical row index. + * @returns {Array} + */ + + + this.getCellMetaAtRow = function (row) { + return metaManager.getCellsMetaAtRow(row); + }; + /** + * Checks if the data format and config allows user to modify the column structure. + * + * @memberof Core# + * @function isColumnModificationAllowed + * @returns {boolean} + */ + + + this.isColumnModificationAllowed = function () { + return !(instance.dataType === 'object' || tableMeta.columns); + }; + + var rendererLookup = cellMethodLookupFactory('renderer'); + /** + * Returns the cell renderer function by given `row` and `column` arguments. + * + * @memberof Core# + * @function getCellRenderer + * @param {number|object} row Visual row index or cell meta object (see {@link Core#getCellMeta}). + * @param {number} column Visual column index. + * @returns {Function} The renderer function. + * @example + * ```js + * // Get cell renderer using `row` and `column` coordinates. + * hot.getCellRenderer(1, 1); + * // Get cell renderer using cell meta object. + * hot.getCellRenderer(hot.getCellMeta(1, 1)); + * ``` + */ + + this.getCellRenderer = function (row, column) { + return _getItem$1(rendererLookup.call(this, row, column)); + }; + /** + * Returns the cell editor class by the provided `row` and `column` arguments. + * + * @memberof Core# + * @function getCellEditor + * @param {number} row Visual row index or cell meta object (see {@link Core#getCellMeta}). + * @param {number} column Visual column index. + * @returns {Function} The editor class. + * @example + * ```js + * // Get cell editor class using `row` and `column` coordinates. + * hot.getCellEditor(1, 1); + * // Get cell editor class using cell meta object. + * hot.getCellEditor(hot.getCellMeta(1, 1)); + * ``` + */ + + + this.getCellEditor = cellMethodLookupFactory('editor'); + var validatorLookup = cellMethodLookupFactory('validator'); + /** + * Returns the cell validator by `row` and `column`. + * + * @memberof Core# + * @function getCellValidator + * @param {number|object} row Visual row index or cell meta object (see {@link Core#getCellMeta}). + * @param {number} column Visual column index. + * @returns {Function|RegExp|undefined} The validator function. + * @example + * ```js + * // Get cell valiator using `row` and `column` coordinates. + * hot.getCellValidator(1, 1); + * // Get cell valiator using cell meta object. + * hot.getCellValidator(hot.getCellMeta(1, 1)); + * ``` + */ + + this.getCellValidator = function (row, column) { + var validator = validatorLookup.call(this, row, column); + + if (typeof validator === 'string') { + validator = _getItem$2(validator); + } + + return validator; + }; + /** + * Validates all cells using their validator functions and calls callback when finished. + * + * If one of the cells is invalid, the callback will be fired with `'valid'` arguments as `false` - otherwise it + * would equal `true`. + * + * @memberof Core# + * @function validateCells + * @param {Function} [callback] The callback function. + * @example + * ```js + * hot.validateCells((valid) => { + * if (valid) { + * // ... code for validated cells + * } + * }) + * ``` + */ + + + this.validateCells = function (callback) { + this._validateCells(callback); + }; + /** + * Validates rows using their validator functions and calls callback when finished. + * + * If one of the cells is invalid, the callback will be fired with `'valid'` arguments as `false` - otherwise it + * would equal `true`. + * + * @memberof Core# + * @function validateRows + * @param {Array} [rows] Array of validation target visual row indexes. + * @param {Function} [callback] The callback function. + * @example + * ```js + * hot.validateRows([3, 4, 5], (valid) => { + * if (valid) { + * // ... code for validated rows + * } + * }) + * ``` + */ + + + this.validateRows = function (rows, callback) { + if (!Array.isArray(rows)) { + throw new Error('validateRows parameter `rows` must be an array'); + } + + this._validateCells(callback, rows); + }; + /** + * Validates columns using their validator functions and calls callback when finished. + * + * If one of the cells is invalid, the callback will be fired with `'valid'` arguments as `false` - otherwise it + * would equal `true`. + * + * @memberof Core# + * @function validateColumns + * @param {Array} [columns] Array of validation target visual columns indexes. + * @param {Function} [callback] The callback function. + * @example + * ```js + * hot.validateColumns([3, 4, 5], (valid) => { + * if (valid) { + * // ... code for validated columns + * } + * }) + * ``` + */ + + + this.validateColumns = function (columns, callback) { + if (!Array.isArray(columns)) { + throw new Error('validateColumns parameter `columns` must be an array'); + } + + this._validateCells(callback, undefined, columns); + }; + /** + * Validates all cells using their validator functions and calls callback when finished. + * + * If one of the cells is invalid, the callback will be fired with `'valid'` arguments as `false` - otherwise it would equal `true`. + * + * Private use intended. + * + * @private + * @memberof Core# + * @function _validateCells + * @param {Function} [callback] The callback function. + * @param {Array} [rows] An array of validation target visual row indexes. + * @param {Array} [columns] An array of validation target visual column indexes. + */ + + + this._validateCells = function (callback, rows, columns) { + var waitingForValidator = new ValidatorsQueue(); + + if (callback) { + waitingForValidator.onQueueEmpty = callback; + } + + var i = instance.countRows() - 1; + + while (i >= 0) { + if (rows !== undefined && rows.indexOf(i) === -1) { + i -= 1; + continue; + } + + var j = instance.countCols() - 1; + + while (j >= 0) { + if (columns !== undefined && columns.indexOf(j) === -1) { + j -= 1; + continue; + } + + waitingForValidator.addValidatorToQueue(); + instance.validateCell(instance.getDataAtCell(i, j), instance.getCellMeta(i, j), function (result) { + if (typeof result !== 'boolean') { + throw new Error('Validation error: result is not boolean'); + } + + if (result === false) { + waitingForValidator.valid = false; + } + + waitingForValidator.removeValidatorFormQueue(); + }, 'validateCells'); + j -= 1; + } + + i -= 1; + } + + waitingForValidator.checkIfQueueIsEmpty(); + }; + /** + * Returns an array of row headers' values (if they are enabled). If param `row` was given, it returns the header of the given row as a string. + * + * @memberof Core# + * @function getRowHeader + * @param {number} [row] Visual row index. + * @fires Hooks#modifyRowHeader + * @returns {Array|string|number} Array of header values / single header value. + */ + + + this.getRowHeader = function (row) { + var rowHeader = tableMeta.rowHeaders; + var physicalRow = row; + + if (physicalRow !== void 0) { + physicalRow = instance.runHooks('modifyRowHeader', physicalRow); + } + + if (physicalRow === void 0) { + rowHeader = []; + rangeEach(instance.countRows() - 1, function (i) { + rowHeader.push(instance.getRowHeader(i)); + }); + } else if (Array.isArray(rowHeader) && rowHeader[physicalRow] !== void 0) { + rowHeader = rowHeader[physicalRow]; + } else if (isFunction(rowHeader)) { + rowHeader = rowHeader(physicalRow); + } else if (rowHeader && typeof rowHeader !== 'string' && typeof rowHeader !== 'number') { + rowHeader = physicalRow + 1; + } + + return rowHeader; + }; + /** + * Returns information about if this table is configured to display row headers. + * + * @memberof Core# + * @function hasRowHeaders + * @returns {boolean} `true` if the instance has the row headers enabled, `false` otherwise. + */ + + + this.hasRowHeaders = function () { + return !!tableMeta.rowHeaders; + }; + /** + * Returns information about if this table is configured to display column headers. + * + * @memberof Core# + * @function hasColHeaders + * @returns {boolean} `true` if the instance has the column headers enabled, `false` otherwise. + */ + + + this.hasColHeaders = function () { + if (tableMeta.colHeaders !== void 0 && tableMeta.colHeaders !== null) { + // Polymer has empty value = null + return !!tableMeta.colHeaders; + } + + for (var i = 0, ilen = instance.countCols(); i < ilen; i++) { + if (instance.getColHeader(i)) { + return true; + } + } + + return false; + }; + /** + * Returns an array of column headers (in string format, if they are enabled). If param `column` is given, it + * returns the header at the given column. + * + * @memberof Core# + * @function getColHeader + * @param {number} [column] Visual column index. + * @fires Hooks#modifyColHeader + * @returns {Array|string|number} The column header(s). + */ + + + this.getColHeader = function (column) { + var columnIndex = instance.runHooks('modifyColHeader', column); + var result = tableMeta.colHeaders; + + if (columnIndex === void 0) { + var out = []; + var ilen = instance.countCols(); + + for (var i = 0; i < ilen; i++) { + out.push(instance.getColHeader(i)); + } + + result = out; + } else { + var translateVisualIndexToColumns = function translateVisualIndexToColumns(visualColumnIndex) { + var arr = []; + var columnsLen = instance.countCols(); + var index = 0; + + for (; index < columnsLen; index++) { + if (isFunction(tableMeta.columns) && tableMeta.columns(index)) { + arr.push(index); + } + } + + return arr[visualColumnIndex]; + }; + + var physicalColumn = instance.toPhysicalColumn(columnIndex); + var prop = translateVisualIndexToColumns(physicalColumn); + + if (tableMeta.colHeaders === false) { + result = null; + } else if (tableMeta.columns && isFunction(tableMeta.columns) && tableMeta.columns(prop) && tableMeta.columns(prop).title) { + result = tableMeta.columns(prop).title; + } else if (tableMeta.columns && tableMeta.columns[physicalColumn] && tableMeta.columns[physicalColumn].title) { + result = tableMeta.columns[physicalColumn].title; + } else if (Array.isArray(tableMeta.colHeaders) && tableMeta.colHeaders[physicalColumn] !== void 0) { + result = tableMeta.colHeaders[physicalColumn]; + } else if (isFunction(tableMeta.colHeaders)) { + result = tableMeta.colHeaders(physicalColumn); + } else if (tableMeta.colHeaders && typeof tableMeta.colHeaders !== 'string' && typeof tableMeta.colHeaders !== 'number') { + result = spreadsheetColumnLabel(columnIndex); // see #1458 + } + } + + return result; + }; + /** + * Return column width from settings (no guessing). Private use intended. + * + * @private + * @memberof Core# + * @function _getColWidthFromSettings + * @param {number} col Visual col index. + * @returns {number} + */ + + + this._getColWidthFromSettings = function (col) { + var width; // We currently don't support cell meta objects for headers (negative values) + + if (col >= 0) { + var cellProperties = instance.getCellMeta(0, col); + width = cellProperties.width; + } + + if (width === void 0 || width === tableMeta.width) { + width = tableMeta.colWidths; + } + + if (width !== void 0 && width !== null) { + switch (_typeof$z(width)) { + case 'object': + // array + width = width[col]; + break; + + case 'function': + width = width(col); + break; + } + + if (typeof width === 'string') { + width = parseInt(width, 10); + } + } + + return width; + }; + /** + * Returns the width of the requested column. + * + * @memberof Core# + * @function getColWidth + * @param {number} column Visual column index. + * @returns {number} Column width. + * @fires Hooks#modifyColWidth + */ + + + this.getColWidth = function (column) { + var width = instance._getColWidthFromSettings(column); + + width = instance.runHooks('modifyColWidth', width, column); + + if (width === void 0) { + width = ViewportColumnsCalculator.DEFAULT_WIDTH; + } + + return width; + }; + /** + * Return row height from settings (no guessing). Private use intended. + * + * @private + * @memberof Core# + * @function _getRowHeightFromSettings + * @param {number} row Visual row index. + * @returns {number} + */ + + + this._getRowHeightFromSettings = function (row) { + // let cellProperties = instance.getCellMeta(row, 0); + // let height = cellProperties.height; + // + // if (height === void 0 || height === tableMeta.height) { + // height = cellProperties.rowHeights; + // } + var height = tableMeta.rowHeights; + + if (height !== void 0 && height !== null) { + switch (_typeof$z(height)) { + case 'object': + // array + height = height[row]; + break; + + case 'function': + height = height(row); + break; + } + + if (typeof height === 'string') { + height = parseInt(height, 10); + } + } + + return height; + }; + /** + * Returns the row height. + * + * @memberof Core# + * @function getRowHeight + * @param {number} row Visual row index. + * @returns {number} The given row's height. + * @fires Hooks#modifyRowHeight + */ + + + this.getRowHeight = function (row) { + var height = instance._getRowHeightFromSettings(row); + + height = instance.runHooks('modifyRowHeight', height, row); + return height; + }; + /** + * Returns the total number of rows in the data source. + * + * @memberof Core# + * @function countSourceRows + * @returns {number} Total number of rows. + */ + + + this.countSourceRows = function () { + return dataSource.countRows(); + }; + /** + * Returns the total number of columns in the data source. + * + * @memberof Core# + * @function countSourceCols + * @returns {number} Total number of columns. + */ + + + this.countSourceCols = function () { + return dataSource.countFirstRowKeys(); + }; + /** + * Returns the total number of visual rows in the table. + * + * @memberof Core# + * @function countRows + * @returns {number} Total number of rows. + */ + + + this.countRows = function () { + return datamap.getLength(); + }; + /** + * Returns the total number of visible columns in the table. + * + * @memberof Core# + * @function countCols + * @returns {number} Total number of columns. + */ + + + this.countCols = function () { + var maxCols = tableMeta.maxCols; + var dataLen = this.columnIndexMapper.getNotTrimmedIndexesLength(); + return Math.min(maxCols, dataLen); + }; + /** + * Returns the number of rendered rows (including rows partially or fully rendered outside viewport). + * + * @memberof Core# + * @function countRenderedRows + * @returns {number} Returns -1 if table is not visible. + */ + + + this.countRenderedRows = function () { + return instance.view.wt.drawn ? instance.view.wt.wtTable.getRenderedRowsCount() : -1; + }; + /** + * Returns the number of visible rows (rendered rows that fully fit inside viewport). + * + * @memberof Core# + * @function countVisibleRows + * @returns {number} Number of visible rows or -1. + */ + + + this.countVisibleRows = function () { + return instance.view.wt.drawn ? instance.view.wt.wtTable.getVisibleRowsCount() : -1; + }; + /** + * Returns the number of rendered columns (including columns partially or fully rendered outside viewport). + * + * @memberof Core# + * @function countRenderedCols + * @returns {number} Returns -1 if table is not visible. + */ + + + this.countRenderedCols = function () { + return instance.view.wt.drawn ? instance.view.wt.wtTable.getRenderedColumnsCount() : -1; + }; + /** + * Returns the number of visible columns. Returns -1 if table is not visible. + * + * @memberof Core# + * @function countVisibleCols + * @returns {number} Number of visible columns or -1. + */ + + + this.countVisibleCols = function () { + return instance.view.wt.drawn ? instance.view.wt.wtTable.getVisibleColumnsCount() : -1; + }; + /** + * Returns the number of empty rows. If the optional ending parameter is `true`, returns the + * number of empty rows at the bottom of the table. + * + * @memberof Core# + * @function countEmptyRows + * @param {boolean} [ending=false] If `true`, will only count empty rows at the end of the data source. + * @returns {number} Count empty rows. + */ + + + this.countEmptyRows = function () { + var ending = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var emptyRows = 0; + rangeEachReverse(instance.countRows() - 1, function (visualIndex) { + if (instance.isEmptyRow(visualIndex)) { + emptyRows += 1; + } else if (ending === true) { + return false; + } + }); + return emptyRows; + }; + /** + * Returns the number of empty columns. If the optional ending parameter is `true`, returns the number of empty + * columns at right hand edge of the table. + * + * @memberof Core# + * @function countEmptyCols + * @param {boolean} [ending=false] If `true`, will only count empty columns at the end of the data source row. + * @returns {number} Count empty cols. + */ + + + this.countEmptyCols = function () { + var ending = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + if (instance.countRows() < 1) { + return 0; + } + + var emptyColumns = 0; + rangeEachReverse(instance.countCols() - 1, function (visualIndex) { + if (instance.isEmptyCol(visualIndex)) { + emptyColumns += 1; + } else if (ending === true) { + return false; + } + }); + return emptyColumns; + }; + /** + * Check if all cells in the row declared by the `row` argument are empty. + * + * @memberof Core# + * @function isEmptyRow + * @param {number} row Visual row index. + * @returns {boolean} `true` if the row at the given `row` is empty, `false` otherwise. + */ + + + this.isEmptyRow = function (row) { + return tableMeta.isEmptyRow.call(instance, row); + }; + /** + * Check if all cells in the the column declared by the `column` argument are empty. + * + * @memberof Core# + * @function isEmptyCol + * @param {number} column Column index. + * @returns {boolean} `true` if the column at the given `col` is empty, `false` otherwise. + */ + + + this.isEmptyCol = function (column) { + return tableMeta.isEmptyCol.call(instance, column); + }; + /** + * Select cell specified by `row` and `column` values or a range of cells finishing at `endRow`, `endCol`. If the table + * was configured to support data column properties that properties can be used to making a selection. + * + * By default, viewport will be scrolled to the selection. After the `selectCell` method had finished, the instance + * will be listening to keyboard input on the document. + * + * @example + * ```js + * // select a single cell + * hot.selectCell(2, 4); + * // select a single cell using column property + * hot.selectCell(2, 'address'); + * // select a range of cells + * hot.selectCell(2, 4, 3, 5); + * // select a range of cells using column properties + * hot.selectCell(2, 'address', 3, 'phone_number'); + * // select a range of cells without scrolling to them + * hot.selectCell(2, 'address', 3, 'phone_number', false); + * ``` + * + * @memberof Core# + * @function selectCell + * @param {number} row Visual row index. + * @param {number|string} column Visual column index or column property. + * @param {number} [endRow] Visual end row index (if selecting a range). + * @param {number|string} [endColumn] Visual end column index or column property (if selecting a range). + * @param {boolean} [scrollToCell=true] If `true`, the viewport will be scrolled to the selection. + * @param {boolean} [changeListener=true] If `false`, Handsontable will not change keyboard events listener to himself. + * @returns {boolean} `true` if selection was successful, `false` otherwise. + */ + + + this.selectCell = function (row, column, endRow, endColumn) { + var scrollToCell = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true; + var changeListener = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true; + + if (isUndefined(row) || isUndefined(column)) { + return false; + } + + return this.selectCells([[row, column, endRow, endColumn]], scrollToCell, changeListener); + }; + /** + * Make multiple, non-contiguous selection specified by `row` and `column` values or a range of cells + * finishing at `endRow`, `endColumn`. The method supports two input formats which are the same as that + * produces by `getSelected` and `getSelectedRange` methods. + * + * By default, viewport will be scrolled to selection. After the `selectCells` method had finished, the instance + * will be listening to keyboard input on the document. + * + * @example + * ```js + * // Using an array of arrays. + * hot.selectCells([[1, 1, 2, 2], [3, 3], [6, 2, 0, 2]]); + * // Using an array of arrays with defined columns as props. + * hot.selectCells([[1, 'id', 2, 'first_name'], [3, 'full_name'], [6, 'last_name', 0, 'first_name']]); + * // Using an array of CellRange objects (produced by `.getSelectedRange()` method). + * const selected = hot.getSelectedRange(); + * + * selected[0].from.row = 0; + * selected[0].from.col = 0; + * + * hot.selectCells(selected); + * ``` + * + * @memberof Core# + * @since 0.38.0 + * @function selectCells + * @param {Array[]|CellRange[]} coords Visual coords passed as an array of array (`[[rowStart, columnStart, rowEnd, columnEnd], ...]`) + * the same format as `getSelected` method returns or as an CellRange objects + * which is the same format what `getSelectedRange` method returns. + * @param {boolean} [scrollToCell=true] If `true`, the viewport will be scrolled to the selection. + * @param {boolean} [changeListener=true] If `false`, Handsontable will not change keyboard events listener to himself. + * @returns {boolean} `true` if selection was successful, `false` otherwise. + */ + + + this.selectCells = function () { + var coords = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [[]]; + var scrollToCell = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var changeListener = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + + if (scrollToCell === false) { + preventScrollingToCell = true; + } + + var wasSelected = selection.selectCells(coords); + + if (wasSelected && changeListener) { + instance.listen(); + } + + preventScrollingToCell = false; + return wasSelected; + }; + /** + * Select column specified by `startColumn` visual index, column property or a range of columns finishing at `endColumn`. + * + * @example + * ```js + * // Select column using visual index. + * hot.selectColumns(1); + * // Select column using column property. + * hot.selectColumns('id'); + * // Select range of columns using visual indexes. + * hot.selectColumns(1, 4); + * // Select range of columns using column properties. + * hot.selectColumns('id', 'last_name'); + * ``` + * + * @memberof Core# + * @since 0.38.0 + * @function selectColumns + * @param {number} startColumn The visual column index from which the selection starts. + * @param {number} [endColumn=startColumn] The visual column index to which the selection finishes. If `endColumn` + * is not defined the column defined by `startColumn` will be selected. + * @returns {boolean} `true` if selection was successful, `false` otherwise. + */ + + + this.selectColumns = function (startColumn) { + var endColumn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startColumn; + return selection.selectColumns(startColumn, endColumn); + }; + /** + * Select row specified by `startRow` visual index or a range of rows finishing at `endRow`. + * + * @example + * ```js + * // Select row using visual index. + * hot.selectRows(1); + * // Select range of rows using visual indexes. + * hot.selectRows(1, 4); + * ``` + * + * @memberof Core# + * @since 0.38.0 + * @function selectRows + * @param {number} startRow The visual row index from which the selection starts. + * @param {number} [endRow=startRow] The visual row index to which the selection finishes. If `endRow` + * is not defined the row defined by `startRow` will be selected. + * @returns {boolean} `true` if selection was successful, `false` otherwise. + */ + + + this.selectRows = function (startRow) { + var endRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startRow; + return selection.selectRows(startRow, endRow); + }; + /** + * Deselects the current cell selection on the table. + * + * @memberof Core# + * @function deselectCell + */ + + + this.deselectCell = function () { + selection.deselect(); + }; + /** + * Select the whole table. The previous selection will be overwritten. + * + * @since 0.38.2 + * @memberof Core# + * @function selectAll + * @param {boolean} [includeHeaders=true] `true` If the selection should include the row, column and corner headers, + * `false` otherwise. + */ + + + this.selectAll = function () { + var includeHeaders = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + var includeRowHeaders = includeHeaders && this.hasRowHeaders(); + var includeColumnHeaders = includeHeaders && this.hasColHeaders(); + preventScrollingToCell = true; + selection.selectAll(includeRowHeaders, includeColumnHeaders); + preventScrollingToCell = false; + }; + + var getIndexToScroll = function getIndexToScroll(indexMapper, visualIndex) { + // Looking for a visual index on the right and then (when not found) on the left. + return indexMapper.getFirstNotHiddenIndex(visualIndex, 1, true); + }; + /** + * Scroll viewport to coordinates specified by the `row` and `column` arguments. + * + * @memberof Core# + * @function scrollViewportTo + * @param {number} [row] Row index. If the last argument isn't defined we treat the index as a visual row index. Otherwise, + * we are using the index for numbering only this rows which may be rendered (we don't consider hidden rows). + * @param {number} [column] Column index. If the last argument isn't defined we treat the index as a visual column index. + * Otherwise, we are using the index for numbering only this columns which may be rendered (we don't consider hidden columns). + * @param {boolean} [snapToBottom=false] If `true`, viewport is scrolled to show the cell on the bottom of the table. + * @param {boolean} [snapToRight=false] If `true`, viewport is scrolled to show the cell on the right side of the table. + * @param {boolean} [considerHiddenIndexes=true] If `true`, we handle visual indexes, otherwise we handle only indexes which + * may be rendered when they are in the viewport (we don't consider hidden indexes as they aren't rendered). + * @returns {boolean} `true` if scroll was successful, `false` otherwise. + */ + + + this.scrollViewportTo = function (row, column) { + var snapToBottom = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var snapToRight = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + var considerHiddenIndexes = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true; + var snapToTop = !snapToBottom; + var snapToLeft = !snapToRight; + var renderableRow = row; + var renderableColumn = column; + + if (considerHiddenIndexes) { + var _isRowInteger = Number.isInteger(row); + + var _isColumnInteger = Number.isInteger(column); + + var visualRowToScroll = _isRowInteger ? getIndexToScroll(this.rowIndexMapper, row) : void 0; + var visualColumnToScroll = _isColumnInteger ? getIndexToScroll(this.columnIndexMapper, column) : void 0; + + if (visualRowToScroll === null || visualColumnToScroll === null) { + return false; + } + + renderableRow = _isRowInteger ? instance.rowIndexMapper.getRenderableFromVisualIndex(visualRowToScroll) : void 0; + renderableColumn = _isColumnInteger ? instance.columnIndexMapper.getRenderableFromVisualIndex(visualColumnToScroll) : void 0; + } + + var isRowInteger = Number.isInteger(renderableRow); + var isColumnInteger = Number.isInteger(renderableColumn); + + if (isRowInteger && isColumnInteger) { + return instance.view.scrollViewport(new CellCoords(renderableRow, renderableColumn), snapToTop, snapToRight, snapToBottom, snapToLeft); + } + + if (isRowInteger && isColumnInteger === false) { + return instance.view.scrollViewportVertically(renderableRow, snapToTop, snapToBottom); + } + + if (isColumnInteger && isRowInteger === false) { + return instance.view.scrollViewportHorizontally(renderableColumn, snapToRight, snapToLeft); + } + + return false; + }; + /** + * Removes the table from the DOM and destroys the instance of the Handsontable. + * + * @memberof Core# + * @function destroy + * @fires Hooks#afterDestroy + */ + + + this.destroy = function () { + instance._clearTimeouts(); + + instance._clearImmediates(); + + if (instance.view) { + // in case HT is destroyed before initialization has finished + instance.view.destroy(); + } + + if (dataSource) { + dataSource.destroy(); + } + + dataSource = null; + metaManager.clearCache(); + stopObserving(); + + if (isRootInstance(instance)) { + var licenseInfo = this.rootDocument.querySelector('#hot-display-license-info'); + + if (licenseInfo) { + licenseInfo.parentNode.removeChild(licenseInfo); + } + } + + empty(instance.rootElement); + eventManager.destroy(); + + if (editorManager) { + editorManager.destroy(); + } // The plugin's `destroy` method is called as a consequence and it should handle + // unregistration of plugin's maps. Some unregistered maps reset the cache. + + + instance.batchExecution(function () { + pluginsRegistry.getItems().forEach(function (_ref19) { + var _ref20 = _slicedToArray$c(_ref19, 2), + plugin = _ref20[1]; + + plugin.destroy(); + }); + pluginsRegistry.clear(); + instance.runHooks('afterDestroy'); + }, true); + Hooks.getSingleton().destroy(instance); + objectEach(instance, function (property, key, obj) { + // replace instance methods with post mortem + if (isFunction(property)) { + obj[key] = postMortem(key); + } else if (key !== 'guid') { + // replace instance properties with null (restores memory) + // it should not be necessary but this prevents a memory leak side effects that show itself in Jasmine tests + obj[key] = null; + } + }); + instance.isDestroyed = true; // replace private properties with null (restores memory) + // it should not be necessary but this prevents a memory leak side effects that show itself in Jasmine tests + + if (datamap) { + datamap.destroy(); + } + + instance.rowIndexMapper = null; + instance.columnIndexMapper = null; + datamap = null; + grid = null; + selection = null; + editorManager = null; + instance = null; + }; + /** + * Replacement for all methods after the Handsontable was destroyed. + * + * @private + * @param {string} method The method name. + * @returns {Function} + */ + + + function postMortem(method) { + return function () { + throw new Error("The \"".concat(method, "\" method cannot be called because this Handsontable instance has been destroyed")); + }; + } + /** + * Returns the active editor class instance. + * + * @memberof Core# + * @function getActiveEditor + * @returns {BaseEditor} The active editor instance. + */ + + + this.getActiveEditor = function () { + return editorManager.getActiveEditor(); + }; + /** + * Returns plugin instance by provided its name. + * + * @memberof Core# + * @function getPlugin + * @param {string} pluginName The plugin name. + * @returns {BasePlugin|undefined} The plugin instance or undefined if there is no plugin. + */ + + + this.getPlugin = function (pluginName) { + var unifiedPluginName = toUpperCaseFirst(pluginName); // Workaround for the UndoRedo plugin which, currently doesn't follow the plugin architecture. + + if (unifiedPluginName === 'UndoRedo') { + return this.undoRedo; + } + + return pluginsRegistry.getItem(unifiedPluginName); + }; + /** + * Returns name of the passed plugin. + * + * @private + * @memberof Core# + * @param {BasePlugin} plugin The plugin instance. + * @returns {string} + */ + + + this.getPluginName = function (plugin) { + // Workaround for the UndoRedo plugin which, currently doesn't follow the plugin architecture. + if (plugin === this.undoRedo) { + return this.undoRedo.constructor.PLUGIN_KEY; + } + + return pluginsRegistry.getId(plugin); + }; + /** + * Returns the Handsontable instance. + * + * @memberof Core# + * @function getInstance + * @returns {Handsontable} The Handsontable instance. + */ + + + this.getInstance = function () { + return instance; + }; + /** + * Adds listener to the specified hook name (only for this Handsontable instance). + * + * @memberof Core# + * @function addHook + * @see Hooks#add + * @param {string} key Hook name (see {@link Hooks}). + * @param {Function|Array} callback Function or array of functions. + * @example + * ```js + * hot.addHook('beforeInit', myCallback); + * ``` + */ + + + this.addHook = function (key, callback) { + Hooks.getSingleton().add(key, callback, instance); + }; + /** + * Check if for a specified hook name there are added listeners (only for this Handsontable instance). All available + * hooks you will find {@link Hooks}. + * + * @memberof Core# + * @function hasHook + * @see Hooks#has + * @param {string} key Hook name. + * @returns {boolean} + * + * @example + * ```js + * const hasBeforeInitListeners = hot.hasHook('beforeInit'); + * ``` + */ + + + this.hasHook = function (key) { + return Hooks.getSingleton().has(key, instance); + }; + /** + * Adds listener to specified hook name (only for this Handsontable instance). After the listener is triggered, + * it will be automatically removed. + * + * @memberof Core# + * @function addHookOnce + * @see Hooks#once + * @param {string} key Hook name (see {@link Hooks}). + * @param {Function|Array} callback Function or array of functions. + * @example + * ```js + * hot.addHookOnce('beforeInit', myCallback); + * ``` + */ + + + this.addHookOnce = function (key, callback) { + Hooks.getSingleton().once(key, callback, instance); + }; + /** + * Removes the hook listener previously registered with {@link Core#addHook}. + * + * @memberof Core# + * @function removeHook + * @see Hooks#remove + * @param {string} key Hook name. + * @param {Function} callback Reference to the function which has been registered using {@link Core#addHook}. + * + * @example + * ```js + * hot.removeHook('beforeInit', myCallback); + * ``` + */ + + + this.removeHook = function (key, callback) { + Hooks.getSingleton().remove(key, callback, instance); + }; + /** + * Run the callbacks for the hook provided in the `key` argument using the parameters given in the other arguments. + * + * @memberof Core# + * @function runHooks + * @see Hooks#run + * @param {string} key Hook name. + * @param {*} [p1] Argument passed to the callback. + * @param {*} [p2] Argument passed to the callback. + * @param {*} [p3] Argument passed to the callback. + * @param {*} [p4] Argument passed to the callback. + * @param {*} [p5] Argument passed to the callback. + * @param {*} [p6] Argument passed to the callback. + * @returns {*} + * + * @example + * ```js + * // Run built-in hook + * hot.runHooks('beforeInit'); + * // Run custom hook + * hot.runHooks('customAction', 10, 'foo'); + * ``` + */ + + + this.runHooks = function (key, p1, p2, p3, p4, p5, p6) { + return Hooks.getSingleton().run(instance, key, p1, p2, p3, p4, p5, p6); + }; + /** + * Get language phrase for specified dictionary key. + * + * @memberof Core# + * @function getTranslatedPhrase + * @since 0.35.0 + * @param {string} dictionaryKey Constant which is dictionary key. + * @param {*} extraArguments Arguments which will be handled by formatters. + * @returns {string} + */ + + + this.getTranslatedPhrase = function (dictionaryKey, extraArguments) { + return getTranslatedPhrase(tableMeta.language, dictionaryKey, extraArguments); + }; + /** + * Converts instance into outerHTML of HTMLTableElement. + * + * @memberof Core# + * @function toHTML + * @since 7.1.0 + * @returns {string} + */ + + + this.toHTML = function () { + return instanceToHTML(_this); + }; + /** + * Converts instance into HTMLTableElement. + * + * @memberof Core# + * @function toTableElement + * @since 7.1.0 + * @returns {HTMLTableElement} + */ + + + this.toTableElement = function () { + var tempElement = _this.rootDocument.createElement('div'); + + tempElement.insertAdjacentHTML('afterbegin', instanceToHTML(_this)); + return tempElement.firstElementChild; + }; + + this.timeouts = []; + /** + * Sets timeout. Purpose of this method is to clear all known timeouts when `destroy` method is called. + * + * @param {number|Function} handle Handler returned from setTimeout or function to execute (it will be automatically wraped + * by setTimeout function). + * @param {number} [delay=0] If first argument is passed as a function this argument set delay of the execution of that function. + * @private + */ + + this._registerTimeout = function (handle) { + var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + var handleFunc = handle; + + if (typeof handleFunc === 'function') { + handleFunc = setTimeout(handleFunc, delay); + } + + this.timeouts.push(handleFunc); + }; + /** + * Clears all known timeouts. + * + * @private + */ + + + this._clearTimeouts = function () { + arrayEach(this.timeouts, function (handler) { + clearTimeout(handler); + }); + }; + + this.immediates = []; + /** + * Execute function execution to the next event loop cycle. Purpose of this method is to clear all known timeouts when `destroy` method is called. + * + * @param {Function} callback Function to be delayed in execution. + * @private + */ + + this._registerImmediate = function (callback) { + this.immediates.push(setImmediate(callback)); + }; + /** + * Clears all known timeouts. + * + * @private + */ + + + this._clearImmediates = function () { + arrayEach(this.immediates, function (handler) { + clearImmediate(handler); + }); + }; + /** + * Refresh selection borders. This is temporary method relic after selection rewrite. + * + * @private + * @param {boolean} [revertOriginal=false] If `true`, the previous value will be restored. Otherwise, the edited value will be saved. + * @param {boolean} [prepareEditorIfNeeded=true] If `true` the editor under the selected cell will be prepared to open. + */ + + + this._refreshBorders = function () { + var revertOriginal = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var prepareEditorIfNeeded = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + editorManager.destroyEditor(revertOriginal); + instance.view.render(); + + if (prepareEditorIfNeeded && selection.isSelected()) { + editorManager.prepareEditor(); + } + }; + + getPluginsNames().forEach(function (pluginName) { + var PluginClass = getPlugin(pluginName); + pluginsRegistry.addItem(pluginName, new PluginClass(_this)); + }); + Hooks.getSingleton().run(instance, 'construct'); +} + +/** + * autoResize - resizes a DOM element to the width and height of another DOM element + * + * Copyright 2014, Marcin Warpechowski + * Licensed under the MIT license + */ +function autoResize() { + var defaults = { + minHeight: 200, + maxHeight: 300, + minWidth: 100, + maxWidth: 300 + }, + el, + body = document.body, + text = document.createTextNode(''), + span = document.createElement('SPAN'), + observe = function observe(element, event, handler) { + element.addEventListener(event, handler, false); + }, + _unObserve = function unObserve(element, event, handler) { + element.removeEventListener(event, handler, false); + }, + resize = function resize(newChar) { + var width, scrollHeight; + + if (!newChar) { + newChar = ""; + } else if (!/^[a-zA-Z \.,\\\/\|0-9]$/.test(newChar)) { + newChar = "."; + } + + if (text.textContent !== void 0) { + text.textContent = el.value + newChar; + } else { + text.data = el.value + newChar; //IE8 + } + + span.style.fontSize = getComputedStyle(el).fontSize; + span.style.fontFamily = getComputedStyle(el).fontFamily; + span.style.whiteSpace = "pre"; + body.appendChild(span); + width = span.clientWidth + 2; + body.removeChild(span); + el.style.height = defaults.minHeight + 'px'; + + if (defaults.minWidth > width) { + el.style.width = defaults.minWidth + 'px'; + } else if (width > defaults.maxWidth) { + el.style.width = defaults.maxWidth + 'px'; + } else { + el.style.width = width + 'px'; + } + + scrollHeight = el.scrollHeight ? el.scrollHeight - 1 : 0; + + if (defaults.minHeight > scrollHeight) { + el.style.height = defaults.minHeight + 'px'; + } else if (defaults.maxHeight < scrollHeight) { + el.style.height = defaults.maxHeight + 'px'; + el.style.overflowY = 'visible'; + } else { + el.style.height = scrollHeight + 'px'; + } + }, + delayedResize = function delayedResize() { + window.setTimeout(resize, 0); + }, + extendDefaults = function extendDefaults(config) { + if (config && config.minHeight) { + if (config.minHeight == 'inherit') { + defaults.minHeight = el.clientHeight; + } else { + var minHeight = parseInt(config.minHeight); + + if (!isNaN(minHeight)) { + defaults.minHeight = minHeight; + } + } + } + + if (config && config.maxHeight) { + if (config.maxHeight == 'inherit') { + defaults.maxHeight = el.clientHeight; + } else { + var maxHeight = parseInt(config.maxHeight); + + if (!isNaN(maxHeight)) { + defaults.maxHeight = maxHeight; + } + } + } + + if (config && config.minWidth) { + if (config.minWidth == 'inherit') { + defaults.minWidth = el.clientWidth; + } else { + var minWidth = parseInt(config.minWidth); + + if (!isNaN(minWidth)) { + defaults.minWidth = minWidth; + } + } + } + + if (config && config.maxWidth) { + if (config.maxWidth == 'inherit') { + defaults.maxWidth = el.clientWidth; + } else { + var maxWidth = parseInt(config.maxWidth); + + if (!isNaN(maxWidth)) { + defaults.maxWidth = maxWidth; + } + } + } + + if (!span.firstChild) { + span.className = "autoResize"; + span.style.display = 'inline-block'; + span.appendChild(text); + } + }, + _init = function init(el_, config, doObserve) { + el = el_; + extendDefaults(config); + + if (el.nodeName == 'TEXTAREA') { + el.style.resize = 'none'; + el.style.overflowY = ''; + el.style.height = defaults.minHeight + 'px'; + el.style.minWidth = defaults.minWidth + 'px'; + el.style.maxWidth = defaults.maxWidth + 'px'; + el.style.overflowY = 'hidden'; + } + + if (doObserve) { + observe(el, 'change', resize); + observe(el, 'cut', delayedResize); + observe(el, 'paste', delayedResize); + observe(el, 'drop', delayedResize); + observe(el, 'keydown', delayedResize); + observe(el, 'focus', resize); + observe(el, 'compositionstart', delayedResize); + observe(el, 'compositionupdate', delayedResize); + observe(el, 'compositionend', delayedResize); + } + + resize(); + }; + + function getComputedStyle(element) { + return element.currentStyle || document.defaultView.getComputedStyle(element); + } + + return { + init: function init(el_, config, doObserve) { + _init(el_, config, doObserve); + }, + unObserve: function unObserve() { + _unObserve(el, 'change', resize); + + _unObserve(el, 'cut', delayedResize); + + _unObserve(el, 'paste', delayedResize); + + _unObserve(el, 'drop', delayedResize); + + _unObserve(el, 'keydown', delayedResize); + + _unObserve(el, 'focus', resize); + + _unObserve(el, 'compositionstart', delayedResize); + + _unObserve(el, 'compositionupdate', delayedResize); + + _unObserve(el, 'compositionend', delayedResize); + }, + resize: resize + }; +} + +function _typeof$A(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$A = function _typeof(obj) { return typeof obj; }; } else { _typeof$A = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$A(obj); } + +function _classCallCheck$15(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$10(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); } } + +function _createClass$10(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$10(Constructor.prototype, protoProps); if (staticProps) _defineProperties$10(Constructor, staticProps); return Constructor; } + +function _get$4(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$4 = Reflect.get; } else { _get$4 = function _get(target, property, receiver) { var base = _superPropBase$4(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$4(target, property, receiver || target); } + +function _superPropBase$4(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$p(object); if (object === null) break; } return object; } + +function _inherits$p(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$q(subClass, superClass); } + +function _setPrototypeOf$q(o, p) { _setPrototypeOf$q = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$q(o, p); } + +function _createSuper$p(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$q(); return function _createSuperInternal() { var Super = _getPrototypeOf$p(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$p(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$p(this, result); }; } + +function _possibleConstructorReturn$p(self, call) { if (call && (_typeof$A(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$p(self); } + +function _assertThisInitialized$p(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$q() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$p(o) { _getPrototypeOf$p = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$p(o); } +var EDITOR_VISIBLE_CLASS_NAME = 'ht_editor_visible'; +var EDITOR_HIDDEN_CLASS_NAME = 'ht_editor_hidden'; +var EDITOR_TYPE$1 = 'text'; +/** + * @private + * @class TextEditor + */ + +var TextEditor = /*#__PURE__*/function (_BaseEditor) { + _inherits$p(TextEditor, _BaseEditor); + + var _super = _createSuper$p(TextEditor); + + /** + * @param {Core} instance The Handsontable instance. + */ + function TextEditor(instance) { + var _this; + + _classCallCheck$15(this, TextEditor); + + _this = _super.call(this, instance); + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + _this.eventManager = new EventManager(_assertThisInitialized$p(_this)); + /** + * Autoresize instance. Automagically resizes editor after changes. + * + * @private + * @type {autoResize} + */ + + _this.autoResize = autoResize(); + /** + * An TEXTAREA element. + * + * @private + * @type {HTMLTextAreaElement} + */ + + _this.TEXTAREA = void 0; + /** + * Style declaration object of the TEXTAREA element. + * + * @private + * @type {CSSStyleDeclaration} + */ + + _this.textareaStyle = void 0; + /** + * Parent element of the TEXTAREA. + * + * @private + * @type {HTMLDivElement} + */ + + _this.TEXTAREA_PARENT = void 0; + /** + * Style declaration object of the TEXTAREA_PARENT element. + * + * @private + * @type {CSSStyleDeclaration} + */ + + _this.textareaParentStyle = void 0; + /** + * Z-index class style for the editor. + * + * @private + * @type {string} + */ + + _this.layerClass = void 0; + + _this.createElements(); + + _this.bindEvents(); + + _this.hot.addHookOnce('afterDestroy', function () { + return _this.destroy(); + }); + + return _this; + } + /** + * Gets current value from editable element. + * + * @returns {number} + */ + + + _createClass$10(TextEditor, [{ + key: "getValue", + value: function getValue() { + return this.TEXTAREA.value; + } + /** + * Sets new value into editable element. + * + * @param {*} newValue The editor value. + */ + + }, { + key: "setValue", + value: function setValue(newValue) { + this.TEXTAREA.value = newValue; + } + /** + * Opens the editor and adjust its size. + */ + + }, { + key: "open", + value: function open() { + var _this2 = this; + + this.refreshDimensions(); // need it instantly, to prevent https://github.com/handsontable/handsontable/issues/348 + + this.showEditableElement(); + this.addHook('beforeKeyDown', function (event) { + return _this2.onBeforeKeyDown(event); + }); + } + /** + * Closes the editor. + */ + + }, { + key: "close", + value: function close() { + this.autoResize.unObserve(); + + if (this.hot.rootDocument.activeElement === this.TEXTAREA) { + this.hot.listen(); // don't refocus the table if user focused some cell outside of HT on purpose + } + + this.hideEditableElement(); + this.removeHooksByKey('beforeKeyDown'); + } + /** + * Prepares editor's meta data. + * + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {HTMLTableCellElement} td The rendered cell element. + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + + }, { + key: "prepare", + value: function prepare(row, col, prop, td, value, cellProperties) { + var previousState = this.state; + + _get$4(_getPrototypeOf$p(TextEditor.prototype), "prepare", this).call(this, row, col, prop, td, value, cellProperties); + + if (!cellProperties.readOnly) { + this.refreshDimensions(true); + var allowInvalid = cellProperties.allowInvalid, + fragmentSelection = cellProperties.fragmentSelection; + + if (allowInvalid) { + // Remove an empty space from texarea (added by copyPaste plugin to make copy/paste + // functionality work with IME) + this.TEXTAREA.value = ''; + } + + if (previousState !== EDITOR_STATE.FINISHED) { + this.hideEditableElement(); + } // @TODO: The fragmentSelection functionality is conflicted with IME. For this feature + // refocus has to be disabled (to make IME working). + + + var restoreFocus = !fragmentSelection; + + if (restoreFocus && !isMobileBrowser()) { + this.focus(); + } + } + } + /** + * Begins editing on a highlighted cell and hides fillHandle corner if was present. + * + * @param {*} newInitialValue The editor initial value. + * @param {Event} event The keyboard event object. + */ + + }, { + key: "beginEditing", + value: function beginEditing(newInitialValue, event) { + if (this.state !== EDITOR_STATE.VIRGIN) { + return; + } + + this.TEXTAREA.value = ''; // Remove an empty space from texarea (added by copyPaste plugin to make copy/paste functionality work with IME). + + _get$4(_getPrototypeOf$p(TextEditor.prototype), "beginEditing", this).call(this, newInitialValue, event); + } + /** + * Sets focus state on the select element. + */ + + }, { + key: "focus", + value: function focus() { + // For IME editor textarea element must be focused using ".select" method. + // Using ".focus" browser automatically scroll into the focused element which + // is undesire effect. + this.TEXTAREA.select(); + setCaretPosition(this.TEXTAREA, this.TEXTAREA.value.length); + } + /** + * Creates an editor's elements and adds necessary CSS classnames. + */ + + }, { + key: "createElements", + value: function createElements() { + var rootDocument = this.hot.rootDocument; + this.TEXTAREA = rootDocument.createElement('TEXTAREA'); + this.TEXTAREA.setAttribute('data-hot-input', ''); // Makes the element recognizable by Hot as its own component's element. + + this.TEXTAREA.tabIndex = -1; + addClass(this.TEXTAREA, 'handsontableInput'); + this.textareaStyle = this.TEXTAREA.style; + this.textareaStyle.width = 0; + this.textareaStyle.height = 0; + this.textareaStyle.overflowY = 'visible'; + this.TEXTAREA_PARENT = rootDocument.createElement('DIV'); + addClass(this.TEXTAREA_PARENT, 'handsontableInputHolder'); + + if (hasClass(this.TEXTAREA_PARENT, this.layerClass)) { + removeClass(this.TEXTAREA_PARENT, this.layerClass); + } + + addClass(this.TEXTAREA_PARENT, EDITOR_HIDDEN_CLASS_NAME); + this.textareaParentStyle = this.TEXTAREA_PARENT.style; + this.TEXTAREA_PARENT.appendChild(this.TEXTAREA); + this.hot.rootElement.appendChild(this.TEXTAREA_PARENT); + } + /** + * Moves an editable element out of the viewport, but element must be able to hold focus for IME support. + * + * @private + */ + + }, { + key: "hideEditableElement", + value: function hideEditableElement() { + if (isIE() || isEdge()) { + this.textareaStyle.textIndent = '-99999px'; + } + + this.textareaStyle.overflowY = 'visible'; + this.textareaParentStyle.opacity = '0'; + this.textareaParentStyle.height = '1px'; + + if (hasClass(this.TEXTAREA_PARENT, this.layerClass)) { + removeClass(this.TEXTAREA_PARENT, this.layerClass); + } + + addClass(this.TEXTAREA_PARENT, EDITOR_HIDDEN_CLASS_NAME); + } + /** + * Resets an editable element position. + * + * @private + */ + + }, { + key: "showEditableElement", + value: function showEditableElement() { + this.textareaParentStyle.height = ''; + this.textareaParentStyle.overflow = ''; + this.textareaParentStyle.position = ''; + this.textareaParentStyle.right = 'auto'; + this.textareaParentStyle.opacity = '1'; + this.textareaStyle.textIndent = ''; + this.textareaStyle.overflowY = 'hidden'; + var childNodes = this.TEXTAREA_PARENT.childNodes; + var hasClassHandsontableEditor = false; + rangeEach(childNodes.length - 1, function (index) { + var childNode = childNodes[index]; + + if (hasClass(childNode, 'handsontableEditor')) { + hasClassHandsontableEditor = true; + return false; + } + }); + + if (hasClass(this.TEXTAREA_PARENT, EDITOR_HIDDEN_CLASS_NAME)) { + removeClass(this.TEXTAREA_PARENT, EDITOR_HIDDEN_CLASS_NAME); + } + + if (hasClassHandsontableEditor) { + this.layerClass = EDITOR_VISIBLE_CLASS_NAME; + addClass(this.TEXTAREA_PARENT, this.layerClass); + } else { + this.layerClass = this.getEditedCellsLayerClass(); + addClass(this.TEXTAREA_PARENT, this.layerClass); + } + } + /** + * Refreshes editor's value using source data. + * + * @private + */ + + }, { + key: "refreshValue", + value: function refreshValue() { + var physicalRow = this.hot.toPhysicalRow(this.row); + var sourceData = this.hot.getSourceDataAtCell(physicalRow, this.col); + this.originalValue = sourceData; + this.setValue(sourceData); + this.refreshDimensions(); + } + /** + * Refreshes editor's size and position. + * + * @private + * @param {boolean} force Indicates if the refreshing editor dimensions should be triggered. + */ + + }, { + key: "refreshDimensions", + value: function refreshDimensions() { + var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + if (this.state !== EDITOR_STATE.EDITING && !force) { + return; + } + + this.TD = this.getEditedCell(); // TD is outside of the viewport. + + if (!this.TD) { + if (!force) { + this.close(); // TODO shouldn't it be this.finishEditing() ? + } + + return; + } + + var _this$hot$view$wt = this.hot.view.wt, + wtOverlays = _this$hot$view$wt.wtOverlays, + wtViewport = _this$hot$view$wt.wtViewport; + var currentOffset = offset(this.TD); + var containerOffset = offset(this.hot.rootElement); + var scrollableContainerTop = wtOverlays.topOverlay.holder; + var scrollableContainerLeft = wtOverlays.leftOverlay.holder; + var containerScrollTop = scrollableContainerTop !== this.hot.rootWindow ? scrollableContainerTop.scrollTop : 0; + var containerScrollLeft = scrollableContainerLeft !== this.hot.rootWindow ? scrollableContainerLeft.scrollLeft : 0; + var editorSection = this.checkEditorSection(); + var scrollTop = ['', 'left'].includes(editorSection) ? containerScrollTop : 0; + var scrollLeft = ['', 'top', 'bottom'].includes(editorSection) ? containerScrollLeft : 0; // If colHeaders is disabled, cells in the first row have border-top + + var editTopModifier = currentOffset.top === containerOffset.top ? 0 : 1; + var backgroundColor = this.TD.style.backgroundColor; + var editTop = currentOffset.top - containerOffset.top - editTopModifier - scrollTop; + var editLeft = currentOffset.left - containerOffset.left - 1 - scrollLeft; + var cssTransformOffset; // TODO: Refactor this to the new instance.getCell method (from #ply-59), after 0.12.1 is released + + switch (editorSection) { + case 'top': + cssTransformOffset = getCssTransform(wtOverlays.topOverlay.clone.wtTable.holder.parentNode); + break; + + case 'left': + cssTransformOffset = getCssTransform(wtOverlays.leftOverlay.clone.wtTable.holder.parentNode); + break; + + case 'top-left-corner': + cssTransformOffset = getCssTransform(wtOverlays.topLeftCornerOverlay.clone.wtTable.holder.parentNode); + break; + + case 'bottom-left-corner': + cssTransformOffset = getCssTransform(wtOverlays.bottomLeftCornerOverlay.clone.wtTable.holder.parentNode); + break; + + case 'bottom': + cssTransformOffset = getCssTransform(wtOverlays.bottomOverlay.clone.wtTable.holder.parentNode); + break; + } + + var hasColumnHeaders = this.hot.hasColHeaders(); + var renderableRow = this.hot.rowIndexMapper.getRenderableFromVisualIndex(this.row); + var renderableColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(this.col); + var nrOfRenderableRowIndexes = this.hot.rowIndexMapper.getRenderableIndexesLength(); + var firstRowIndexOfTheBottomOverlay = nrOfRenderableRowIndexes - this.hot.view.wt.getSetting('fixedRowsBottom'); + + if (hasColumnHeaders && renderableRow <= 0 || renderableRow === firstRowIndexOfTheBottomOverlay) { + editTop += 1; + } + + if (renderableColumn <= 0) { + editLeft += 1; + } + + if (cssTransformOffset && cssTransformOffset !== -1) { + this.textareaParentStyle[cssTransformOffset[0]] = cssTransformOffset[1]; + } else { + resetCssTransform(this.TEXTAREA_PARENT); + } + + this.textareaParentStyle.top = "".concat(editTop, "px"); + this.textareaParentStyle.left = "".concat(editLeft, "px"); + this.showEditableElement(); + var firstRowOffset = wtViewport.rowsRenderCalculator.startPosition; + var firstColumnOffset = wtViewport.columnsRenderCalculator.startPosition; + var horizontalScrollPosition = wtOverlays.leftOverlay.getScrollPosition(); + var verticalScrollPosition = wtOverlays.topOverlay.getScrollPosition(); + var scrollbarWidth = getScrollbarWidth(this.hot.rootDocument); + var cellTopOffset = this.TD.offsetTop + firstRowOffset - verticalScrollPosition; + var cellLeftOffset = this.TD.offsetLeft + firstColumnOffset - horizontalScrollPosition; + var width = innerWidth(this.TD) - 8; + var actualVerticalScrollbarWidth = hasVerticalScrollbar(scrollableContainerTop) ? scrollbarWidth : 0; + var actualHorizontalScrollbarWidth = hasHorizontalScrollbar(scrollableContainerLeft) ? scrollbarWidth : 0; + var maxWidth = this.hot.view.maximumVisibleElementWidth(cellLeftOffset) - 9 - actualVerticalScrollbarWidth; + var height = this.TD.scrollHeight + 1; + var maxHeight = Math.max(this.hot.view.maximumVisibleElementHeight(cellTopOffset) - actualHorizontalScrollbarWidth, 23); // eslint-disable-line max-len + + var cellComputedStyle = getComputedStyle(this.TD, this.hot.rootWindow); + this.TEXTAREA.style.fontSize = cellComputedStyle.fontSize; + this.TEXTAREA.style.fontFamily = cellComputedStyle.fontFamily; + this.TEXTAREA.style.backgroundColor = backgroundColor; + this.autoResize.init(this.TEXTAREA, { + minHeight: Math.min(height, maxHeight), + maxHeight: maxHeight, + // TEXTAREA should never be higher than visible part of the viewport (should not cover the scrollbar) + minWidth: Math.min(width, maxWidth), + maxWidth: maxWidth // TEXTAREA should never be wider than visible part of the viewport (should not cover the scrollbar) + + }, true); + } + /** + * Binds events and hooks. + * + * @private + */ + + }, { + key: "bindEvents", + value: function bindEvents() { + var _this3 = this; + + this.eventManager.addEventListener(this.TEXTAREA, 'cut', function (event) { + return event.stopPropagation(); + }); + this.eventManager.addEventListener(this.TEXTAREA, 'paste', function (event) { + return event.stopPropagation(); + }); + this.addHook('afterScrollHorizontally', function () { + return _this3.refreshDimensions(); + }); + this.addHook('afterScrollVertically', function () { + return _this3.refreshDimensions(); + }); + this.addHook('afterColumnResize', function () { + _this3.refreshDimensions(); + + _this3.focus(); + }); + this.addHook('afterRowResize', function () { + _this3.refreshDimensions(); + + _this3.focus(); + }); + } + /** + * Ugly hack for autocompleteEditor. + * + * @private + */ + + }, { + key: "allowKeyEventPropagation", + value: function allowKeyEventPropagation() {} + /** + * Destroys the internal event manager and clears attached hooks. + * + * @private + */ + + }, { + key: "destroy", + value: function destroy() { + this.eventManager.destroy(); + this.clearHooks(); + } + /** + * OnBeforeKeyDown callback. + * + * @param {Event} event The keyboard event object. + */ + + }, { + key: "onBeforeKeyDown", + value: function onBeforeKeyDown(event) { + // catch CTRL but not right ALT (which in some systems triggers ALT+CTRL) + var ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey; // Process only events that have been fired in the editor + + if (event.target !== this.TEXTAREA || isImmediatePropagationStopped(event)) { + return; + } + + switch (event.keyCode) { + case KEY_CODES.ARROW_RIGHT: + if (this.isInFullEditMode()) { + if (!this.isWaiting() && !this.allowKeyEventPropagation(event.keyCode)) { + stopImmediatePropagation(event); + } + } + + break; + + case KEY_CODES.ARROW_LEFT: + if (this.isInFullEditMode()) { + if (!this.isWaiting() && !this.allowKeyEventPropagation(event.keyCode)) { + stopImmediatePropagation(event); + } + } + + break; + + case KEY_CODES.ARROW_UP: + case KEY_CODES.ARROW_DOWN: + if (this.isInFullEditMode()) { + if (!this.isWaiting() && !this.allowKeyEventPropagation(event.keyCode)) { + stopImmediatePropagation(event); + } + } + + break; + + case KEY_CODES.ENTER: + { + var isMultipleSelection = this.hot.selection.isMultiple(); + + if (ctrlDown && !isMultipleSelection || event.altKey) { + // if ctrl+enter or alt+enter, add new line + if (this.isOpened()) { + var caretPosition = getCaretPosition(this.TEXTAREA); + var value = this.getValue(); + var newValue = "".concat(value.slice(0, caretPosition), "\n").concat(value.slice(caretPosition)); + this.setValue(newValue); + setCaretPosition(this.TEXTAREA, caretPosition + 1); + } else { + this.beginEditing("".concat(this.originalValue, "\n")); + } + + stopImmediatePropagation(event); + } + + event.preventDefault(); // don't add newline to field + + break; + } + + case KEY_CODES.BACKSPACE: + case KEY_CODES.DELETE: + case KEY_CODES.HOME: + case KEY_CODES.END: + stopImmediatePropagation(event); // backspace, delete, home, end should only work locally when cell is edited (not in table context) + + break; + } + + var arrowKeyCodes = [KEY_CODES.ARROW_UP, KEY_CODES.ARROW_RIGHT, KEY_CODES.ARROW_DOWN, KEY_CODES.ARROW_LEFT]; + + if (arrowKeyCodes.indexOf(event.keyCode) === -1) { + this.autoResize.resize(String.fromCharCode(event.keyCode)); + } + } + }], [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE$1; + } + }]); + + return TextEditor; +}(BaseEditor); + +/** + * Adds appropriate CSS class to table cell, based on cellProperties. + */ +var RENDERER_TYPE = 'base'; +/** + * @param {Core} instance The Handsontable instance. + * @param {HTMLTableCellElement} TD The rendered cell element. + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + +function baseRenderer(instance, TD, row, col, prop, value, cellProperties) { + var classesToAdd = []; + var classesToRemove = []; + + if (cellProperties.className) { + addClass(TD, cellProperties.className); + } + + if (cellProperties.readOnly) { + classesToAdd.push(cellProperties.readOnlyCellClassName); + } + + if (cellProperties.valid === false && cellProperties.invalidCellClassName) { + classesToAdd.push(cellProperties.invalidCellClassName); + } else { + classesToRemove.push(cellProperties.invalidCellClassName); + } + + if (cellProperties.wordWrap === false && cellProperties.noWordWrapClassName) { + classesToAdd.push(cellProperties.noWordWrapClassName); + } + + if (!value && cellProperties.placeholder) { + classesToAdd.push(cellProperties.placeholderCellClassName); + } + + removeClass(TD, classesToRemove); + addClass(TD, classesToAdd); +} +baseRenderer.RENDERER_TYPE = RENDERER_TYPE; + +var RENDERER_TYPE$1 = 'text'; +/** + * Default text renderer. + * + * @private + * @param {Core} instance The Handsontable instance. + * @param {HTMLTableCellElement} TD The rendered cell element. + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + +function textRenderer(instance, TD, row, col, prop, value, cellProperties) { + baseRenderer.apply(this, [instance, TD, row, col, prop, value, cellProperties]); + var escaped = value; + + if (!escaped && cellProperties.placeholder) { + escaped = cellProperties.placeholder; + } + + escaped = stringify(escaped); + + if (!instance.getSettings().trimWhitespace && !instance.getSettings().wordWrap) { + // 160 is   which won't wrap and preserves sequences of whitespace + escaped = escaped.replace(/ /g, String.fromCharCode(160)); + } + + if (cellProperties.rendererTemplate) { + empty(TD); + var TEMPLATE = instance.rootDocument.createElement('TEMPLATE'); + TEMPLATE.setAttribute('bind', '{{}}'); + TEMPLATE.innerHTML = cellProperties.rendererTemplate; + HTMLTemplateElement.decorate(TEMPLATE); + TEMPLATE.model = instance.getSourceDataAtRow(row); + TD.appendChild(TEMPLATE); + } else { + // this is faster than innerHTML. See: https://github.com/handsontable/handsontable/wiki/JavaScript-&-DOM-performance-tips + fastInnerText(TD, escaped); + } +} +textRenderer.RENDERER_TYPE = RENDERER_TYPE$1; + +var CELL_TYPE$1 = 'text'; +var TextCellType = { + CELL_TYPE: CELL_TYPE$1, + editor: TextEditor, + renderer: textRenderer +}; + +_register$3(TextCellType); +/** + * @param {HTMLElement} rootElement The element to which the Handsontable instance is injected. + * @param {object} userSettings The user defined options. + * @returns {Core} + */ + +function Handsontable(rootElement, userSettings) { + var instance = new Core(rootElement, userSettings || {}, rootInstanceSymbol); + instance.init(); + return instance; +} + +Handsontable.Core = function (rootElement) { + var userSettings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + return new Core(rootElement, userSettings, rootInstanceSymbol); +}; + +Handsontable.packageName = 'handsontable'; +Handsontable.buildDate = "09/02/2021 09:15:32"; +Handsontable.version = "8.3.1"; +Handsontable.languages = { + dictionaryKeys: dictionaryKeys, + getLanguageDictionary: getLanguageDictionary, + getLanguagesDictionaries: getLanguagesDictionaries, + registerLanguageDictionary: registerLanguageDictionary, + getTranslatedPhrase: getTranslatedPhrase +}; + +/** + * @param {Core} Handsontable The Handsontable instance. + */ +function jQueryWrapper(Handsontable) { + // eslint-disable-next-line + var jQuery = typeof window === 'undefined' ? false : window.jQuery; + + if (!jQuery) { + return; + } + + jQuery.fn.handsontable = function (action) { + var $this = this.first(); // Use only first element from list + + var instance = $this.data('handsontable'); // Init case + + if (typeof action !== 'string') { + var userSettings = action || {}; + + if (instance) { + instance.updateSettings(userSettings); + } else { + instance = new Handsontable.Core($this[0], userSettings); + $this.data('handsontable', instance); + instance.init(); + } + + return $this; + } + + var output; // Action case + + if (instance) { + if (typeof instance[action] !== 'undefined') { + var _instance$action; + + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + output = (_instance$action = instance[action]).call.apply(_instance$action, [instance].concat(args)); + + if (action === 'destroy') { + $this.removeData(); + } + } else { + throw new Error("Handsontable do not provide action: ".concat(action)); + } + } + + return output; + }; +} + +function _classCallCheck$16(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$11(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); } } + +function _createClass$11(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$11(Constructor.prototype, protoProps); if (staticProps) _defineProperties$11(Constructor, staticProps); return Constructor; } +/** + * @class GhostTable + * @util + */ + +var GhostTable = /*#__PURE__*/function () { + function GhostTable(hotInstance) { + _classCallCheck$16(this, GhostTable); + + /** + * Handsontable instance. + * + * @type {Core} + */ + this.hot = hotInstance; + /** + * Container element where every table will be injected. + * + * @type {HTMLElement|null} + */ + + this.container = null; + /** + * Flag which determine is table was injected to DOM. + * + * @type {boolean} + */ + + this.injected = false; + /** + * Added rows collection. + * + * @type {Array} + */ + + this.rows = []; + /** + * Added columns collection. + * + * @type {Array} + */ + + this.columns = []; + /** + * Samples prepared for calculations. + * + * @type {Map} + * @default {null} + */ + + this.samples = null; + /** + * Ghost table settings. + * + * @type {object} + * @default {Object} + */ + + this.settings = { + useHeaders: true + }; + } + /** + * Add row. + * + * @param {number} row Row index. + * @param {Map} samples Samples Map object. + */ + + + _createClass$11(GhostTable, [{ + key: "addRow", + value: function addRow(row, samples) { + if (this.columns.length) { + throw new Error('Doesn\'t support multi-dimensional table'); + } + + if (!this.rows.length) { + this.container = this.createContainer(this.hot.rootElement.className); + } + + var rowObject = { + row: row + }; + this.rows.push(rowObject); + this.samples = samples; + this.table = this.createTable(this.hot.table.className); + this.table.colGroup.appendChild(this.createColGroupsCol()); + this.table.tr.appendChild(this.createRow(row)); + this.container.container.appendChild(this.table.fragment); + rowObject.table = this.table.table; + } + /** + * Add a row consisting of the column headers. + * + * @param {Map} samples A map with sampled table values. + */ + + }, { + key: "addColumnHeadersRow", + value: function addColumnHeadersRow(samples) { + var colHeader = this.hot.getColHeader(0); + + if (colHeader !== null && colHeader !== void 0) { + var rowObject = { + row: -1 + }; + this.rows.push(rowObject); + this.container = this.createContainer(this.hot.rootElement.className); + this.samples = samples; + this.table = this.createTable(this.hot.table.className); + this.table.colGroup.appendChild(this.createColGroupsCol()); + this.table.tHead.appendChild(this.createColumnHeadersRow()); + this.container.container.appendChild(this.table.fragment); + rowObject.table = this.table.table; + } + } + /** + * Add column. + * + * @param {number} column Column index. + * @param {Map} samples A map with sampled table values. + */ + + }, { + key: "addColumn", + value: function addColumn(column, samples) { + if (this.rows.length) { + throw new Error('Doesn\'t support multi-dimensional table'); + } + + if (!this.columns.length) { + this.container = this.createContainer(this.hot.rootElement.className); + } + + var columnObject = { + col: column + }; + this.columns.push(columnObject); + this.samples = samples; + this.table = this.createTable(this.hot.table.className); + + if (this.getSetting('useHeaders') && this.hot.getColHeader(column) !== null) { + // Please keep in mind that the renderable column index equal to the visual columns index for the GhostTable. + // We render all columns. + this.hot.view.appendColHeader(column, this.table.th); + } + + this.table.tBody.appendChild(this.createCol(column)); + this.container.container.appendChild(this.table.fragment); + columnObject.table = this.table.table; + } + /** + * Get calculated heights. + * + * @param {Function} callback Callback which will be fired for each calculated row. + */ + + }, { + key: "getHeights", + value: function getHeights(callback) { + if (!this.injected) { + this.injectTable(); + } + + arrayEach(this.rows, function (row) { + // -1 <- reduce border-top from table + callback(row.row, outerHeight(row.table) - 1); + }); + } + /** + * Get calculated widths. + * + * @param {Function} callback Callback which will be fired for each calculated column. + */ + + }, { + key: "getWidths", + value: function getWidths(callback) { + if (!this.injected) { + this.injectTable(); + } + + arrayEach(this.columns, function (column) { + callback(column.col, outerWidth(column.table)); + }); + } + /** + * Set the Ghost Table settings to the provided object. + * + * @param {object} settings New Ghost Table Settings. + */ + + }, { + key: "setSettings", + value: function setSettings(settings) { + this.settings = settings; + } + /** + * Set a single setting of the Ghost Table. + * + * @param {string} name Setting name. + * @param {*} value Setting value. + */ + + }, { + key: "setSetting", + value: function setSetting(name, value) { + if (!this.settings) { + this.settings = {}; + } + + this.settings[name] = value; + } + /** + * Get the Ghost Table settings. + * + * @returns {object|null} + */ + + }, { + key: "getSettings", + value: function getSettings() { + return this.settings; + } + /** + * Get a single Ghost Table setting. + * + * @param {string} name The setting name to get. + * @returns {boolean|null} + */ + + }, { + key: "getSetting", + value: function getSetting(name) { + if (this.settings) { + return this.settings[name]; + } + + return null; + } + /** + * Create colgroup col elements. + * + * @returns {DocumentFragment} + */ + + }, { + key: "createColGroupsCol", + value: function createColGroupsCol() { + var _this = this; + + var fragment = this.hot.rootDocument.createDocumentFragment(); + + if (this.hot.hasRowHeaders()) { + fragment.appendChild(this.createColElement(-1)); + } + + this.samples.forEach(function (sample) { + arrayEach(sample.strings, function (string) { + fragment.appendChild(_this.createColElement(string.col)); + }); + }); + return fragment; + } + /** + * Create table row element. + * + * @param {number} row Row index. + * @returns {DocumentFragment} Returns created table row elements. + */ + + }, { + key: "createRow", + value: function createRow(row) { + var _this2 = this; + + var rootDocument = this.hot.rootDocument; + var fragment = rootDocument.createDocumentFragment(); + var th = rootDocument.createElement('th'); + + if (this.hot.hasRowHeaders()) { + this.hot.view.appendRowHeader(row, th); + fragment.appendChild(th); + } + + this.samples.forEach(function (sample) { + arrayEach(sample.strings, function (string) { + var column = string.col; + + var cellProperties = _this2.hot.getCellMeta(row, column); + + cellProperties.col = column; + cellProperties.row = row; + + var renderer = _this2.hot.getCellRenderer(cellProperties); + + var td = rootDocument.createElement('td'); // Indicate that this element is created and supported by GhostTable. It can be useful to + // exclude rendering performance costly logic or exclude logic which doesn't work within a hidden table. + + td.setAttribute('ghost-table', 1); + renderer(_this2.hot, td, row, column, _this2.hot.colToProp(column), string.value, cellProperties); + fragment.appendChild(td); + }); + }); + return fragment; + } + }, { + key: "createColumnHeadersRow", + value: function createColumnHeadersRow() { + var _this3 = this; + + var rootDocument = this.hot.rootDocument; + var fragment = rootDocument.createDocumentFragment(); + + if (this.hot.hasRowHeaders()) { + var th = rootDocument.createElement('th'); + this.hot.view.appendColHeader(-1, th); + fragment.appendChild(th); + } + + this.samples.forEach(function (sample) { + arrayEach(sample.strings, function (string) { + var column = string.col; + var th = rootDocument.createElement('th'); // Please keep in mind that the renderable column index equal to the visual columns index for the GhostTable. + // We render all columns. + + _this3.hot.view.appendColHeader(column, th); + + fragment.appendChild(th); + }); + }); + return fragment; + } + /** + * Create table column elements. + * + * @param {number} column Column index. + * @returns {DocumentFragment} Returns created column table column elements. + */ + + }, { + key: "createCol", + value: function createCol(column) { + var _this4 = this; + + var rootDocument = this.hot.rootDocument; + var fragment = rootDocument.createDocumentFragment(); + this.samples.forEach(function (sample) { + arrayEach(sample.strings, function (string) { + var row = string.row; + + var cellProperties = _this4.hot.getCellMeta(row, column); + + cellProperties.col = column; + cellProperties.row = row; + + var renderer = _this4.hot.getCellRenderer(cellProperties); + + var td = rootDocument.createElement('td'); + var tr = rootDocument.createElement('tr'); // Indicate that this element is created and supported by GhostTable. It can be useful to + // exclude rendering performance costly logic or exclude logic which doesn't work within a hidden table. + + td.setAttribute('ghost-table', 1); + renderer(_this4.hot, td, row, column, _this4.hot.colToProp(column), string.value, cellProperties); + tr.appendChild(td); + fragment.appendChild(tr); + }); + }); + return fragment; + } + /** + * Remove table from document and reset internal state. + */ + + }, { + key: "clean", + value: function clean() { + this.rows.length = 0; + this.rows[-1] = void 0; + this.columns.length = 0; + + if (this.samples) { + this.samples.clear(); + } + + this.samples = null; + this.removeTable(); + } + /** + * Inject generated table into document. + * + * @param {HTMLElement} [parent=null] The element to which the ghost table is injected. + */ + + }, { + key: "injectTable", + value: function injectTable() { + var parent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + if (!this.injected) { + (parent || this.hot.rootElement).appendChild(this.container.fragment); + this.injected = true; + } + } + /** + * Remove table from document. + */ + + }, { + key: "removeTable", + value: function removeTable() { + if (this.injected && this.container.container.parentNode) { + this.container.container.parentNode.removeChild(this.container.container); + this.container = null; + this.injected = false; + } + } + /** + * Create col element. + * + * @param {number} column Column index. + * @returns {HTMLElement} + */ + + }, { + key: "createColElement", + value: function createColElement(column) { + var col = this.hot.rootDocument.createElement('col'); + col.style.width = "".concat(this.hot.view.wt.wtTable.getStretchedColumnWidth(column), "px"); + return col; + } + /** + * Create table element. + * + * @param {string} className The CSS classes to add. + * @returns {object} + */ + + }, { + key: "createTable", + value: function createTable() { + var className = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + var rootDocument = this.hot.rootDocument; + var fragment = rootDocument.createDocumentFragment(); + var table = rootDocument.createElement('table'); + var tHead = rootDocument.createElement('thead'); + var tBody = rootDocument.createElement('tbody'); + var colGroup = rootDocument.createElement('colgroup'); + var tr = rootDocument.createElement('tr'); + var th = rootDocument.createElement('th'); + + if (this.isVertical()) { + table.appendChild(colGroup); + } + + if (this.isHorizontal()) { + tr.appendChild(th); + tHead.appendChild(tr); + table.style.tableLayout = 'auto'; + table.style.width = 'auto'; + } + + table.appendChild(tHead); + + if (this.isVertical()) { + tBody.appendChild(tr); + } + + table.appendChild(tBody); + addClass(table, className); + fragment.appendChild(table); + return { + fragment: fragment, + table: table, + tHead: tHead, + tBody: tBody, + colGroup: colGroup, + tr: tr, + th: th + }; + } + /** + * Create container for tables. + * + * @param {string} className The CSS classes to add. + * @returns {object} + */ + + }, { + key: "createContainer", + value: function createContainer() { + var className = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + var rootDocument = this.hot.rootDocument; + var fragment = rootDocument.createDocumentFragment(); + var container = rootDocument.createElement('div'); + var containerClassName = "htGhostTable htAutoSize ".concat(className.trim()); + addClass(container, containerClassName); + fragment.appendChild(container); + return { + fragment: fragment, + container: container + }; + } + /** + * Checks if table is raised vertically (checking rows). + * + * @returns {boolean} + */ + + }, { + key: "isVertical", + value: function isVertical() { + return !!(this.rows.length && !this.columns.length); + } + /** + * Checks if table is raised horizontally (checking columns). + * + * @returns {boolean} + */ + + }, { + key: "isHorizontal", + value: function isHorizontal() { + return !!(this.columns.length && !this.rows.length); + } + }]); + + return GhostTable; +}(); + +/** + * Get normalized Date object for the ISO formatted date strings. + * Natively, the date object parsed from a ISO 8601 string will be offsetted by the timezone difference, which may result in returning a wrong date. + * See: Github issue #3338. + * + * @param {string} dateString String representing the date. + * @returns {Date} The proper Date object. + */ +function getNormalizedDate(dateString) { + var nativeDate = new Date(dateString); // NaN if dateString is not in ISO format + + if (!isNaN(new Date("".concat(dateString, "T00:00")).getDate())) { + // Compensate timezone offset + return new Date(nativeDate.getTime() + nativeDate.getTimezoneOffset() * 60000); + } + + return nativeDate; +} + +var dateHelpers = /*#__PURE__*/Object.freeze({ + __proto__: null, + getNormalizedDate: getNormalizedDate +}); + +function _typeof$B(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$B = function _typeof(obj) { return typeof obj; }; } else { _typeof$B = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$B(obj); } + +function _classCallCheck$17(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$12(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); } } + +function _createClass$12(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$12(Constructor.prototype, protoProps); if (staticProps) _defineProperties$12(Constructor, staticProps); return Constructor; } + +function _get$5(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$5 = Reflect.get; } else { _get$5 = function _get(target, property, receiver) { var base = _superPropBase$5(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$5(target, property, receiver || target); } + +function _superPropBase$5(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$q(object); if (object === null) break; } return object; } + +function _inherits$q(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$r(subClass, superClass); } + +function _setPrototypeOf$r(o, p) { _setPrototypeOf$r = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$r(o, p); } + +function _createSuper$q(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$r(); return function _createSuperInternal() { var Super = _getPrototypeOf$q(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$q(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$q(this, result); }; } + +function _possibleConstructorReturn$q(self, call) { if (call && (_typeof$B(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$q(self); } + +function _assertThisInitialized$q(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$r() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$q(o) { _getPrototypeOf$q = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$q(o); } +var EDITOR_TYPE$2 = 'handsontable'; +/** + * @private + * @class HandsontableEditor + */ + +var HandsontableEditor = /*#__PURE__*/function (_TextEditor) { + _inherits$q(HandsontableEditor, _TextEditor); + + var _super = _createSuper$q(HandsontableEditor); + + function HandsontableEditor() { + _classCallCheck$17(this, HandsontableEditor); + + return _super.apply(this, arguments); + } + + _createClass$12(HandsontableEditor, [{ + key: "open", + value: + /** + * Opens the editor and adjust its size. + */ + function open() { + // this.addHook('beforeKeyDown', event => this.onBeforeKeyDown(event)); + _get$5(_getPrototypeOf$q(HandsontableEditor.prototype), "open", this).call(this); + + if (this.htEditor) { + this.htEditor.destroy(); + } + + if (this.htContainer.style.display === 'none') { + this.htContainer.style.display = ''; + } // Construct and initialise a new Handsontable + + + this.htEditor = new this.hot.constructor(this.htContainer, this.htOptions); + this.htEditor.init(); + this.htEditor.rootElement.style.display = ''; + + if (this.cellProperties.strict) { + this.htEditor.selectCell(0, 0); + } else { + this.htEditor.deselectCell(); + } + + setCaretPosition(this.TEXTAREA, 0, this.TEXTAREA.value.length); + } + /** + * Closes the editor. + */ + + }, { + key: "close", + value: function close() { + if (this.htEditor) { + this.htEditor.rootElement.style.display = 'none'; + } + + this.removeHooksByKey('beforeKeyDown'); + + _get$5(_getPrototypeOf$q(HandsontableEditor.prototype), "close", this).call(this); + } + /** + * Prepares editor's meta data and configuration of the internal Handsontable's instance. + * + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {HTMLTableCellElement} td The rendered cell element. + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + + }, { + key: "prepare", + value: function prepare(row, col, prop, td, value, cellProperties) { + _get$5(_getPrototypeOf$q(HandsontableEditor.prototype), "prepare", this).call(this, row, col, prop, td, value, cellProperties); + + var parent = this; + var options = { + startRows: 0, + startCols: 0, + minRows: 0, + minCols: 0, + className: 'listbox', + copyPaste: false, + autoColumnSize: false, + autoRowSize: false, + readOnly: true, + fillHandle: false, + autoWrapCol: false, + autoWrapRow: false, + afterOnCellMouseDown: function afterOnCellMouseDown(_, coords) { + var sourceValue = this.getSourceData(coords.row, coords.col); // if the value is undefined then it means we don't want to set the value + + if (sourceValue !== void 0) { + parent.setValue(sourceValue); + } + + parent.instance.destroyEditor(); + }, + preventWheel: true + }; + + if (this.cellProperties.handsontable) { + extend(options, cellProperties.handsontable); + } + + this.htOptions = options; + } + /** + * Begins editing on a highlighted cell and hides fillHandle corner if was present. + * + * @param {*} newInitialValue The editor initial value. + * @param {*} event The keyboard event object. + */ + + }, { + key: "beginEditing", + value: function beginEditing(newInitialValue, event) { + var onBeginEditing = this.hot.getSettings().onBeginEditing; + + if (onBeginEditing && onBeginEditing() === false) { + return; + } + + _get$5(_getPrototypeOf$q(HandsontableEditor.prototype), "beginEditing", this).call(this, newInitialValue, event); + } + /** + * Creates an editor's elements and adds necessary CSS classnames. + */ + + }, { + key: "createElements", + value: function createElements() { + _get$5(_getPrototypeOf$q(HandsontableEditor.prototype), "createElements", this).call(this); + + var DIV = this.hot.rootDocument.createElement('DIV'); + DIV.className = 'handsontableEditor'; + this.TEXTAREA_PARENT.appendChild(DIV); + this.htContainer = DIV; + this.assignHooks(); + } + /** + * Finishes editing and start saving or restoring process for editing cell or last selected range. + * + * @param {boolean} restoreOriginalValue If true, then closes editor without saving value from the editor into a cell. + * @param {boolean} ctrlDown If true, then saveValue will save editor's value to each cell in the last selected range. + * @param {Function} callback The callback function, fired after editor closing. + */ + + }, { + key: "finishEditing", + value: function finishEditing(restoreOriginalValue, ctrlDown, callback) { + if (this.htEditor && this.htEditor.isListening()) { + // if focus is still in the HOT editor + this.hot.listen(); // return the focus to the parent HOT instance + } + + if (this.htEditor && this.htEditor.getSelectedLast()) { + var value = this.htEditor.getInstance().getValue(); + + if (value !== void 0) { + // if the value is undefined then it means we don't want to set the value + this.setValue(value); + } + } + + _get$5(_getPrototypeOf$q(HandsontableEditor.prototype), "finishEditing", this).call(this, restoreOriginalValue, ctrlDown, callback); + } + /** + * Assings afterDestroy callback to prevent memory leaks. + * + * @private + */ + + }, { + key: "assignHooks", + value: function assignHooks() { + var _this = this; + + this.hot.addHook('afterDestroy', function () { + if (_this.htEditor) { + _this.htEditor.destroy(); + } + }); + } + /** + * OnBeforeKeyDown callback. + * + * @private + * @param {Event} event The keyboard event object. + */ + + }, { + key: "onBeforeKeyDown", + value: function onBeforeKeyDown(event) { + if (isImmediatePropagationStopped(event)) { + return; + } + + var innerHOT = this.htEditor.getInstance(); + var rowToSelect; + var selectedRow; + + if (event.keyCode === KEY_CODES.ARROW_DOWN) { + if (!innerHOT.getSelectedLast() && !innerHOT.flipped) { + rowToSelect = 0; + } else if (innerHOT.getSelectedLast()) { + if (innerHOT.flipped) { + rowToSelect = innerHOT.getSelectedLast()[0] + 1; + } else if (!innerHOT.flipped) { + var lastRow = innerHOT.countRows() - 1; + selectedRow = innerHOT.getSelectedLast()[0]; + rowToSelect = Math.min(lastRow, selectedRow + 1); + } + } + } else if (event.keyCode === KEY_CODES.ARROW_UP) { + if (!innerHOT.getSelectedLast() && innerHOT.flipped) { + rowToSelect = innerHOT.countRows() - 1; + } else if (innerHOT.getSelectedLast()) { + if (innerHOT.flipped) { + selectedRow = innerHOT.getSelectedLast()[0]; + rowToSelect = Math.max(0, selectedRow - 1); + } else { + selectedRow = innerHOT.getSelectedLast()[0]; + rowToSelect = selectedRow - 1; + } + } + } + + if (rowToSelect !== void 0) { + if (rowToSelect < 0 || innerHOT.flipped && rowToSelect > innerHOT.countRows() - 1) { + innerHOT.deselectCell(); + } else { + innerHOT.selectCell(rowToSelect, 0); + } + + if (innerHOT.getData().length) { + event.preventDefault(); + stopImmediatePropagation(event); + this.hot.listen(); + this.TEXTAREA.focus(); + } + } + + _get$5(_getPrototypeOf$q(HandsontableEditor.prototype), "onBeforeKeyDown", this).call(this, event); + } + }], [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE$2; + } + }]); + + return HandsontableEditor; +}(TextEditor); + +function _typeof$C(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$C = function _typeof(obj) { return typeof obj; }; } else { _typeof$C = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$C(obj); } + +function _classCallCheck$18(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$13(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); } } + +function _createClass$13(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$13(Constructor.prototype, protoProps); if (staticProps) _defineProperties$13(Constructor, staticProps); return Constructor; } + +function _get$6(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$6 = Reflect.get; } else { _get$6 = function _get(target, property, receiver) { var base = _superPropBase$6(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$6(target, property, receiver || target); } + +function _superPropBase$6(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$r(object); if (object === null) break; } return object; } + +function _inherits$r(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$s(subClass, superClass); } + +function _setPrototypeOf$s(o, p) { _setPrototypeOf$s = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$s(o, p); } + +function _createSuper$r(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$s(); return function _createSuperInternal() { var Super = _getPrototypeOf$r(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$r(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$r(this, result); }; } + +function _possibleConstructorReturn$r(self, call) { if (call && (_typeof$C(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$r(self); } + +function _assertThisInitialized$r(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$s() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$r(o) { _getPrototypeOf$r = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$r(o); } +var privatePool$4 = new WeakMap(); +var EDITOR_TYPE$3 = 'autocomplete'; +/** + * @private + * @class AutocompleteEditor + */ + +var AutocompleteEditor = /*#__PURE__*/function (_HandsontableEditor) { + _inherits$r(AutocompleteEditor, _HandsontableEditor); + + var _super = _createSuper$r(AutocompleteEditor); + + function AutocompleteEditor(instance) { + var _this; + + _classCallCheck$18(this, AutocompleteEditor); + + _this = _super.call(this, instance); + /** + * Query string to turn available values over. + * + * @type {string} + */ + + _this.query = null; + /** + * Contains stripped choices. + * + * @type {string[]} + */ + + _this.strippedChoices = []; + /** + * Contains raw choices. + * + * @type {Array} + */ + + _this.rawChoices = []; + privatePool$4.set(_assertThisInitialized$r(_this), { + skipOne: false, + isMacOS: _this.hot.rootWindow.navigator.platform.indexOf('Mac') > -1 + }); + return _this; + } + /** + * Gets current value from editable element. + * + * @returns {string} + */ + + + _createClass$13(AutocompleteEditor, [{ + key: "getValue", + value: function getValue() { + var _this2 = this; + + var selectedValue = this.rawChoices.find(function (value) { + var strippedValue = _this2.stripValueIfNeeded(value); + + return strippedValue === _this2.TEXTAREA.value; + }); + + if (isDefined(selectedValue)) { + return selectedValue; + } + + return this.TEXTAREA.value; + } + /** + * Creates an editor's elements and adds necessary CSS classnames. + */ + + }, { + key: "createElements", + value: function createElements() { + _get$6(_getPrototypeOf$r(AutocompleteEditor.prototype), "createElements", this).call(this); + + addClass(this.htContainer, 'autocompleteEditor'); + addClass(this.htContainer, this.hot.rootWindow.navigator.platform.indexOf('Mac') === -1 ? '' : 'htMacScroll'); + } + /** + * Opens the editor and adjust its size and internal Handsontable's instance. + */ + + }, { + key: "open", + value: function open() { + var _this3 = this; + + var priv = privatePool$4.get(this); // this.addHook('beforeKeyDown', event => this.onBeforeKeyDown(event)); + // Ugly fix for handsontable which grab window object for autocomplete scroll listener instead table element. + + this.TEXTAREA_PARENT.style.overflow = 'auto'; + + _get$6(_getPrototypeOf$r(AutocompleteEditor.prototype), "open", this).call(this); + + this.TEXTAREA_PARENT.style.overflow = ''; + var choicesListHot = this.htEditor.getInstance(); + var trimDropdown = this.cellProperties.trimDropdown === void 0 ? true : this.cellProperties.trimDropdown; + this.showEditableElement(); + this.focus(); + var scrollbarWidth = getScrollbarWidth(); + + if (scrollbarWidth === 0 && priv.isMacOS) { + scrollbarWidth += 15; // default scroll bar width if scroll bars are visible only when scrolling + } + + choicesListHot.updateSettings({ + colWidths: trimDropdown ? [outerWidth(this.TEXTAREA) - 2] : void 0, + width: trimDropdown ? outerWidth(this.TEXTAREA) + scrollbarWidth : void 0, + renderer: function renderer(instance, TD, row, col, prop, value, cellProperties) { + textRenderer(instance, TD, row, col, prop, value, cellProperties); + var _this3$cellProperties = _this3.cellProperties, + filteringCaseSensitive = _this3$cellProperties.filteringCaseSensitive, + allowHtml = _this3$cellProperties.allowHtml; + var query = _this3.query; + var cellValue = stringify(value); + var indexOfMatch; + var match; + + if (cellValue && !allowHtml) { + indexOfMatch = filteringCaseSensitive === true ? cellValue.indexOf(query) : cellValue.toLowerCase().indexOf(query.toLowerCase()); + + if (indexOfMatch !== -1) { + match = cellValue.substr(indexOfMatch, query.length); + cellValue = cellValue.replace(match, "".concat(match, "")); + } + } + + TD.innerHTML = cellValue; + }, + autoColumnSize: true + }); + + if (priv.skipOne) { + priv.skipOne = false; + } + + this.hot._registerTimeout(function () { + _this3.queryChoices(_this3.TEXTAREA.value); + }); + } + /** + * Closes the editor. + */ + + }, { + key: "close", + value: function close() { + this.removeHooksByKey('beforeKeyDown'); + + _get$6(_getPrototypeOf$r(AutocompleteEditor.prototype), "close", this).call(this); + } + /** + * Verifies result of validation or closes editor if user's cancelled changes. + * + * @param {boolean|undefined} result If `false` and the cell using allowInvalid option, + * then an editor won't be closed until validation is passed. + */ + + }, { + key: "discardEditor", + value: function discardEditor(result) { + _get$6(_getPrototypeOf$r(AutocompleteEditor.prototype), "discardEditor", this).call(this, result); + + this.hot.view.render(); + } + /** + * Prepares choices list based on applied argument. + * + * @private + * @param {string} query The query. + */ + + }, { + key: "queryChoices", + value: function queryChoices(query) { + var _this4 = this; + + var source = this.cellProperties.source; + this.query = query; + + if (typeof source === 'function') { + source.call(this.cellProperties, query, function (choices) { + _this4.rawChoices = choices; + + _this4.updateChoicesList(_this4.stripValuesIfNeeded(choices)); + }); + } else if (Array.isArray(source)) { + this.rawChoices = source; + this.updateChoicesList(this.stripValuesIfNeeded(source)); + } else { + this.updateChoicesList([]); + } + } + /** + * Updates list of the possible completions to choose. + * + * @private + * @param {Array} choicesList The choices list to process. + */ + + }, { + key: "updateChoicesList", + value: function updateChoicesList(choicesList) { + var pos = getCaretPosition(this.TEXTAREA); + var endPos = getSelectionEndPosition(this.TEXTAREA); + var sortByRelevanceSetting = this.cellProperties.sortByRelevance; + var filterSetting = this.cellProperties.filter; + var orderByRelevance = null; + var highlightIndex = null; + var choices = choicesList; + + if (sortByRelevanceSetting) { + orderByRelevance = AutocompleteEditor.sortByRelevance(this.stripValueIfNeeded(this.getValue()), choices, this.cellProperties.filteringCaseSensitive); + } + + var orderByRelevanceLength = Array.isArray(orderByRelevance) ? orderByRelevance.length : 0; + + if (filterSetting === false) { + if (orderByRelevanceLength) { + highlightIndex = orderByRelevance[0]; + } + } else { + var sorted = []; + + for (var i = 0, choicesCount = choices.length; i < choicesCount; i++) { + if (sortByRelevanceSetting && orderByRelevanceLength <= i) { + break; + } + + if (orderByRelevanceLength) { + sorted.push(choices[orderByRelevance[i]]); + } else { + sorted.push(choices[i]); + } + } + + highlightIndex = 0; + choices = sorted; + } + + this.strippedChoices = choices; + this.htEditor.loadData(pivot([choices])); + this.updateDropdownHeight(); + this.flipDropdownIfNeeded(); + + if (this.cellProperties.strict === true) { + this.highlightBestMatchingChoice(highlightIndex); + } + + this.hot.listen(); + setCaretPosition(this.TEXTAREA, pos, pos === endPos ? void 0 : endPos); + } + /** + * Checks where is enough place to open editor. + * + * @private + * @returns {boolean} + */ + + }, { + key: "flipDropdownIfNeeded", + value: function flipDropdownIfNeeded() { + var textareaOffset = offset(this.TEXTAREA); + var textareaHeight = outerHeight(this.TEXTAREA); + var dropdownHeight = this.getDropdownHeight(); + var trimmingContainer = getTrimmingContainer(this.hot.view.wt.wtTable.TABLE); + var trimmingContainerScrollTop = trimmingContainer.scrollTop; + var headersHeight = outerHeight(this.hot.view.wt.wtTable.THEAD); + var containerOffset = { + row: 0, + col: 0 + }; + + if (trimmingContainer !== this.hot.rootWindow) { + containerOffset = offset(trimmingContainer); + } + + var spaceAbove = textareaOffset.top - containerOffset.top - headersHeight + trimmingContainerScrollTop; + var spaceBelow = trimmingContainer.scrollHeight - spaceAbove - headersHeight - textareaHeight; + var flipNeeded = dropdownHeight > spaceBelow && spaceAbove > spaceBelow; + + if (flipNeeded) { + this.flipDropdown(dropdownHeight); + } else { + this.unflipDropdown(); + } + + this.limitDropdownIfNeeded(flipNeeded ? spaceAbove : spaceBelow, dropdownHeight); + return flipNeeded; + } + /** + * Checks if the internal table should generate scrollbar or could be rendered without it. + * + * @private + * @param {number} spaceAvailable The free space as height definded in px available for dropdown list. + * @param {number} dropdownHeight The dropdown height. + */ + + }, { + key: "limitDropdownIfNeeded", + value: function limitDropdownIfNeeded(spaceAvailable, dropdownHeight) { + if (dropdownHeight > spaceAvailable) { + var tempHeight = 0; + var i = 0; + var lastRowHeight = 0; + var height = null; + + do { + lastRowHeight = this.htEditor.getRowHeight(i) || this.htEditor.view.wt.wtSettings.settings.defaultRowHeight; + tempHeight += lastRowHeight; + i += 1; + } while (tempHeight < spaceAvailable); + + height = tempHeight - lastRowHeight; + + if (this.htEditor.flipped) { + this.htEditor.rootElement.style.top = "".concat(parseInt(this.htEditor.rootElement.style.top, 10) + dropdownHeight - height, "px"); // eslint-disable-line max-len + } + + this.setDropdownHeight(tempHeight - lastRowHeight); + } + } + /** + * Configures editor to open it at the top. + * + * @private + * @param {number} dropdownHeight The dropdown height. + */ + + }, { + key: "flipDropdown", + value: function flipDropdown(dropdownHeight) { + var dropdownStyle = this.htEditor.rootElement.style; + dropdownStyle.position = 'absolute'; + dropdownStyle.top = "".concat(-dropdownHeight, "px"); + this.htEditor.flipped = true; + } + /** + * Configures editor to open it at the bottom. + * + * @private + */ + + }, { + key: "unflipDropdown", + value: function unflipDropdown() { + var dropdownStyle = this.htEditor.rootElement.style; + + if (dropdownStyle.position === 'absolute') { + dropdownStyle.position = ''; + dropdownStyle.top = ''; + } + + this.htEditor.flipped = void 0; + } + /** + * Updates width and height of the internal Handsontable's instance. + * + * @private + */ + + }, { + key: "updateDropdownHeight", + value: function updateDropdownHeight() { + var currentDropdownWidth = this.htEditor.getColWidth(0) + getScrollbarWidth(this.hot.rootDocument) + 2; + var trimDropdown = this.cellProperties.trimDropdown; + this.htEditor.updateSettings({ + height: this.getDropdownHeight(), + width: trimDropdown ? void 0 : currentDropdownWidth + }); + this.htEditor.view.wt.wtTable.alignOverlaysWithTrimmingContainer(); + } + /** + * Sets new height of the internal Handsontable's instance. + * + * @private + * @param {number} height The new dropdown height. + */ + + }, { + key: "setDropdownHeight", + value: function setDropdownHeight(height) { + this.htEditor.updateSettings({ + height: height + }); + } + /** + * Creates new selection on specified row index, or deselects selected cells. + * + * @private + * @param {number|undefined} index The visual row index. + */ + + }, { + key: "highlightBestMatchingChoice", + value: function highlightBestMatchingChoice(index) { + if (typeof index === 'number') { + this.htEditor.selectCell(index, 0, void 0, void 0, void 0, false); + } else { + this.htEditor.deselectCell(); + } + } + /** + * Calculates and return the internal Handsontable's height. + * + * @private + * @returns {number} + */ + + }, { + key: "getDropdownHeight", + value: function getDropdownHeight() { + var firstRowHeight = this.htEditor.getInstance().getRowHeight(0) || 23; + var visibleRows = this.cellProperties.visibleRows; + return this.strippedChoices.length >= visibleRows ? visibleRows * firstRowHeight : this.strippedChoices.length * firstRowHeight + 8; // eslint-disable-line max-len + } + /** + * Sanitizes value from potential dangerous tags. + * + * @private + * @param {string} value The value to sanitize. + * @returns {string} + */ + + }, { + key: "stripValueIfNeeded", + value: function stripValueIfNeeded(value) { + return this.stripValuesIfNeeded([value])[0]; + } + /** + * Sanitizes an array of the values from potential dangerous tags. + * + * @private + * @param {string[]} values The value to sanitize. + * @returns {string[]} + */ + + }, { + key: "stripValuesIfNeeded", + value: function stripValuesIfNeeded(values) { + var allowHtml = this.cellProperties.allowHtml; + var stringifiedValues = arrayMap(values, function (value) { + return stringify(value); + }); + var strippedValues = arrayMap(stringifiedValues, function (value) { + return allowHtml ? value : stripTags(value); + }); + return strippedValues; + } + /** + * Captures use of arrow down and up to control their behaviour. + * + * @private + * @param {number} keyCode The keyboard keycode. + * @returns {boolean} + */ + + }, { + key: "allowKeyEventPropagation", + value: function allowKeyEventPropagation(keyCode) { + var selectedRange = this.htEditor.getSelectedRangeLast(); + var selected = { + row: selectedRange ? selectedRange.from.row : -1 + }; + var allowed = false; + + if (keyCode === KEY_CODES.ARROW_DOWN && selected.row > 0 && selected.row < this.htEditor.countRows() - 1) { + allowed = true; + } + + if (keyCode === KEY_CODES.ARROW_UP && selected.row > -1) { + allowed = true; + } + + return allowed; + } + /** + * OnBeforeKeyDown callback. + * + * @private + * @param {KeyboardEvent} event The keyboard event object. + */ + + }, { + key: "onBeforeKeyDown", + value: function onBeforeKeyDown(event) { + var _this5 = this; + + var priv = privatePool$4.get(this); + priv.skipOne = false; + + if (isPrintableChar(event.keyCode) || event.keyCode === KEY_CODES.BACKSPACE || event.keyCode === KEY_CODES.DELETE || event.keyCode === KEY_CODES.INSERT) { + var timeOffset = 0; // on ctl+c / cmd+c don't update suggestion list + + if (event.keyCode === KEY_CODES.C && (event.ctrlKey || event.metaKey)) { + return; + } + + if (!this.isOpened()) { + timeOffset += 10; + } + + if (this.htEditor) { + this.hot._registerTimeout(function () { + _this5.queryChoices(_this5.TEXTAREA.value); + + priv.skipOne = true; + }, timeOffset); + } + } + + _get$6(_getPrototypeOf$r(AutocompleteEditor.prototype), "onBeforeKeyDown", this).call(this, event); + } + }], [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE$3; + } + }]); + + return AutocompleteEditor; +}(HandsontableEditor); +/** + * Filters and sorts by relevance. + * + * @param {*} value The selected value. + * @param {string[]} choices The list of available choices. + * @param {boolean} caseSensitive Indicates if it's sorted by case. + * @returns {number[]} Array of indexes in original choices array. + */ + +AutocompleteEditor.sortByRelevance = function (value, choices, caseSensitive) { + var choicesRelevance = []; + var result = []; + var valueLength = value.length; + var choicesCount = choices.length; + var charsLeft; + var currentItem; + var i; + var valueIndex; + + if (valueLength === 0) { + for (i = 0; i < choicesCount; i++) { + result.push(i); + } + + return result; + } + + for (i = 0; i < choicesCount; i++) { + currentItem = stripTags(stringify(choices[i])); + + if (caseSensitive) { + valueIndex = currentItem.indexOf(value); + } else { + valueIndex = currentItem.toLowerCase().indexOf(value.toLowerCase()); + } + + if (valueIndex !== -1) { + charsLeft = currentItem.length - valueIndex - valueLength; + choicesRelevance.push({ + baseIndex: i, + index: valueIndex, + charsLeft: charsLeft, + value: currentItem + }); + } + } + + choicesRelevance.sort(function (a, b) { + if (b.index === -1) { + return -1; + } + + if (a.index === -1) { + return 1; + } + + if (a.index < b.index) { + return -1; + } else if (b.index < a.index) { + return 1; + } else if (a.index === b.index) { + if (a.charsLeft < b.charsLeft) { + return -1; + } else if (a.charsLeft > b.charsLeft) { + return 1; + } + } + + return 0; + }); + + for (i = 0, choicesCount = choicesRelevance.length; i < choicesCount; i++) { + result.push(choicesRelevance[i].baseIndex); + } + + return result; +}; + +function _typeof$D(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$D = function _typeof(obj) { return typeof obj; }; } else { _typeof$D = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$D(obj); } + +function _classCallCheck$19(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$14(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); } } + +function _createClass$14(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$14(Constructor.prototype, protoProps); if (staticProps) _defineProperties$14(Constructor, staticProps); return Constructor; } + +function _inherits$s(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$t(subClass, superClass); } + +function _setPrototypeOf$t(o, p) { _setPrototypeOf$t = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$t(o, p); } + +function _createSuper$s(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$t(); return function _createSuperInternal() { var Super = _getPrototypeOf$s(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$s(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$s(this, result); }; } + +function _possibleConstructorReturn$s(self, call) { if (call && (_typeof$D(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$s(self); } + +function _assertThisInitialized$s(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$t() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$s(o) { _getPrototypeOf$s = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$s(o); } +var EDITOR_TYPE$4 = 'checkbox'; +/** + * @private + * @class CheckboxEditor + */ + +var CheckboxEditor = /*#__PURE__*/function (_BaseEditor) { + _inherits$s(CheckboxEditor, _BaseEditor); + + var _super = _createSuper$s(CheckboxEditor); + + function CheckboxEditor() { + _classCallCheck$19(this, CheckboxEditor); + + return _super.apply(this, arguments); + } + + _createClass$14(CheckboxEditor, [{ + key: "beginEditing", + value: function beginEditing(initialValue, event) { + // Just some events connected with checkbox editor are delegated here. Some `keydown` events like `enter` and `space` key press + // are handled inside `checkboxRenderer`. Some events come here from `editorManager`. Below `if` statement was created by author + // for purpose of handling only `doubleclick` event which may be done on a cell with checkbox. + if (event && event.type === 'mouseup') { + var checkbox = this.TD.querySelector('input[type="checkbox"]'); + + if (!hasClass(checkbox, 'htBadValue')) { + checkbox.click(); + } + } + } + }, { + key: "finishEditing", + value: function finishEditing() {} + }, { + key: "init", + value: function init() {} + }, { + key: "open", + value: function open() {} + }, { + key: "close", + value: function close() {} + }, { + key: "getValue", + value: function getValue() {} + }, { + key: "setValue", + value: function setValue() {} + }, { + key: "focus", + value: function focus() {} + }], [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE$4; + } + }]); + + return CheckboxEditor; +}(BaseEditor); + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +_export({ target: 'Object', stat: true }, { + setPrototypeOf: objectSetPrototypeOf +}); + +var pikaday = createCommonjsModule(function (module, exports) { +/*! + * Pikaday + * + * Copyright © 2014 David Bushell | BSD & MIT license | https://github.com/Pikaday/Pikaday + */ + +(function (root, factory) +{ + + var moment$1; + { + // CommonJS module + // Load moment.js as an optional dependency + try { moment$1 = moment; } catch (e) {} + module.exports = factory(moment$1); + } +}(commonjsGlobal, function (moment) +{ + + /** + * feature detection and helper functions + */ + var hasMoment = typeof moment === 'function', + + hasEventListeners = !!window.addEventListener, + + document = window.document, + + sto = window.setTimeout, + + addEvent = function(el, e, callback, capture) + { + if (hasEventListeners) { + el.addEventListener(e, callback, !!capture); + } else { + el.attachEvent('on' + e, callback); + } + }, + + removeEvent = function(el, e, callback, capture) + { + if (hasEventListeners) { + el.removeEventListener(e, callback, !!capture); + } else { + el.detachEvent('on' + e, callback); + } + }, + + trim = function(str) + { + return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g,''); + }, + + hasClass = function(el, cn) + { + return (' ' + el.className + ' ').indexOf(' ' + cn + ' ') !== -1; + }, + + addClass = function(el, cn) + { + if (!hasClass(el, cn)) { + el.className = (el.className === '') ? cn : el.className + ' ' + cn; + } + }, + + removeClass = function(el, cn) + { + el.className = trim((' ' + el.className + ' ').replace(' ' + cn + ' ', ' ')); + }, + + isArray = function(obj) + { + return (/Array/).test(Object.prototype.toString.call(obj)); + }, + + isDate = function(obj) + { + return (/Date/).test(Object.prototype.toString.call(obj)) && !isNaN(obj.getTime()); + }, + + isWeekend = function(date) + { + var day = date.getDay(); + return day === 0 || day === 6; + }, + + isLeapYear = function(year) + { + // solution by Matti Virkkunen: http://stackoverflow.com/a/4881951 + return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0; + }, + + getDaysInMonth = function(year, month) + { + return [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month]; + }, + + setToStartOfDay = function(date) + { + if (isDate(date)) date.setHours(0,0,0,0); + }, + + compareDates = function(a,b) + { + // weak date comparison (use setToStartOfDay(date) to ensure correct result) + return a.getTime() === b.getTime(); + }, + + extend = function(to, from, overwrite) + { + var prop, hasProp; + for (prop in from) { + hasProp = to[prop] !== undefined; + if (hasProp && typeof from[prop] === 'object' && from[prop] !== null && from[prop].nodeName === undefined) { + if (isDate(from[prop])) { + if (overwrite) { + to[prop] = new Date(from[prop].getTime()); + } + } + else if (isArray(from[prop])) { + if (overwrite) { + to[prop] = from[prop].slice(0); + } + } else { + to[prop] = extend({}, from[prop], overwrite); + } + } else if (overwrite || !hasProp) { + to[prop] = from[prop]; + } + } + return to; + }, + + fireEvent = function(el, eventName, data) + { + var ev; + + if (document.createEvent) { + ev = document.createEvent('HTMLEvents'); + ev.initEvent(eventName, true, false); + ev = extend(ev, data); + el.dispatchEvent(ev); + } else if (document.createEventObject) { + ev = document.createEventObject(); + ev = extend(ev, data); + el.fireEvent('on' + eventName, ev); + } + }, + + adjustCalendar = function(calendar) { + if (calendar.month < 0) { + calendar.year -= Math.ceil(Math.abs(calendar.month)/12); + calendar.month += 12; + } + if (calendar.month > 11) { + calendar.year += Math.floor(Math.abs(calendar.month)/12); + calendar.month -= 12; + } + return calendar; + }, + + /** + * defaults and localisation + */ + defaults = { + + // bind the picker to a form field + field: null, + + // automatically show/hide the picker on `field` focus (default `true` if `field` is set) + bound: undefined, + + // data-attribute on the input field with an aria assistance tekst (only applied when `bound` is set) + ariaLabel: 'Use the arrow keys to pick a date', + + // position of the datepicker, relative to the field (default to bottom & left) + // ('bottom' & 'left' keywords are not used, 'top' & 'right' are modifier on the bottom/left position) + position: 'bottom left', + + // automatically fit in the viewport even if it means repositioning from the position option + reposition: true, + + // the default output format for `.toString()` and `field` value + format: 'YYYY-MM-DD', + + // the toString function which gets passed a current date object and format + // and returns a string + toString: null, + + // used to create date object from current input string + parse: null, + + // the initial date to view when first opened + defaultDate: null, + + // make the `defaultDate` the initial selected value + setDefaultDate: false, + + // first day of week (0: Sunday, 1: Monday etc) + firstDay: 0, + + // the default flag for moment's strict date parsing + formatStrict: false, + + // the minimum/earliest date that can be selected + minDate: null, + // the maximum/latest date that can be selected + maxDate: null, + + // number of years either side, or array of upper/lower range + yearRange: 10, + + // show week numbers at head of row + showWeekNumber: false, + + // Week picker mode + pickWholeWeek: false, + + // used internally (don't config outside) + minYear: 0, + maxYear: 9999, + minMonth: undefined, + maxMonth: undefined, + + startRange: null, + endRange: null, + + isRTL: false, + + // Additional text to append to the year in the calendar title + yearSuffix: '', + + // Render the month after year in the calendar title + showMonthAfterYear: false, + + // Render days of the calendar grid that fall in the next or previous month + showDaysInNextAndPreviousMonths: false, + + // Allows user to select days that fall in the next or previous month + enableSelectionDaysInNextAndPreviousMonths: false, + + // how many months are visible + numberOfMonths: 1, + + // when numberOfMonths is used, this will help you to choose where the main calendar will be (default `left`, can be set to `right`) + // only used for the first display or when a selected date is not visible + mainCalendar: 'left', + + // Specify a DOM element to render the calendar in + container: undefined, + + // Blur field when date is selected + blurFieldOnSelect : true, + + // internationalization + i18n: { + previousMonth : 'Previous Month', + nextMonth : 'Next Month', + months : ['January','February','March','April','May','June','July','August','September','October','November','December'], + weekdays : ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'], + weekdaysShort : ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'] + }, + + // Theme Classname + theme: null, + + // events array + events: [], + + // callback function + onSelect: null, + onOpen: null, + onClose: null, + onDraw: null, + + // Enable keyboard input + keyboardInput: true + }, + + + /** + * templating functions to abstract HTML rendering + */ + renderDayName = function(opts, day, abbr) + { + day += opts.firstDay; + while (day >= 7) { + day -= 7; + } + return abbr ? opts.i18n.weekdaysShort[day] : opts.i18n.weekdays[day]; + }, + + renderDay = function(opts) + { + var arr = []; + var ariaSelected = 'false'; + if (opts.isEmpty) { + if (opts.showDaysInNextAndPreviousMonths) { + arr.push('is-outside-current-month'); + + if(!opts.enableSelectionDaysInNextAndPreviousMonths) { + arr.push('is-selection-disabled'); + } + + } else { + return ''; + } + } + if (opts.isDisabled) { + arr.push('is-disabled'); + } + if (opts.isToday) { + arr.push('is-today'); + } + if (opts.isSelected) { + arr.push('is-selected'); + ariaSelected = 'true'; + } + if (opts.hasEvent) { + arr.push('has-event'); + } + if (opts.isInRange) { + arr.push('is-inrange'); + } + if (opts.isStartRange) { + arr.push('is-startrange'); + } + if (opts.isEndRange) { + arr.push('is-endrange'); + } + return ''; + }, + + renderWeek = function (d, m, y) { + // Lifted from http://javascript.about.com/library/blweekyear.htm, lightly modified. + var onejan = new Date(y, 0, 1), + weekNum = Math.ceil((((new Date(y, m, d) - onejan) / 86400000) + onejan.getDay()+1)/7); + return ''; + }, + + renderRow = function(days, isRTL, pickWholeWeek, isRowSelected) + { + return '' + (isRTL ? days.reverse() : days).join('') + ''; + }, + + renderBody = function(rows) + { + return '' + rows.join('') + ''; + }, + + renderHead = function(opts) + { + var i, arr = []; + if (opts.showWeekNumber) { + arr.push(''); + } + for (i = 0; i < 7; i++) { + arr.push(''); + } + return '' + (opts.isRTL ? arr.reverse() : arr).join('') + ''; + }, + + renderTitle = function(instance, c, year, month, refYear, randId) + { + var i, j, arr, + opts = instance._o, + isMinYear = year === opts.minYear, + isMaxYear = year === opts.maxYear, + html = '
', + monthHtml, + yearHtml, + prev = true, + next = true; + + for (arr = [], i = 0; i < 12; i++) { + arr.push(''); + } + + monthHtml = '
' + opts.i18n.months[month] + '
'; + + if (isArray(opts.yearRange)) { + i = opts.yearRange[0]; + j = opts.yearRange[1] + 1; + } else { + i = year - opts.yearRange; + j = 1 + year + opts.yearRange; + } + + for (arr = []; i < j && i <= opts.maxYear; i++) { + if (i >= opts.minYear) { + arr.push(''); + } + } + yearHtml = '
' + year + opts.yearSuffix + '
'; + + if (opts.showMonthAfterYear) { + html += yearHtml + monthHtml; + } else { + html += monthHtml + yearHtml; + } + + if (isMinYear && (month === 0 || opts.minMonth >= month)) { + prev = false; + } + + if (isMaxYear && (month === 11 || opts.maxMonth <= month)) { + next = false; + } + + if (c === 0) { + html += ''; + } + if (c === (instance._o.numberOfMonths - 1) ) { + html += ''; + } + + return html += '
'; + }, + + renderTable = function(opts, data, randId) + { + return '
' + + '' + + '' + weekNum + '
' + renderDayName(opts, i, true) + '
' + renderHead(opts) + renderBody(data) + '
'; + }, + + + /** + * Pikaday constructor + */ + Pikaday = function(options) + { + var self = this, + opts = self.config(options); + + self._onMouseDown = function(e) + { + if (!self._v) { + return; + } + e = e || window.event; + var target = e.target || e.srcElement; + if (!target) { + return; + } + + if (!hasClass(target, 'is-disabled')) { + if (hasClass(target, 'pika-button') && !hasClass(target, 'is-empty') && !hasClass(target.parentNode, 'is-disabled')) { + self.setDate(new Date(target.getAttribute('data-pika-year'), target.getAttribute('data-pika-month'), target.getAttribute('data-pika-day'))); + if (opts.bound) { + sto(function() { + self.hide(); + if (opts.blurFieldOnSelect && opts.field) { + opts.field.blur(); + } + }, 100); + } + } + else if (hasClass(target, 'pika-prev')) { + self.prevMonth(); + } + else if (hasClass(target, 'pika-next')) { + self.nextMonth(); + } + } + if (!hasClass(target, 'pika-select')) { + // if this is touch event prevent mouse events emulation + if (e.preventDefault) { + e.preventDefault(); + } else { + e.returnValue = false; + return false; + } + } else { + self._c = true; + } + }; + + self._onChange = function(e) + { + e = e || window.event; + var target = e.target || e.srcElement; + if (!target) { + return; + } + if (hasClass(target, 'pika-select-month')) { + self.gotoMonth(target.value); + } + else if (hasClass(target, 'pika-select-year')) { + self.gotoYear(target.value); + } + }; + + self._onKeyChange = function(e) + { + e = e || window.event; + + if (self.isVisible()) { + + switch(e.keyCode){ + case 13: + case 27: + if (opts.field) { + opts.field.blur(); + } + break; + case 37: + e.preventDefault(); + self.adjustDate('subtract', 1); + break; + case 38: + self.adjustDate('subtract', 7); + break; + case 39: + self.adjustDate('add', 1); + break; + case 40: + self.adjustDate('add', 7); + break; + } + } + }; + + self._onInputChange = function(e) + { + var date; + + if (e.firedBy === self) { + return; + } + if (opts.parse) { + date = opts.parse(opts.field.value, opts.format); + } else if (hasMoment) { + date = moment(opts.field.value, opts.format, opts.formatStrict); + date = (date && date.isValid()) ? date.toDate() : null; + } + else { + date = new Date(Date.parse(opts.field.value)); + } + if (isDate(date)) { + self.setDate(date); + } + if (!self._v) { + self.show(); + } + }; + + self._onInputFocus = function() + { + self.show(); + }; + + self._onInputClick = function() + { + self.show(); + }; + + self._onInputBlur = function() + { + // IE allows pika div to gain focus; catch blur the input field + var pEl = document.activeElement; + do { + if (hasClass(pEl, 'pika-single')) { + return; + } + } + while ((pEl = pEl.parentNode)); + + if (!self._c) { + self._b = sto(function() { + self.hide(); + }, 50); + } + self._c = false; + }; + + self._onClick = function(e) + { + e = e || window.event; + var target = e.target || e.srcElement, + pEl = target; + if (!target) { + return; + } + if (!hasEventListeners && hasClass(target, 'pika-select')) { + if (!target.onchange) { + target.setAttribute('onchange', 'return;'); + addEvent(target, 'change', self._onChange); + } + } + do { + if (hasClass(pEl, 'pika-single') || pEl === opts.trigger) { + return; + } + } + while ((pEl = pEl.parentNode)); + if (self._v && target !== opts.trigger && pEl !== opts.trigger) { + self.hide(); + } + }; + + self.el = document.createElement('div'); + self.el.className = 'pika-single' + (opts.isRTL ? ' is-rtl' : '') + (opts.theme ? ' ' + opts.theme : ''); + + addEvent(self.el, 'mousedown', self._onMouseDown, true); + addEvent(self.el, 'touchend', self._onMouseDown, true); + addEvent(self.el, 'change', self._onChange); + + if (opts.keyboardInput) { + addEvent(document, 'keydown', self._onKeyChange); + } + + if (opts.field) { + if (opts.container) { + opts.container.appendChild(self.el); + } else if (opts.bound) { + document.body.appendChild(self.el); + } else { + opts.field.parentNode.insertBefore(self.el, opts.field.nextSibling); + } + addEvent(opts.field, 'change', self._onInputChange); + + if (!opts.defaultDate) { + if (hasMoment && opts.field.value) { + opts.defaultDate = moment(opts.field.value, opts.format).toDate(); + } else { + opts.defaultDate = new Date(Date.parse(opts.field.value)); + } + opts.setDefaultDate = true; + } + } + + var defDate = opts.defaultDate; + + if (isDate(defDate)) { + if (opts.setDefaultDate) { + self.setDate(defDate, true); + } else { + self.gotoDate(defDate); + } + } else { + self.gotoDate(new Date()); + } + + if (opts.bound) { + this.hide(); + self.el.className += ' is-bound'; + addEvent(opts.trigger, 'click', self._onInputClick); + addEvent(opts.trigger, 'focus', self._onInputFocus); + addEvent(opts.trigger, 'blur', self._onInputBlur); + } else { + this.show(); + } + }; + + + /** + * public Pikaday API + */ + Pikaday.prototype = { + + + /** + * configure functionality + */ + config: function(options) + { + if (!this._o) { + this._o = extend({}, defaults, true); + } + + var opts = extend(this._o, options, true); + + opts.isRTL = !!opts.isRTL; + + opts.field = (opts.field && opts.field.nodeName) ? opts.field : null; + + opts.theme = (typeof opts.theme) === 'string' && opts.theme ? opts.theme : null; + + opts.bound = !!(opts.bound !== undefined ? opts.field && opts.bound : opts.field); + + opts.trigger = (opts.trigger && opts.trigger.nodeName) ? opts.trigger : opts.field; + + opts.disableWeekends = !!opts.disableWeekends; + + opts.disableDayFn = (typeof opts.disableDayFn) === 'function' ? opts.disableDayFn : null; + + var nom = parseInt(opts.numberOfMonths, 10) || 1; + opts.numberOfMonths = nom > 4 ? 4 : nom; + + if (!isDate(opts.minDate)) { + opts.minDate = false; + } + if (!isDate(opts.maxDate)) { + opts.maxDate = false; + } + if ((opts.minDate && opts.maxDate) && opts.maxDate < opts.minDate) { + opts.maxDate = opts.minDate = false; + } + if (opts.minDate) { + this.setMinDate(opts.minDate); + } + if (opts.maxDate) { + this.setMaxDate(opts.maxDate); + } + + if (isArray(opts.yearRange)) { + var fallback = new Date().getFullYear() - 10; + opts.yearRange[0] = parseInt(opts.yearRange[0], 10) || fallback; + opts.yearRange[1] = parseInt(opts.yearRange[1], 10) || fallback; + } else { + opts.yearRange = Math.abs(parseInt(opts.yearRange, 10)) || defaults.yearRange; + if (opts.yearRange > 100) { + opts.yearRange = 100; + } + } + + return opts; + }, + + /** + * return a formatted string of the current selection (using Moment.js if available) + */ + toString: function(format) + { + format = format || this._o.format; + if (!isDate(this._d)) { + return ''; + } + if (this._o.toString) { + return this._o.toString(this._d, format); + } + if (hasMoment) { + return moment(this._d).format(format); + } + return this._d.toDateString(); + }, + + /** + * return a Moment.js object of the current selection (if available) + */ + getMoment: function() + { + return hasMoment ? moment(this._d) : null; + }, + + /** + * set the current selection from a Moment.js object (if available) + */ + setMoment: function(date, preventOnSelect) + { + if (hasMoment && moment.isMoment(date)) { + this.setDate(date.toDate(), preventOnSelect); + } + }, + + /** + * return a Date object of the current selection + */ + getDate: function() + { + return isDate(this._d) ? new Date(this._d.getTime()) : null; + }, + + /** + * set the current selection + */ + setDate: function(date, preventOnSelect) + { + if (!date) { + this._d = null; + + if (this._o.field) { + this._o.field.value = ''; + fireEvent(this._o.field, 'change', { firedBy: this }); + } + + return this.draw(); + } + if (typeof date === 'string') { + date = new Date(Date.parse(date)); + } + if (!isDate(date)) { + return; + } + + var min = this._o.minDate, + max = this._o.maxDate; + + if (isDate(min) && date < min) { + date = min; + } else if (isDate(max) && date > max) { + date = max; + } + + this._d = new Date(date.getTime()); + setToStartOfDay(this._d); + this.gotoDate(this._d); + + if (this._o.field) { + this._o.field.value = this.toString(); + fireEvent(this._o.field, 'change', { firedBy: this }); + } + if (!preventOnSelect && typeof this._o.onSelect === 'function') { + this._o.onSelect.call(this, this.getDate()); + } + }, + + /** + * change view to a specific date + */ + gotoDate: function(date) + { + var newCalendar = true; + + if (!isDate(date)) { + return; + } + + if (this.calendars) { + var firstVisibleDate = new Date(this.calendars[0].year, this.calendars[0].month, 1), + lastVisibleDate = new Date(this.calendars[this.calendars.length-1].year, this.calendars[this.calendars.length-1].month, 1), + visibleDate = date.getTime(); + // get the end of the month + lastVisibleDate.setMonth(lastVisibleDate.getMonth()+1); + lastVisibleDate.setDate(lastVisibleDate.getDate()-1); + newCalendar = (visibleDate < firstVisibleDate.getTime() || lastVisibleDate.getTime() < visibleDate); + } + + if (newCalendar) { + this.calendars = [{ + month: date.getMonth(), + year: date.getFullYear() + }]; + if (this._o.mainCalendar === 'right') { + this.calendars[0].month += 1 - this._o.numberOfMonths; + } + } + + this.adjustCalendars(); + }, + + adjustDate: function(sign, days) { + + var day = this.getDate() || new Date(); + var difference = parseInt(days)*24*60*60*1000; + + var newDay; + + if (sign === 'add') { + newDay = new Date(day.valueOf() + difference); + } else if (sign === 'subtract') { + newDay = new Date(day.valueOf() - difference); + } + + this.setDate(newDay); + }, + + adjustCalendars: function() { + this.calendars[0] = adjustCalendar(this.calendars[0]); + for (var c = 1; c < this._o.numberOfMonths; c++) { + this.calendars[c] = adjustCalendar({ + month: this.calendars[0].month + c, + year: this.calendars[0].year + }); + } + this.draw(); + }, + + gotoToday: function() + { + this.gotoDate(new Date()); + }, + + /** + * change view to a specific month (zero-index, e.g. 0: January) + */ + gotoMonth: function(month) + { + if (!isNaN(month)) { + this.calendars[0].month = parseInt(month, 10); + this.adjustCalendars(); + } + }, + + nextMonth: function() + { + this.calendars[0].month++; + this.adjustCalendars(); + }, + + prevMonth: function() + { + this.calendars[0].month--; + this.adjustCalendars(); + }, + + /** + * change view to a specific full year (e.g. "2012") + */ + gotoYear: function(year) + { + if (!isNaN(year)) { + this.calendars[0].year = parseInt(year, 10); + this.adjustCalendars(); + } + }, + + /** + * change the minDate + */ + setMinDate: function(value) + { + if(value instanceof Date) { + setToStartOfDay(value); + this._o.minDate = value; + this._o.minYear = value.getFullYear(); + this._o.minMonth = value.getMonth(); + } else { + this._o.minDate = defaults.minDate; + this._o.minYear = defaults.minYear; + this._o.minMonth = defaults.minMonth; + this._o.startRange = defaults.startRange; + } + + this.draw(); + }, + + /** + * change the maxDate + */ + setMaxDate: function(value) + { + if(value instanceof Date) { + setToStartOfDay(value); + this._o.maxDate = value; + this._o.maxYear = value.getFullYear(); + this._o.maxMonth = value.getMonth(); + } else { + this._o.maxDate = defaults.maxDate; + this._o.maxYear = defaults.maxYear; + this._o.maxMonth = defaults.maxMonth; + this._o.endRange = defaults.endRange; + } + + this.draw(); + }, + + setStartRange: function(value) + { + this._o.startRange = value; + }, + + setEndRange: function(value) + { + this._o.endRange = value; + }, + + /** + * refresh the HTML + */ + draw: function(force) + { + if (!this._v && !force) { + return; + } + var opts = this._o, + minYear = opts.minYear, + maxYear = opts.maxYear, + minMonth = opts.minMonth, + maxMonth = opts.maxMonth, + html = '', + randId; + + if (this._y <= minYear) { + this._y = minYear; + if (!isNaN(minMonth) && this._m < minMonth) { + this._m = minMonth; + } + } + if (this._y >= maxYear) { + this._y = maxYear; + if (!isNaN(maxMonth) && this._m > maxMonth) { + this._m = maxMonth; + } + } + + randId = 'pika-title-' + Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 2); + + for (var c = 0; c < opts.numberOfMonths; c++) { + html += '
' + renderTitle(this, c, this.calendars[c].year, this.calendars[c].month, this.calendars[0].year, randId) + this.render(this.calendars[c].year, this.calendars[c].month, randId) + '
'; + } + + this.el.innerHTML = html; + + if (opts.bound) { + if(opts.field.type !== 'hidden') { + sto(function() { + opts.trigger.focus(); + }, 1); + } + } + + if (typeof this._o.onDraw === 'function') { + this._o.onDraw(this); + } + + if (opts.bound) { + // let the screen reader user know to use arrow keys + opts.field.setAttribute('aria-label', opts.ariaLabel); + } + }, + + adjustPosition: function() + { + var field, pEl, width, height, viewportWidth, viewportHeight, scrollTop, left, top, clientRect, leftAligned, bottomAligned; + + if (this._o.container) return; + + this.el.style.position = 'absolute'; + + field = this._o.trigger; + pEl = field; + width = this.el.offsetWidth; + height = this.el.offsetHeight; + viewportWidth = window.innerWidth || document.documentElement.clientWidth; + viewportHeight = window.innerHeight || document.documentElement.clientHeight; + scrollTop = window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop; + leftAligned = true; + bottomAligned = true; + + if (typeof field.getBoundingClientRect === 'function') { + clientRect = field.getBoundingClientRect(); + left = clientRect.left + window.pageXOffset; + top = clientRect.bottom + window.pageYOffset; + } else { + left = pEl.offsetLeft; + top = pEl.offsetTop + pEl.offsetHeight; + while((pEl = pEl.offsetParent)) { + left += pEl.offsetLeft; + top += pEl.offsetTop; + } + } + + // default position is bottom & left + if ((this._o.reposition && left + width > viewportWidth) || + ( + this._o.position.indexOf('right') > -1 && + left - width + field.offsetWidth > 0 + ) + ) { + left = left - width + field.offsetWidth; + leftAligned = false; + } + if ((this._o.reposition && top + height > viewportHeight + scrollTop) || + ( + this._o.position.indexOf('top') > -1 && + top - height - field.offsetHeight > 0 + ) + ) { + top = top - height - field.offsetHeight; + bottomAligned = false; + } + + this.el.style.left = left + 'px'; + this.el.style.top = top + 'px'; + + addClass(this.el, leftAligned ? 'left-aligned' : 'right-aligned'); + addClass(this.el, bottomAligned ? 'bottom-aligned' : 'top-aligned'); + removeClass(this.el, !leftAligned ? 'left-aligned' : 'right-aligned'); + removeClass(this.el, !bottomAligned ? 'bottom-aligned' : 'top-aligned'); + }, + + /** + * render HTML for a particular month + */ + render: function(year, month, randId) + { + var opts = this._o, + now = new Date(), + days = getDaysInMonth(year, month), + before = new Date(year, month, 1).getDay(), + data = [], + row = []; + setToStartOfDay(now); + if (opts.firstDay > 0) { + before -= opts.firstDay; + if (before < 0) { + before += 7; + } + } + var previousMonth = month === 0 ? 11 : month - 1, + nextMonth = month === 11 ? 0 : month + 1, + yearOfPreviousMonth = month === 0 ? year - 1 : year, + yearOfNextMonth = month === 11 ? year + 1 : year, + daysInPreviousMonth = getDaysInMonth(yearOfPreviousMonth, previousMonth); + var cells = days + before, + after = cells; + while(after > 7) { + after -= 7; + } + cells += 7 - after; + var isWeekSelected = false; + for (var i = 0, r = 0; i < cells; i++) + { + var day = new Date(year, month, 1 + (i - before)), + isSelected = isDate(this._d) ? compareDates(day, this._d) : false, + isToday = compareDates(day, now), + hasEvent = opts.events.indexOf(day.toDateString()) !== -1 ? true : false, + isEmpty = i < before || i >= (days + before), + dayNumber = 1 + (i - before), + monthNumber = month, + yearNumber = year, + isStartRange = opts.startRange && compareDates(opts.startRange, day), + isEndRange = opts.endRange && compareDates(opts.endRange, day), + isInRange = opts.startRange && opts.endRange && opts.startRange < day && day < opts.endRange, + isDisabled = (opts.minDate && day < opts.minDate) || + (opts.maxDate && day > opts.maxDate) || + (opts.disableWeekends && isWeekend(day)) || + (opts.disableDayFn && opts.disableDayFn(day)); + + if (isEmpty) { + if (i < before) { + dayNumber = daysInPreviousMonth + dayNumber; + monthNumber = previousMonth; + yearNumber = yearOfPreviousMonth; + } else { + dayNumber = dayNumber - days; + monthNumber = nextMonth; + yearNumber = yearOfNextMonth; + } + } + + var dayConfig = { + day: dayNumber, + month: monthNumber, + year: yearNumber, + hasEvent: hasEvent, + isSelected: isSelected, + isToday: isToday, + isDisabled: isDisabled, + isEmpty: isEmpty, + isStartRange: isStartRange, + isEndRange: isEndRange, + isInRange: isInRange, + showDaysInNextAndPreviousMonths: opts.showDaysInNextAndPreviousMonths, + enableSelectionDaysInNextAndPreviousMonths: opts.enableSelectionDaysInNextAndPreviousMonths + }; + + if (opts.pickWholeWeek && isSelected) { + isWeekSelected = true; + } + + row.push(renderDay(dayConfig)); + + if (++r === 7) { + if (opts.showWeekNumber) { + row.unshift(renderWeek(i - before, month, year)); + } + data.push(renderRow(row, opts.isRTL, opts.pickWholeWeek, isWeekSelected)); + row = []; + r = 0; + isWeekSelected = false; + } + } + return renderTable(opts, data, randId); + }, + + isVisible: function() + { + return this._v; + }, + + show: function() + { + if (!this.isVisible()) { + this._v = true; + this.draw(); + removeClass(this.el, 'is-hidden'); + if (this._o.bound) { + addEvent(document, 'click', this._onClick); + this.adjustPosition(); + } + if (typeof this._o.onOpen === 'function') { + this._o.onOpen.call(this); + } + } + }, + + hide: function() + { + var v = this._v; + if (v !== false) { + if (this._o.bound) { + removeEvent(document, 'click', this._onClick); + } + this.el.style.position = 'static'; // reset + this.el.style.left = 'auto'; + this.el.style.top = 'auto'; + addClass(this.el, 'is-hidden'); + this._v = false; + if (v !== undefined && typeof this._o.onClose === 'function') { + this._o.onClose.call(this); + } + } + }, + + /** + * GAME OVER + */ + destroy: function() + { + var opts = this._o; + + this.hide(); + removeEvent(this.el, 'mousedown', this._onMouseDown, true); + removeEvent(this.el, 'touchend', this._onMouseDown, true); + removeEvent(this.el, 'change', this._onChange); + if (opts.keyboardInput) { + removeEvent(document, 'keydown', this._onKeyChange); + } + if (opts.field) { + removeEvent(opts.field, 'change', this._onInputChange); + if (opts.bound) { + removeEvent(opts.trigger, 'click', this._onInputClick); + removeEvent(opts.trigger, 'focus', this._onInputFocus); + removeEvent(opts.trigger, 'blur', this._onInputBlur); + } + } + if (this.el.parentNode) { + this.el.parentNode.removeChild(this.el); + } + } + + }; + + return Pikaday; +})); +}); + +function _typeof$E(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$E = function _typeof(obj) { return typeof obj; }; } else { _typeof$E = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$E(obj); } + +function _classCallCheck$1a(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$15(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); } } + +function _createClass$15(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$15(Constructor.prototype, protoProps); if (staticProps) _defineProperties$15(Constructor, staticProps); return Constructor; } + +function _get$7(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$7 = Reflect.get; } else { _get$7 = function _get(target, property, receiver) { var base = _superPropBase$7(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$7(target, property, receiver || target); } + +function _superPropBase$7(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$t(object); if (object === null) break; } return object; } + +function _inherits$t(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$u(subClass, superClass); } + +function _setPrototypeOf$u(o, p) { _setPrototypeOf$u = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$u(o, p); } + +function _createSuper$t(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$u(); return function _createSuperInternal() { var Super = _getPrototypeOf$t(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$t(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$t(this, result); }; } + +function _possibleConstructorReturn$t(self, call) { if (call && (_typeof$E(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$t(self); } + +function _assertThisInitialized$t(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$u() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$t(o) { _getPrototypeOf$t = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$t(o); } +var EDITOR_TYPE$5 = 'date'; +/** + * @private + * @class DateEditor + */ + +var DateEditor = /*#__PURE__*/function (_TextEditor) { + _inherits$t(DateEditor, _TextEditor); + + var _super = _createSuper$t(DateEditor); + + /** + * @param {Core} hotInstance Handsontable instance. + * @private + */ + function DateEditor(hotInstance) { + var _this; + + _classCallCheck$1a(this, DateEditor); + + _this = _super.call(this, hotInstance); // TODO: Move this option to general settings + + _this.defaultDateFormat = 'DD/MM/YYYY'; + _this.isCellEdited = false; + _this.parentDestroyed = false; + return _this; + } + + _createClass$15(DateEditor, [{ + key: "init", + value: function init() { + var _this2 = this; + + if (typeof moment !== 'function') { + throw new Error('You need to include moment.js to your project.'); + } + + if (typeof pikaday !== 'function') { + throw new Error('You need to include Pikaday to your project.'); + } + + _get$7(_getPrototypeOf$t(DateEditor.prototype), "init", this).call(this); + + this.instance.addHook('afterDestroy', function () { + _this2.parentDestroyed = true; + + _this2.destroyElements(); + }); + } + /** + * Create data picker instance. + */ + + }, { + key: "createElements", + value: function createElements() { + _get$7(_getPrototypeOf$t(DateEditor.prototype), "createElements", this).call(this); + + this.datePicker = this.hot.rootDocument.createElement('DIV'); + this.datePickerStyle = this.datePicker.style; + this.datePickerStyle.position = 'absolute'; + this.datePickerStyle.top = 0; + this.datePickerStyle.left = 0; + this.datePickerStyle.zIndex = 9999; + addClass(this.datePicker, 'htDatepickerHolder'); + this.hot.rootDocument.body.appendChild(this.datePicker); + this.$datePicker = new pikaday(this.getDatePickerConfig()); + var eventManager = new EventManager(this); + /** + * Prevent recognizing clicking on datepicker as clicking outside of table. + */ + + eventManager.addEventListener(this.datePicker, 'mousedown', function (event) { + return event.stopPropagation(); + }); + this.hideDatepicker(); + } + /** + * Destroy data picker instance. + */ + + }, { + key: "destroyElements", + value: function destroyElements() { + var datePickerParentElement = this.datePicker.parentNode; + this.$datePicker.destroy(); + + if (datePickerParentElement) { + datePickerParentElement.removeChild(this.datePicker); + } + } + /** + * Prepare editor to appear. + * + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {HTMLTableCellElement} td The rendered cell element. + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + + }, { + key: "prepare", + value: function prepare(row, col, prop, td, value, cellProperties) { + _get$7(_getPrototypeOf$t(DateEditor.prototype), "prepare", this).call(this, row, col, prop, td, value, cellProperties); + } + /** + * Open editor. + * + * @param {Event} [event=null] The event object. + */ + + }, { + key: "open", + value: function open() { + var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + _get$7(_getPrototypeOf$t(DateEditor.prototype), "open", this).call(this); + + this.showDatepicker(event); + } + /** + * Close editor. + */ + + }, { + key: "close", + value: function close() { + var _this3 = this; + + this._opened = false; + + this.instance._registerTimeout(function () { + _this3.instance._refreshBorders(); + }); + + _get$7(_getPrototypeOf$t(DateEditor.prototype), "close", this).call(this); + } + /** + * Finishes editing and start saving or restoring process for editing cell or last selected range. + * + * @param {boolean} restoreOriginalValue If true, then closes editor without saving value from the editor into a cell. + * @param {boolean} ctrlDown If true, then saveValue will save editor's value to each cell in the last selected range. + */ + + }, { + key: "finishEditing", + value: function finishEditing() { + var restoreOriginalValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var ctrlDown = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + + if (restoreOriginalValue) { + // pressed ESC, restore original value + // var value = this.instance.getDataAtCell(this.row, this.col); + var value = this.originalValue; + + if (value !== void 0) { + this.setValue(value); + } + } + + this.hideDatepicker(); + + _get$7(_getPrototypeOf$t(DateEditor.prototype), "finishEditing", this).call(this, restoreOriginalValue, ctrlDown); + } + /** + * Show data picker. + * + * @param {Event} event The event object. + */ + + }, { + key: "showDatepicker", + value: function showDatepicker(event) { + this.$datePicker.config(this.getDatePickerConfig()); + var offset = this.TD.getBoundingClientRect(); + var dateFormat = this.cellProperties.dateFormat || this.defaultDateFormat; + var datePickerConfig = this.$datePicker.config(); + var dateStr; + var isMouseDown = this.instance.view.isMouseDown(); + var isMeta = event ? isMetaKey(event.keyCode) : false; + this.datePickerStyle.top = "".concat(this.hot.rootWindow.pageYOffset + offset.top + outerHeight(this.TD), "px"); + this.datePickerStyle.left = "".concat(this.hot.rootWindow.pageXOffset + offset.left, "px"); + + this.$datePicker._onInputFocus = function () {}; + + datePickerConfig.format = dateFormat; + + if (this.originalValue) { + dateStr = this.originalValue; + + if (moment(dateStr, dateFormat, true).isValid()) { + this.$datePicker.setMoment(moment(dateStr, dateFormat), true); + } // workaround for date/time cells - pikaday resets the cell value to 12:00 AM by default, this will overwrite the value. + + + if (this.getValue() !== this.originalValue) { + this.setValue(this.originalValue); + } + + if (!isMeta && !isMouseDown) { + this.setValue(''); + } + } else if (this.cellProperties.defaultDate) { + dateStr = this.cellProperties.defaultDate; + datePickerConfig.defaultDate = dateStr; + + if (moment(dateStr, dateFormat, true).isValid()) { + this.$datePicker.setMoment(moment(dateStr, dateFormat), true); + } + + if (!isMeta && !isMouseDown) { + this.setValue(''); + } + } else { + // if a default date is not defined, set a soft-default-date: display the current day and month in the + // datepicker, but don't fill the editor input + this.$datePicker.gotoToday(); + } + + this.datePickerStyle.display = 'block'; + this.$datePicker.show(); + } + /** + * Hide data picker. + */ + + }, { + key: "hideDatepicker", + value: function hideDatepicker() { + this.datePickerStyle.display = 'none'; + this.$datePicker.hide(); + } + /** + * Get date picker options. + * + * @returns {object} + */ + + }, { + key: "getDatePickerConfig", + value: function getDatePickerConfig() { + var _this4 = this; + + var htInput = this.TEXTAREA; + var options = {}; + + if (this.cellProperties && this.cellProperties.datePickerConfig) { + deepExtend(options, this.cellProperties.datePickerConfig); + } + + var origOnSelect = options.onSelect; + var origOnClose = options.onClose; + options.field = htInput; + options.trigger = htInput; + options.container = this.datePicker; + options.bound = false; + options.format = options.format || this.defaultDateFormat; + options.reposition = options.reposition || false; + + options.onSelect = function (value) { + var dateStr = value; + + if (!isNaN(dateStr.getTime())) { + dateStr = moment(dateStr).format(_this4.cellProperties.dateFormat || _this4.defaultDateFormat); + } + + _this4.setValue(dateStr); + + _this4.hideDatepicker(); + + if (origOnSelect) { + origOnSelect(); + } + }; + + options.onClose = function () { + if (!_this4.parentDestroyed) { + _this4.finishEditing(false); + } + + if (origOnClose) { + origOnClose(); + } + }; + + return options; + } + }], [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE$5; + } + }]); + + return DateEditor; +}(TextEditor); + +function _typeof$F(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$F = function _typeof(obj) { return typeof obj; }; } else { _typeof$F = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$F(obj); } + +function _classCallCheck$1b(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$16(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); } } + +function _createClass$16(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$16(Constructor.prototype, protoProps); if (staticProps) _defineProperties$16(Constructor, staticProps); return Constructor; } + +function _get$8(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$8 = Reflect.get; } else { _get$8 = function _get(target, property, receiver) { var base = _superPropBase$8(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$8(target, property, receiver || target); } + +function _superPropBase$8(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$u(object); if (object === null) break; } return object; } + +function _inherits$u(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$v(subClass, superClass); } + +function _setPrototypeOf$v(o, p) { _setPrototypeOf$v = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$v(o, p); } + +function _createSuper$u(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$v(); return function _createSuperInternal() { var Super = _getPrototypeOf$u(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$u(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$u(this, result); }; } + +function _possibleConstructorReturn$u(self, call) { if (call && (_typeof$F(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$u(self); } + +function _assertThisInitialized$u(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$v() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$u(o) { _getPrototypeOf$u = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$u(o); } +var EDITOR_TYPE$6 = 'dropdown'; +/** + * @private + * @class DropdownEditor + */ + +var DropdownEditor = /*#__PURE__*/function (_AutocompleteEditor) { + _inherits$u(DropdownEditor, _AutocompleteEditor); + + var _super = _createSuper$u(DropdownEditor); + + function DropdownEditor() { + _classCallCheck$1b(this, DropdownEditor); + + return _super.apply(this, arguments); + } + + _createClass$16(DropdownEditor, [{ + key: "prepare", + value: + /** + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {HTMLTableCellElement} td The rendered cell element. + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + function prepare(row, col, prop, td, value, cellProperties) { + _get$8(_getPrototypeOf$u(DropdownEditor.prototype), "prepare", this).call(this, row, col, prop, td, value, cellProperties); + + this.cellProperties.filter = false; + this.cellProperties.strict = true; + } + }], [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE$6; + } + }]); + + return DropdownEditor; +}(AutocompleteEditor); +Hooks.getSingleton().add('beforeValidate', function (value, row, col) { + var cellMeta = this.getCellMeta(row, this.propToCol(col)); + + if (cellMeta.editor === DropdownEditor) { + if (cellMeta.strict === void 0) { + cellMeta.filter = false; + cellMeta.strict = true; + } + } +}); + +function _typeof$G(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$G = function _typeof(obj) { return typeof obj; }; } else { _typeof$G = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$G(obj); } + +function _classCallCheck$1c(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$17(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); } } + +function _createClass$17(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$17(Constructor.prototype, protoProps); if (staticProps) _defineProperties$17(Constructor, staticProps); return Constructor; } + +function _inherits$v(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$w(subClass, superClass); } + +function _setPrototypeOf$w(o, p) { _setPrototypeOf$w = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$w(o, p); } + +function _createSuper$v(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$w(); return function _createSuperInternal() { var Super = _getPrototypeOf$v(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$v(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$v(this, result); }; } + +function _possibleConstructorReturn$v(self, call) { if (call && (_typeof$G(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$v(self); } + +function _assertThisInitialized$v(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$w() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$v(o) { _getPrototypeOf$v = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$v(o); } +var EDITOR_TYPE$7 = 'numeric'; +/** + * @private + * @class NumericEditor + */ + +var NumericEditor = /*#__PURE__*/function (_TextEditor) { + _inherits$v(NumericEditor, _TextEditor); + + var _super = _createSuper$v(NumericEditor); + + function NumericEditor() { + _classCallCheck$1c(this, NumericEditor); + + return _super.apply(this, arguments); + } + + _createClass$17(NumericEditor, null, [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE$7; + } + }]); + + return NumericEditor; +}(TextEditor); + +function _typeof$H(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$H = function _typeof(obj) { return typeof obj; }; } else { _typeof$H = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$H(obj); } + +function _classCallCheck$1d(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$18(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); } } + +function _createClass$18(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$18(Constructor.prototype, protoProps); if (staticProps) _defineProperties$18(Constructor, staticProps); return Constructor; } + +function _get$9(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$9 = Reflect.get; } else { _get$9 = function _get(target, property, receiver) { var base = _superPropBase$9(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$9(target, property, receiver || target); } + +function _superPropBase$9(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$w(object); if (object === null) break; } return object; } + +function _inherits$w(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$x(subClass, superClass); } + +function _setPrototypeOf$x(o, p) { _setPrototypeOf$x = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$x(o, p); } + +function _createSuper$w(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$x(); return function _createSuperInternal() { var Super = _getPrototypeOf$w(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$w(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$w(this, result); }; } + +function _possibleConstructorReturn$w(self, call) { if (call && (_typeof$H(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$w(self); } + +function _assertThisInitialized$w(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$x() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$w(o) { _getPrototypeOf$w = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$w(o); } +var EDITOR_TYPE$8 = 'password'; +/** + * @private + * @class PasswordEditor + */ + +var PasswordEditor = /*#__PURE__*/function (_TextEditor) { + _inherits$w(PasswordEditor, _TextEditor); + + var _super = _createSuper$w(PasswordEditor); + + function PasswordEditor() { + _classCallCheck$1d(this, PasswordEditor); + + return _super.apply(this, arguments); + } + + _createClass$18(PasswordEditor, [{ + key: "createElements", + value: function createElements() { + _get$9(_getPrototypeOf$w(PasswordEditor.prototype), "createElements", this).call(this); + + this.TEXTAREA = this.hot.rootDocument.createElement('input'); + this.TEXTAREA.setAttribute('type', 'password'); + this.TEXTAREA.setAttribute('data-hot-input', ''); // Makes the element recognizable by Hot as its own component's element. + + this.TEXTAREA.className = 'handsontableInput'; + this.textareaStyle = this.TEXTAREA.style; + this.textareaStyle.width = 0; + this.textareaStyle.height = 0; + empty(this.TEXTAREA_PARENT); + this.TEXTAREA_PARENT.appendChild(this.TEXTAREA); + } + }], [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE$8; + } + }]); + + return PasswordEditor; +}(TextEditor); + +function _typeof$I(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$I = function _typeof(obj) { return typeof obj; }; } else { _typeof$I = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$I(obj); } + +function _classCallCheck$1e(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$19(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); } } + +function _createClass$19(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$19(Constructor.prototype, protoProps); if (staticProps) _defineProperties$19(Constructor, staticProps); return Constructor; } + +function _get$a(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$a = Reflect.get; } else { _get$a = function _get(target, property, receiver) { var base = _superPropBase$a(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$a(target, property, receiver || target); } + +function _superPropBase$a(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$x(object); if (object === null) break; } return object; } + +function _inherits$x(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$y(subClass, superClass); } + +function _setPrototypeOf$y(o, p) { _setPrototypeOf$y = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$y(o, p); } + +function _createSuper$x(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$y(); return function _createSuperInternal() { var Super = _getPrototypeOf$x(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$x(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$x(this, result); }; } + +function _possibleConstructorReturn$x(self, call) { if (call && (_typeof$I(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$x(self); } + +function _assertThisInitialized$x(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$y() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$x(o) { _getPrototypeOf$x = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$x(o); } +var EDITOR_VISIBLE_CLASS_NAME$1 = 'ht_editor_visible'; +var EDITOR_TYPE$9 = 'select'; +/** + * @private + * @class SelectEditor + */ + +var SelectEditor = /*#__PURE__*/function (_BaseEditor) { + _inherits$x(SelectEditor, _BaseEditor); + + var _super = _createSuper$x(SelectEditor); + + function SelectEditor() { + _classCallCheck$1e(this, SelectEditor); + + return _super.apply(this, arguments); + } + + _createClass$19(SelectEditor, [{ + key: "init", + value: + /** + * Initializes editor instance, DOM Element and mount hooks. + */ + function init() { + this.select = this.hot.rootDocument.createElement('SELECT'); + addClass(this.select, 'htSelectEditor'); + this.select.style.display = 'none'; + this.hot.rootElement.appendChild(this.select); + this.registerHooks(); + } + /** + * Returns select's value. + * + * @returns {*} + */ + + }, { + key: "getValue", + value: function getValue() { + return this.select.value; + } + /** + * Sets value in the select element. + * + * @param {*} value A new select's value. + */ + + }, { + key: "setValue", + value: function setValue(value) { + this.select.value = value; + } + /** + * Opens the editor and adjust its size. + */ + + }, { + key: "open", + value: function open() { + var _this = this; + + this._opened = true; + this.refreshDimensions(); + this.select.style.display = ''; + this.addHook('beforeKeyDown', function () { + return _this.onBeforeKeyDown(); + }); + } + /** + * Closes the editor. + */ + + }, { + key: "close", + value: function close() { + this._opened = false; + this.select.style.display = 'none'; + + if (hasClass(this.select, EDITOR_VISIBLE_CLASS_NAME$1)) { + removeClass(this.select, EDITOR_VISIBLE_CLASS_NAME$1); + } + + this.clearHooks(); + } + /** + * Sets focus state on the select element. + */ + + }, { + key: "focus", + value: function focus() { + this.select.focus(); + } + /** + * Binds hooks to refresh editor's size after scrolling of the viewport or resizing of columns/rows. + * + * @private + */ + + }, { + key: "registerHooks", + value: function registerHooks() { + var _this2 = this; + + this.addHook('afterScrollHorizontally', function () { + return _this2.refreshDimensions(); + }); + this.addHook('afterScrollVertically', function () { + return _this2.refreshDimensions(); + }); + this.addHook('afterColumnResize', function () { + return _this2.refreshDimensions(); + }); + this.addHook('afterRowResize', function () { + return _this2.refreshDimensions(); + }); + } + /** + * Prepares editor's meta data and a list of available options. + * + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {HTMLTableCellElement} td The rendered cell element. + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + + }, { + key: "prepare", + value: function prepare(row, col, prop, td, value, cellProperties) { + var _this3 = this; + + _get$a(_getPrototypeOf$x(SelectEditor.prototype), "prepare", this).call(this, row, col, prop, td, value, cellProperties); + + var selectOptions = this.cellProperties.selectOptions; + var options; + + if (typeof selectOptions === 'function') { + options = this.prepareOptions(selectOptions(this.row, this.col, this.prop)); + } else { + options = this.prepareOptions(selectOptions); + } + + empty(this.select); + objectEach(options, function (optionValue, key) { + var optionElement = _this3.hot.rootDocument.createElement('OPTION'); + + optionElement.value = key; + fastInnerHTML(optionElement, optionValue); + + _this3.select.appendChild(optionElement); + }); + } + /** + * Creates consistent list of available options. + * + * @private + * @param {Array|object} optionsToPrepare The list of the values to render in the select eleemnt. + * @returns {object} + */ + + }, { + key: "prepareOptions", + value: function prepareOptions(optionsToPrepare) { + var preparedOptions = {}; + + if (Array.isArray(optionsToPrepare)) { + for (var i = 0, len = optionsToPrepare.length; i < len; i++) { + preparedOptions[optionsToPrepare[i]] = optionsToPrepare[i]; + } + } else if (_typeof$I(optionsToPrepare) === 'object') { + preparedOptions = optionsToPrepare; + } + + return preparedOptions; + } + /** + * Refreshes editor's value using source data. + * + * @private + */ + + }, { + key: "refreshValue", + value: function refreshValue() { + var sourceData = this.hot.getSourceDataAtCell(this.row, this.prop); + this.originalValue = sourceData; + this.setValue(sourceData); + this.refreshDimensions(); + } + /** + * Refreshes editor's size and position. + * + * @private + */ + + }, { + key: "refreshDimensions", + value: function refreshDimensions() { + if (this.state !== EDITOR_STATE.EDITING) { + return; + } + + this.TD = this.getEditedCell(); // TD is outside of the viewport. + + if (!this.TD) { + this.close(); + return; + } + + var wtOverlays = this.hot.view.wt.wtOverlays; + var currentOffset = offset(this.TD); + var containerOffset = offset(this.hot.rootElement); + var scrollableContainer = wtOverlays.scrollableElement; + var editorSection = this.checkEditorSection(); + var width = outerWidth(this.TD) + 1; + var height = outerHeight(this.TD) + 1; + var editTop = currentOffset.top - containerOffset.top - 1 - (scrollableContainer.scrollTop || 0); + var editLeft = currentOffset.left - containerOffset.left - 1 - (scrollableContainer.scrollLeft || 0); + var cssTransformOffset; + + switch (editorSection) { + case 'top': + cssTransformOffset = getCssTransform(wtOverlays.topOverlay.clone.wtTable.holder.parentNode); + break; + + case 'left': + cssTransformOffset = getCssTransform(wtOverlays.leftOverlay.clone.wtTable.holder.parentNode); + break; + + case 'top-left-corner': + cssTransformOffset = getCssTransform(wtOverlays.topLeftCornerOverlay.clone.wtTable.holder.parentNode); + break; + + case 'bottom-left-corner': + cssTransformOffset = getCssTransform(wtOverlays.bottomLeftCornerOverlay.clone.wtTable.holder.parentNode); + break; + + case 'bottom': + cssTransformOffset = getCssTransform(wtOverlays.bottomOverlay.clone.wtTable.holder.parentNode); + break; + } + + var renderableRow = this.hot.rowIndexMapper.getRenderableFromVisualIndex(this.row); + var renderableColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(this.col); + var nrOfRenderableRowIndexes = this.hot.rowIndexMapper.getRenderableIndexesLength(); + var firstRowIndexOfTheBottomOverlay = nrOfRenderableRowIndexes - this.hot.view.wt.getSetting('fixedRowsBottom'); + + if (renderableRow <= 0 || renderableRow === firstRowIndexOfTheBottomOverlay) { + editTop += 1; + } + + if (renderableColumn <= 0) { + editLeft += 1; + } + + var selectStyle = this.select.style; + + if (cssTransformOffset && cssTransformOffset !== -1) { + selectStyle[cssTransformOffset[0]] = cssTransformOffset[1]; + } else { + resetCssTransform(this.select); + } + + var cellComputedStyle = getComputedStyle(this.TD, this.hot.rootWindow); + + if (parseInt(cellComputedStyle.borderTopWidth, 10) > 0) { + height -= 1; + } + + if (parseInt(cellComputedStyle.borderLeftWidth, 10) > 0) { + width -= 1; + } + + selectStyle.height = "".concat(height, "px"); + selectStyle.minWidth = "".concat(width, "px"); + selectStyle.top = "".concat(editTop, "px"); + selectStyle.left = "".concat(editLeft, "px"); + selectStyle.margin = '0px'; + addClass(this.select, EDITOR_VISIBLE_CLASS_NAME$1); + } + /** + * OnBeforeKeyDown callback. + * + * @private + */ + + }, { + key: "onBeforeKeyDown", + value: function onBeforeKeyDown() { + var previousOptionIndex = this.select.selectedIndex - 1; + var nextOptionIndex = this.select.selectedIndex + 1; + + switch (event.keyCode) { + case KEY_CODES.ARROW_UP: + if (previousOptionIndex >= 0) { + this.select[previousOptionIndex].selected = true; + } + + stopImmediatePropagation(event); + event.preventDefault(); + break; + + case KEY_CODES.ARROW_DOWN: + if (nextOptionIndex <= this.select.length - 1) { + this.select[nextOptionIndex].selected = true; + } + + stopImmediatePropagation(event); + event.preventDefault(); + break; + } + } + }], [{ + key: "EDITOR_TYPE", + get: function get() { + return EDITOR_TYPE$9; + } + }]); + + return SelectEditor; +}(BaseEditor); + +var RENDERER_TYPE$2 = 'html'; +/** + * @private + * @param {Core} instance The Handsontable instance. + * @param {HTMLTableCellElement} TD The rendered cell element. + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + +function htmlRenderer(instance, TD, row, col, prop, value, cellProperties) { + baseRenderer.apply(this, [instance, TD, row, col, prop, value, cellProperties]); + fastInnerHTML(TD, value === null || value === void 0 ? '' : value, false); +} +htmlRenderer.RENDERER_TYPE = RENDERER_TYPE$2; + +var RENDERER_TYPE$3 = 'autocomplete'; +/** + * Autocomplete renderer. + * + * @private + * @param {Core} instance The Handsontable instance. + * @param {HTMLTableCellElement} TD The rendered cell element. + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + +function autocompleteRenderer(instance, TD, row, col, prop, value, cellProperties) { + var rootDocument = instance.rootDocument; + var rendererFunc = cellProperties.allowHtml ? htmlRenderer : textRenderer; + var ARROW = rootDocument.createElement('DIV'); + ARROW.className = 'htAutocompleteArrow'; + ARROW.appendChild(rootDocument.createTextNode(String.fromCharCode(9660))); + rendererFunc.apply(this, [instance, TD, row, col, prop, value, cellProperties]); + + if (!TD.firstChild) { + // http://jsperf.com/empty-node-if-needed + // otherwise empty fields appear borderless in demo/renderers.html (IE) + TD.appendChild(rootDocument.createTextNode(String.fromCharCode(160))); // workaround for https://github.com/handsontable/handsontable/issues/1946 + // this is faster than innerHTML. See: https://github.com/handsontable/handsontable/wiki/JavaScript-&-DOM-performance-tips + } + + TD.insertBefore(ARROW, TD.firstChild); + addClass(TD, 'htAutocomplete'); + + if (!instance.acArrowListener) { + var eventManager = new EventManager(instance); // not very elegant but easy and fast + + instance.acArrowListener = function (event) { + if (hasClass(event.target, 'htAutocompleteArrow')) { + instance.view.wt.getSetting('onCellDblClick', null, new CellCoords(row, col), TD); + } + }; + + eventManager.addEventListener(instance.rootElement, 'mousedown', instance.acArrowListener); // We need to unbind the listener after the table has been destroyed + + instance.addHookOnce('afterDestroy', function () { + eventManager.destroy(); + }); + } +} +autocompleteRenderer.RENDERER_TYPE = RENDERER_TYPE$3; + +var isListeningKeyDownEvent = new WeakMap(); +var isCheckboxListenerAdded = new WeakMap(); +var BAD_VALUE_CLASS = 'htBadValue'; +var RENDERER_TYPE$4 = 'checkbox'; +/** + * Checkbox renderer. + * + * @private + * @param {Core} instance The Handsontable instance. + * @param {HTMLTableCellElement} TD The rendered cell element. + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {number|string} prop The column property (passed when datasource is an array of objects). + * @param {*} value The rendered value. + * @param {object} cellProperties The cell meta object ({@see Core#getCellMeta}). + */ + +function checkboxRenderer(instance, TD, row, col, prop, value, cellProperties) { + var rootDocument = instance.rootDocument; + baseRenderer.apply(this, [instance, TD, row, col, prop, value, cellProperties]); + registerEvents(instance); + var input = createInput(rootDocument); + var labelOptions = cellProperties.label; + var badValue = false; + + if (typeof cellProperties.checkedTemplate === 'undefined') { + cellProperties.checkedTemplate = true; + } + + if (typeof cellProperties.uncheckedTemplate === 'undefined') { + cellProperties.uncheckedTemplate = false; + } + + empty(TD); // TODO identify under what circumstances this line can be removed + + if (value === cellProperties.checkedTemplate || equalsIgnoreCase(value, cellProperties.checkedTemplate)) { + input.checked = true; + } else if (value === cellProperties.uncheckedTemplate || equalsIgnoreCase(value, cellProperties.uncheckedTemplate)) { + input.checked = false; + } else if (value === null) { + // default value + addClass(input, 'noValue'); + } else { + input.style.display = 'none'; + addClass(input, BAD_VALUE_CLASS); + badValue = true; + } + + input.setAttribute('data-row', row); + input.setAttribute('data-col', col); + + if (!badValue && labelOptions) { + var labelText = ''; + + if (labelOptions.value) { + labelText = typeof labelOptions.value === 'function' ? labelOptions.value.call(this, row, col, prop, value) : labelOptions.value; + } else if (labelOptions.property) { + var labelValue = instance.getDataAtRowProp(row, labelOptions.property); + labelText = labelValue !== null ? labelValue : ''; + } + + var label = createLabel(rootDocument, labelText); + + if (labelOptions.position === 'before') { + label.appendChild(input); + } else { + label.insertBefore(input, label.firstChild); + } + + input = label; + } + + TD.appendChild(input); + + if (badValue) { + TD.appendChild(rootDocument.createTextNode('#bad-value#')); + } + + if (!isListeningKeyDownEvent.has(instance)) { + isListeningKeyDownEvent.set(instance, true); + instance.addHook('beforeKeyDown', onBeforeKeyDown); + } + /** + * On before key down DOM listener. + * + * @private + * @param {Event} event The keyboard event object. + */ + + + function onBeforeKeyDown(event) { + var toggleKeys = 'SPACE|ENTER'; + var switchOffKeys = 'DELETE|BACKSPACE'; + var isKeyCode = partial(isKey, event.keyCode); + + if (!instance.getSettings().enterBeginsEditing && isKeyCode('ENTER')) { + return; + } + + if (isKeyCode("".concat(toggleKeys, "|").concat(switchOffKeys)) && !isImmediatePropagationStopped(event)) { + eachSelectedCheckboxCell(function () { + stopImmediatePropagation(event); + event.preventDefault(); + }); + } + + if (isKeyCode(toggleKeys)) { + changeSelectedCheckboxesState(); + } + + if (isKeyCode(switchOffKeys)) { + changeSelectedCheckboxesState(true); + } + } + /** + * Change checkbox checked property. + * + * @private + * @param {boolean} [uncheckCheckbox=false] The new "checked" state for the checkbox elements. + */ + + + function changeSelectedCheckboxesState() { + var uncheckCheckbox = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var selRange = instance.getSelectedRange(); + + if (!selRange) { + return; + } + + for (var key = 0; key < selRange.length; key++) { + var _selRange$key$getTopL = selRange[key].getTopLeftCorner(), + startRow = _selRange$key$getTopL.row, + startColumn = _selRange$key$getTopL.col; + + var _selRange$key$getBott = selRange[key].getBottomRightCorner(), + endRow = _selRange$key$getBott.row, + endColumn = _selRange$key$getBott.col; + + var changes = []; + + for (var visualRow = startRow; visualRow <= endRow; visualRow += 1) { + for (var visualColumn = startColumn; visualColumn <= endColumn; visualColumn += 1) { + var cachedCellProperties = instance.getCellMeta(visualRow, visualColumn); + + if (cachedCellProperties.type !== 'checkbox') { + return; + } + /* eslint-disable no-continue */ + + + if (cachedCellProperties.readOnly === true) { + continue; + } + + if (typeof cachedCellProperties.checkedTemplate === 'undefined') { + cachedCellProperties.checkedTemplate = true; + } + + if (typeof cachedCellProperties.uncheckedTemplate === 'undefined') { + cachedCellProperties.uncheckedTemplate = false; + } + + var dataAtCell = instance.getDataAtCell(visualRow, visualColumn); + + if (uncheckCheckbox === false) { + if ([cachedCellProperties.checkedTemplate, cachedCellProperties.checkedTemplate.toString()].includes(dataAtCell)) { + // eslint-disable-line max-len + changes.push([visualRow, visualColumn, cachedCellProperties.uncheckedTemplate]); + } else if ([cachedCellProperties.uncheckedTemplate, cachedCellProperties.uncheckedTemplate.toString(), null, void 0].includes(dataAtCell)) { + // eslint-disable-line max-len + changes.push([visualRow, visualColumn, cachedCellProperties.checkedTemplate]); + } + } else { + changes.push([visualRow, visualColumn, cachedCellProperties.uncheckedTemplate]); + } + } + } + + if (changes.length > 0) { + instance.setDataAtCell(changes); + } + } + } + /** + * Call callback for each found selected cell with checkbox type. + * + * @private + * @param {Function} callback The callback function. + */ + + + function eachSelectedCheckboxCell(callback) { + var selRange = instance.getSelectedRange(); + + if (!selRange) { + return; + } + + for (var key = 0; key < selRange.length; key++) { + var topLeft = selRange[key].getTopLeftCorner(); + var bottomRight = selRange[key].getBottomRightCorner(); + + for (var visualRow = topLeft.row; visualRow <= bottomRight.row; visualRow++) { + for (var visualColumn = topLeft.col; visualColumn <= bottomRight.col; visualColumn++) { + var cachedCellProperties = instance.getCellMeta(visualRow, visualColumn); + + if (cachedCellProperties.type !== 'checkbox') { + return; + } + + var cell = instance.getCell(visualRow, visualColumn); + + if (cell === null || cell === void 0) { + callback(visualRow, visualColumn, cachedCellProperties); + } else { + var checkboxes = cell.querySelectorAll('input[type=checkbox]'); + + if (checkboxes.length > 0 && !cachedCellProperties.readOnly) { + callback(checkboxes); + } + } + } + } + } + } +} +checkboxRenderer.RENDERER_TYPE = RENDERER_TYPE$4; +/** + * Register checkbox listeners. + * + * @param {Core} instance The Handsontable instance. + * @returns {EventManager} + */ + +function registerEvents(instance) { + var eventManager = isCheckboxListenerAdded.get(instance); + + if (!eventManager) { + var rootElement = instance.rootElement; + eventManager = new EventManager(instance); + eventManager.addEventListener(rootElement, 'click', function (event) { + return onClick(event, instance); + }); + eventManager.addEventListener(rootElement, 'mouseup', function (event) { + return onMouseUp(event, instance); + }); + eventManager.addEventListener(rootElement, 'change', function (event) { + return onChange(event, instance); + }); + isCheckboxListenerAdded.set(instance, eventManager); + } + + return eventManager; +} +/** + * Create input element. + * + * @param {Document} rootDocument The document owner. + * @returns {Node} + */ + + +function createInput(rootDocument) { + var input = rootDocument.createElement('input'); + input.className = 'htCheckboxRendererInput'; + input.type = 'checkbox'; + input.setAttribute('autocomplete', 'off'); + input.setAttribute('tabindex', '-1'); + return input.cloneNode(false); +} +/** + * Create label element. + * + * @param {Document} rootDocument The document owner. + * @param {string} text The label text. + * @returns {Node} + */ + + +function createLabel(rootDocument, text) { + var label = rootDocument.createElement('label'); + label.className = 'htCheckboxRendererLabel'; + label.appendChild(rootDocument.createTextNode(text)); + return label.cloneNode(true); +} +/** + * `mouseup` callback. + * + * @private + * @param {Event} event `mouseup` event. + * @param {Core} instance The Handsontable instance. + */ + + +function onMouseUp(event, instance) { + if (!isCheckboxInput(event.target)) { + return; + } + + setTimeout(instance.listen, 10); +} +/** + * `click` callback. + * + * @private + * @param {Event} event `click` event. + * @param {Core} instance The Handsontable instance. + * @returns {boolean|undefined} + */ + + +function onClick(event, instance) { + if (!isCheckboxInput(event.target)) { + return false; + } + + var row = parseInt(event.target.getAttribute('data-row'), 10); + var col = parseInt(event.target.getAttribute('data-col'), 10); + var cellProperties = instance.getCellMeta(row, col); + + if (cellProperties.readOnly) { + event.preventDefault(); + } +} +/** + * `change` callback. + * + * @param {Event} event `change` event. + * @param {Core} instance The Handsontable instance. + * @returns {boolean} + */ + + +function onChange(event, instance) { + if (!isCheckboxInput(event.target)) { + return false; + } + + var row = parseInt(event.target.getAttribute('data-row'), 10); + var col = parseInt(event.target.getAttribute('data-col'), 10); + var cellProperties = instance.getCellMeta(row, col); + + if (!cellProperties.readOnly) { + var newCheckboxValue = null; + + if (event.target.checked) { + newCheckboxValue = cellProperties.uncheckedTemplate === void 0 ? true : cellProperties.checkedTemplate; + } else { + newCheckboxValue = cellProperties.uncheckedTemplate === void 0 ? false : cellProperties.uncheckedTemplate; + } + + instance.setDataAtCell(row, col, newCheckboxValue); + } +} +/** + * Check if the provided element is the checkbox input. + * + * @private + * @param {HTMLElement} element The element in question. + * @returns {boolean} + */ + + +function isCheckboxInput(element) { + return element.tagName === 'INPUT' && element.getAttribute('type') === 'checkbox'; +} + +var numbro_min = createCommonjsModule(function (module, exports) { +!function(e){module.exports=e();}(function(){return function a(o,u,c){function s(t,e){if(!u[t]){if(!o[t]){var r="function"==typeof commonjsRequire&&commonjsRequire;if(!e&&r)return r(t,!0);if(l)return l(t,!0);var n=new Error("Cannot find module '"+t+"'");throw n.code="MODULE_NOT_FOUND",n}var i=u[t]={exports:{}};o[t][0].call(i.exports,function(e){return s(o[t][1][e]||e)},i,i.exports,a,o,u,c);}return u[t].exports}for(var l="function"==typeof commonjsRequire&&commonjsRequire,e=0;ea[o]^r?1:-1;return c==s?0:s(n=e.length)){for(i=r,t-=n;--t;i+=r);e+=i;}else tO?e.c=e.e=null:e.c=r=f.length){if(!n)break e;for(;f.length<=s;f.push(0));c=l=0,o=(a%=j)-j+(i=1);}else {for(c=u=f[s],i=1;10<=u;u/=10,i++);l=(o=(a%=j)-j+i)<0?0:c/p[i-o-1]%10|0;}if(n=n||t<0||null!=f[s+1]||(o<0?c:c%p[i-o-1]),n=r<4?(l||n)&&(0==r||r==(e.s<0?3:2)):5O?e.c=e.e=null:e.e>>11))?(r=crypto.getRandomValues(new Uint32Array(2)),t[o]=r[0],t[o+1]=r[1]):(u.push(a%1e14),o+=2);o=i/2;}else {if(!crypto.randomBytes)throw x=!1,Error(T+"crypto unavailable");for(t=crypto.randomBytes(i*=7);or-1&&(null==o[i+1]&&(o[i+1]=0),o[i+1]+=o[i]/r|0,o[i]%=r);}return o.reverse()}return function(e,t,r,n,i){var a,o,u,c,s,l,f,p,g=e.indexOf("."),h=b,d=w;for(0<=g&&(c=S,S=0,e=e.replace(".",""),l=(p=new A(t)).pow(e.length-g),S=c,p.c=m(H(V(l.c),l.e,"0"),10,r,v),p.e=p.c.length),u=c=(f=m(e,t,r,i?(a=M,v):(a=v,M))).length;0==f[--c];f.pop());if(!f[0])return a.charAt(0);if(g<0?--u:(l.c=f,l.e=u,l.s=n,f=(l=y(l,p,h,d,r)).c,s=l.r,u=l.e),g=f[o=u+h+1],c=r/2,s=s||o<0||null!=f[o+1],s=d<4?(null!=g||s)&&(0==d||d==(l.s<0?3:2)):cr;)f[o]=0,o||(++u,f=[1].concat(f));for(c=f.length;!f[--c];);for(g=0,e="";g<=c;e+=a.charAt(f[g++]));e=H(e,u,a.charAt(0));}return e}}(),y=function(){function M(e,t,r){var n,i,a,o,u=0,c=e.length,s=t%I,l=t/I|0;for(e=e.slice();c--;)u=((i=s*(a=e[c]%I)+(n=l*a+(o=e[c]/I|0)*s)%I*I+u)/r|0)+(n/I|0)+l*o,e[c]=i%r;return u&&(e=[u].concat(e)),e}function B(e,t,r,n){var i,a;if(r!=n)a=nt[i]?1:-1;break}return a}function D(e,t,r,n){for(var i=0;r--;)e[r]-=i,i=e[r](S[u]||0)&&o--,x<0)g.push(1),c=!0;else {for(y=S.length,w=N.length,x+=2,1<(s=L(i/(N[u=0]+1)))&&(N=M(N,s,i),S=M(S,s,i),w=N.length,y=S.length),m=w,d=(h=S.slice(0,w)).length;d=i/2&&b++;do{if(s=0,(a=B(N,h,w,d))<0){if(v=h[0],w!=d&&(v=v*i+(h[1]||0)),1<(s=L(v/b)))for(i<=s&&(s=i-1),f=(l=M(N,s,i)).length,d=h.length;1==B(l,h,f,d);)s--,D(l,wa&&(s.c.length=a):n&&(s=s.mod(t));}if(i){if(0===(i=L(i/2)))break;c=i%2;}else if(E(e=e.times(r),e.e+1,1),14a&&(l.c.length=a):n&&(l=l.mod(t));}return n?s:(u&&(s=d.div(s)),t?s.mod(t):a?E(s,S,w,void 0):s)},n.integerValue=function(e){var t=new A(this);return null==e?e=w:Z(e,0,8),E(t,t.e+1,e)},n.isEqualTo=n.eq=function(e,t){return 0===q(this,new A(e,t))},n.isFinite=function(){return !!this.c},n.isGreaterThan=n.gt=function(e,t){return 0this.c.length-2},n.isLessThan=n.lt=function(e,t){return q(this,new A(e,t))<0},n.isLessThanOrEqualTo=n.lte=function(e,t){return -1===(t=q(this,new A(e,t)))||0===t},n.isNaN=function(){return !this.s},n.isNegative=function(){return this.s<0},n.isPositive=function(){return 0n&&(n=this.e+1),n},n.shiftedBy=function(e){return Z(e,-C,C),this.times("1e"+e)},n.squareRoot=n.sqrt=function(){var e,t,r,n,i,a=this,o=a.c,u=a.s,c=a.e,s=b+4,l=new A("0.5");if(1!==u||!o||!o[0])return new A(!u||u<0&&(!o||o[0])?NaN:o?a:1/0);if((r=0==(u=Math.sqrt(+F(a)))||u==1/0?(((t=V(o)).length+c)%2==0&&(t+="0"),u=Math.sqrt(+t),c=G((c+1)/2)-(c<0||c%2),new A(t=u==1/0?"1e"+c:(t=u.toExponential()).slice(0,t.indexOf("e")+1)+c)):new A(u+"")).c[0])for((u=(c=r.e)+s)<3&&(u=0);;)if(i=r,r=l.times(i.plus(y(a,i,s,1))),V(i.c).slice(0,u)===(t=V(r.c)).slice(0,u)){if(r.e=Math.pow(10,12)&&!r||"trillion"===r?(c=n.trillion,t/=Math.pow(10,12)):s=Math.pow(10,9)&&!r||"billion"===r?(c=n.billion,t/=Math.pow(10,9)):s=Math.pow(10,6)&&!r||"million"===r?(c=n.million,t/=Math.pow(10,6)):(s=Math.pow(10,3)&&!r||"thousand"===r)&&(c=n.thousand,t/=Math.pow(10,3)),c&&(c=(a?" ":"")+c),u){var f=t.toString().split(".")[0];l=Math.max(u-f.length,0);}return {value:t,abbreviation:c,mantissaPrecision:l}}({value:c,forceAverage:O,abbreviations:i.currentAbbreviations(),spaceSeparated:D,totalLength:y});c=_.value,k+=_.abbreviation,y&&(S=_.mantissaPrecision);}if(F){var L=(l=(s={value:c,characteristicPrecision:b}).value,f=s.characteristicPrecision,p=void 0===f?0:f,g=C(l.toExponential().split("e"),2),h=g[0],d=g[1],v=+h,p&&1 -1; + var date; + + if (dateFromDate.isValid() && dateFromDate.format('x') === dateFromMoment.format('x') || !dateFromMoment.isValid() || isAlphanumeric) { + date = dateFromDate; + } else { + date = dateFromMoment; + } + + return date.format(dateFormat); +} + +var VALIDATOR_TYPE$2 = 'numeric'; +/** + * The Numeric cell validator. + * + * @private + * @param {*} value Value of edited cell. + * @param {Function} callback Callback called with validation result. + */ + +function numericValidator(value, callback) { + var valueToValidate = value; + + if (valueToValidate === null || valueToValidate === void 0) { + valueToValidate = ''; + } + + if (this.allowEmpty && valueToValidate === '') { + callback(true); + } else if (valueToValidate === '') { + callback(false); + } else { + callback(isNumeric(value)); + } +} +numericValidator.VALIDATOR_TYPE = VALIDATOR_TYPE$2; + +var STRICT_FORMATS = ['YYYY-MM-DDTHH:mm:ss.SSSZ', 'X', // Unix timestamp +'x' // Unix ms timestamp +]; +var VALIDATOR_TYPE$3 = 'time'; +/** + * The Time cell validator. + * + * @private + * @param {*} value Value of edited cell. + * @param {Function} callback Callback called with validation result. + */ + +function timeValidator(value, callback) { + var timeFormat = this.timeFormat || 'h:mm:ss a'; + var valid = true; + var valueToValidate = value; + + if (valueToValidate === null) { + valueToValidate = ''; + } + + valueToValidate = /^\d{3,}$/.test(valueToValidate) ? parseInt(valueToValidate, 10) : valueToValidate; + var twoDigitValue = /^\d{1,2}$/.test(valueToValidate); + + if (twoDigitValue) { + valueToValidate += ':00'; + } + + var date = moment(valueToValidate, STRICT_FORMATS, true).isValid() ? moment(valueToValidate) : moment(valueToValidate, timeFormat); + var isValidTime = date.isValid(); // is it in the specified format + + var isValidFormat = moment(valueToValidate, timeFormat, true).isValid() && !twoDigitValue; + + if (this.allowEmpty && valueToValidate === '') { + isValidTime = true; + isValidFormat = true; + } + + if (!isValidTime) { + valid = false; + } + + if (!isValidTime && isValidFormat) { + valid = true; + } + + if (isValidTime && !isValidFormat) { + if (this.correctFormat === true) { + // if format correction is enabled + var correctedValue = date.format(timeFormat); + var row = this.instance.toVisualRow(this.row); + var column = this.instance.toVisualColumn(this.col); + this.instance.setDataAtCell(row, column, correctedValue, 'timeValidator'); + valid = true; + } else { + valid = false; + } + } + + callback(valid); +} +timeValidator.VALIDATOR_TYPE = VALIDATOR_TYPE$3; + +var CELL_TYPE$2 = 'autocomplete'; +var AutocompleteCellType = { + CELL_TYPE: CELL_TYPE$2, + editor: AutocompleteEditor, + renderer: autocompleteRenderer, + validator: autocompleteValidator +}; + +var CELL_TYPE$3 = 'checkbox'; +var CheckboxCellType = { + CELL_TYPE: CELL_TYPE$3, + editor: CheckboxEditor, + renderer: checkboxRenderer +}; + +var CELL_TYPE$4 = 'date'; +var DateCellType = { + CELL_TYPE: CELL_TYPE$4, + editor: DateEditor, + // displays small gray arrow on right side of the cell + renderer: autocompleteRenderer, + validator: dateValidator +}; + +var CELL_TYPE$5 = 'dropdown'; +var DropdownCellType = { + CELL_TYPE: CELL_TYPE$5, + editor: DropdownEditor, + // displays small gray arrow on right side of the cell + renderer: autocompleteRenderer, + validator: autocompleteValidator +}; + +var CELL_TYPE$6 = 'handsontable'; +var HandsontableCellType = { + CELL_TYPE: CELL_TYPE$6, + editor: HandsontableEditor, + // displays small gray arrow on right side of the cell + renderer: autocompleteRenderer +}; + +var CELL_TYPE$7 = 'numeric'; +var NumericCellType = { + CELL_TYPE: CELL_TYPE$7, + editor: NumericEditor, + renderer: numericRenderer, + validator: numericValidator, + dataType: 'number' +}; + +var CELL_TYPE$8 = 'password'; +var PasswordCellType = { + CELL_TYPE: CELL_TYPE$8, + editor: PasswordEditor, + renderer: passwordRenderer, + copyable: false +}; + +var CELL_TYPE$9 = 'time'; +var TimeCellType = { + CELL_TYPE: CELL_TYPE$9, + editor: TextEditor, + // displays small gray arrow on right side of the cell + renderer: textRenderer, + validator: timeValidator +}; + +function _slicedToArray$d(arr, i) { return _arrayWithHoles$d(arr) || _iterableToArrayLimit$d(arr, i) || _unsupportedIterableToArray$n(arr, i) || _nonIterableRest$d(); } + +function _nonIterableRest$d() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$n(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$n(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$n(o, minLen); } + +function _arrayLikeToArray$n(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$d(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$d(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$1f(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1a(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); } } + +function _createClass$1a(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1a(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1a(Constructor, staticProps); return Constructor; } +var DEPS_TYPE_CHECKERS = new Map([['plugin', hasPlugin], ['cell-type', hasItem$3], ['editor', hasItem], ['renderer', hasItem$1], ['validator', hasItem$2]]); +var PLUGIN_KEY = 'base'; +var privatePool$5 = new WeakMap(); +var missingDependeciesMsgs = []; +var initializedPlugins = null; +/** + * @util + */ + +var BasePlugin = /*#__PURE__*/function () { + /** + * @param {object} hotInstance Handsontable instance. + */ + function BasePlugin(hotInstance) { + var _this = this; + + _classCallCheck$1f(this, BasePlugin); + + /** + * Handsontable instance. + * + * @type {Core} + */ + defineGetter(this, 'hot', hotInstance, { + writable: false + }); + privatePool$5.set(this, { + hooks: {} + }); + initializedPlugins = null; + this.pluginName = null; + this.pluginsInitializedCallbacks = []; + this.isPluginsReady = false; + this.enabled = false; + this.initialized = false; + this.hot.addHook('afterPluginsInitialized', function () { + return _this.onAfterPluginsInitialized(); + }); + this.hot.addHook('afterUpdateSettings', function (newSettings) { + return _this.onUpdateSettings(newSettings); + }); + this.hot.addHook('beforeInit', function () { + return _this.init(); + }); + } + + _createClass$1a(BasePlugin, [{ + key: "init", + value: function init() { + var _this2 = this; + + this.pluginName = this.hot.getPluginName(this); + var pluginDeps = this.constructor.PLUGIN_DEPS; + var dependecies = Array.isArray(pluginDeps) ? pluginDeps : []; + + if (dependecies.length > 0) { + var missingDependencies = []; + dependecies.forEach(function (dependency) { + var _dependency$split = dependency.split(':'), + _dependency$split2 = _slicedToArray$d(_dependency$split, 2), + type = _dependency$split2[0], + moduleName = _dependency$split2[1]; + + if (!DEPS_TYPE_CHECKERS.has(type)) { + throw new Error("Unknown plugin dependency type \"".concat(type, "\" was found.")); + } + + if (!DEPS_TYPE_CHECKERS.get(type)(moduleName)) { + missingDependencies.push(" - ".concat(moduleName, " (").concat(type, ")")); + } + }); + + if (missingDependencies.length > 0) { + var errorMsg = ["The ".concat(this.pluginName, " plugin requires the following modules:\n"), "".concat(missingDependencies.join('\n'), "\n")].join(''); + missingDependeciesMsgs.push(errorMsg); + } + } + + if (!initializedPlugins) { + initializedPlugins = getPluginsNames(); + } // Workaround for the UndoRedo plugin which, currently doesn't follow the plugin architecture. + // Without this line the `callOnPluginsReady` callback won't be triggered after all plugin + // initialization. + + + if (initializedPlugins.indexOf('UndoRedo') >= 0) { + initializedPlugins.splice(initializedPlugins.indexOf('UndoRedo'), 1); + } + + if (initializedPlugins.indexOf(this.pluginName) >= 0) { + initializedPlugins.splice(initializedPlugins.indexOf(this.pluginName), 1); + } + + this.hot.addHookOnce('afterPluginsInitialized', function () { + if (_this2.isEnabled && _this2.isEnabled()) { + _this2.enablePlugin(); + } + }); + var isAllPluginsAreInitialized = initializedPlugins.length === 0; + + if (isAllPluginsAreInitialized) { + if (missingDependeciesMsgs.length > 0) { + var _errorMsg = ["".concat(missingDependeciesMsgs.join('\n'), "\n"), 'You have to import and register them manually.'].join(''); + + throw new Error(_errorMsg); + } + + this.hot.runHooks('afterPluginsInitialized'); + } + + this.initialized = true; + } + /** + * Enable plugin for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + this.enabled = true; + } + /** + * Disable plugin for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + if (this.eventManager) { + this.eventManager.clear(); + } + + this.clearHooks(); + this.enabled = false; + } + /** + * Add listener to plugin hooks system. + * + * @param {string} name The hook name. + * @param {Function} callback The listener function to add. + */ + + }, { + key: "addHook", + value: function addHook(name, callback) { + privatePool$5.get(this).hooks[name] = privatePool$5.get(this).hooks[name] || []; + var hooks = privatePool$5.get(this).hooks[name]; + this.hot.addHook(name, callback); + hooks.push(callback); + privatePool$5.get(this).hooks[name] = hooks; + } + /** + * Remove all hooks listeners by hook name. + * + * @param {string} name The hook name. + */ + + }, { + key: "removeHooks", + value: function removeHooks(name) { + var _this3 = this; + + arrayEach(privatePool$5.get(this).hooks[name] || [], function (callback) { + _this3.hot.removeHook(name, callback); + }); + } + /** + * Clear all hooks. + */ + + }, { + key: "clearHooks", + value: function clearHooks() { + var _this4 = this; + + var hooks = privatePool$5.get(this).hooks; + objectEach(hooks, function (callbacks, name) { + return _this4.removeHooks(name); + }); + hooks.length = 0; + } + /** + * Register function which will be immediately called after all plugins initialized. + * + * @param {Function} callback The listener function to call. + */ + + }, { + key: "callOnPluginsReady", + value: function callOnPluginsReady(callback) { + if (this.isPluginsReady) { + callback(); + } else { + this.pluginsInitializedCallbacks.push(callback); + } + } + /** + * On after plugins initialized listener. + * + * @private + */ + + }, { + key: "onAfterPluginsInitialized", + value: function onAfterPluginsInitialized() { + arrayEach(this.pluginsInitializedCallbacks, function (callback) { + return callback(); + }); + this.pluginsInitializedCallbacks.length = 0; + this.isPluginsReady = true; + } + /** + * On update settings listener. + * + * @private + */ + + }, { + key: "onUpdateSettings", + value: function onUpdateSettings() { + if (this.isEnabled) { + if (this.enabled && !this.isEnabled()) { + this.disablePlugin(); + } + + if (!this.enabled && this.isEnabled()) { + this.enablePlugin(); + } + + if (this.enabled && this.isEnabled()) { + this.updatePlugin(); + } + } + } + /** + * Updates the plugin to use the latest options you have specified. + * + * @private + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() {} + /** + * Destroy plugin. + */ + + }, { + key: "destroy", + value: function destroy() { + var _this5 = this; + + if (this.eventManager) { + this.eventManager.destroy(); + } + + this.clearHooks(); + objectEach(this, function (value, property) { + if (property !== 'hot') { + _this5[property] = null; + } + }); + delete this.t; + delete this.hot; + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY; + } + }]); + + return BasePlugin; +}(); + +function _classCallCheck$1g(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1b(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); } } + +function _createClass$1b(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1b(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1b(Constructor, staticProps); return Constructor; } +/** + * @class Storage + * @plugin PersistentState + */ + +var Storage = /*#__PURE__*/function () { + // eslint-disable-next-line no-restricted-globals + function Storage(prefix) { + var rootWindow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window; + + _classCallCheck$1g(this, Storage); + + /** + * Reference to proper window. + * + * @type {Window} + */ + this.rootWindow = rootWindow; + /** + * Prefix for key (id element). + * + * @type {string} + */ + + this.prefix = prefix; + /** + * Saved keys. + * + * @type {Array} + */ + + this.savedKeys = []; + this.loadSavedKeys(); + } + /** + * Save data to localStorage. + * + * @param {string} key Key string. + * @param {Mixed} value Value to save. + */ + + + _createClass$1b(Storage, [{ + key: "saveValue", + value: function saveValue(key, value) { + this.rootWindow.localStorage.setItem("".concat(this.prefix, "_").concat(key), JSON.stringify(value)); + + if (this.savedKeys.indexOf(key) === -1) { + this.savedKeys.push(key); + this.saveSavedKeys(); + } + } + /** + * Load data from localStorage. + * + * @param {string} key Key string. + * @param {object} defaultValue Object containing the loaded data. + * + * @returns {object|undefined} + */ + + }, { + key: "loadValue", + value: function loadValue(key, defaultValue) { + var itemKey = typeof key === 'undefined' ? defaultValue : key; + var value = this.rootWindow.localStorage.getItem("".concat(this.prefix, "_").concat(itemKey)); + return value === null ? void 0 : JSON.parse(value); + } + /** + * Reset given data from localStorage. + * + * @param {string} key Key string. + */ + + }, { + key: "reset", + value: function reset(key) { + this.rootWindow.localStorage.removeItem("".concat(this.prefix, "_").concat(key)); + } + /** + * Reset all data from localStorage. + * + */ + + }, { + key: "resetAll", + value: function resetAll() { + var _this = this; + + arrayEach(this.savedKeys, function (value, index) { + _this.rootWindow.localStorage.removeItem("".concat(_this.prefix, "_").concat(_this.savedKeys[index])); + }); + this.clearSavedKeys(); + } + /** + * Load and save all keys from localStorage. + * + * @private + */ + + }, { + key: "loadSavedKeys", + value: function loadSavedKeys() { + var keysJSON = this.rootWindow.localStorage.getItem("".concat(this.prefix, "__persistentStateKeys")); + var keys = typeof keysJSON === 'string' ? JSON.parse(keysJSON) : void 0; + this.savedKeys = keys || []; + } + /** + * Save saved key in localStorage. + * + * @private + */ + + }, { + key: "saveSavedKeys", + value: function saveSavedKeys() { + this.rootWindow.localStorage.setItem("".concat(this.prefix, "__persistentStateKeys"), JSON.stringify(this.savedKeys)); + } + /** + * Clear saved key from localStorage. + * + * @private + */ + + }, { + key: "clearSavedKeys", + value: function clearSavedKeys() { + this.savedKeys.length = 0; + this.saveSavedKeys(); + } + }]); + + return Storage; +}(); + +function _typeof$J(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$J = function _typeof(obj) { return typeof obj; }; } else { _typeof$J = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$J(obj); } + +function _classCallCheck$1h(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1c(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); } } + +function _createClass$1c(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1c(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1c(Constructor, staticProps); return Constructor; } + +function _get$b(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$b = Reflect.get; } else { _get$b = function _get(target, property, receiver) { var base = _superPropBase$b(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$b(target, property, receiver || target); } + +function _superPropBase$b(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$y(object); if (object === null) break; } return object; } + +function _inherits$y(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$z(subClass, superClass); } + +function _setPrototypeOf$z(o, p) { _setPrototypeOf$z = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$z(o, p); } + +function _createSuper$y(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$z(); return function _createSuperInternal() { var Super = _getPrototypeOf$y(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$y(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$y(this, result); }; } + +function _possibleConstructorReturn$y(self, call) { if (call && (_typeof$J(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$y(self); } + +function _assertThisInitialized$y(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$z() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$y(o) { _getPrototypeOf$y = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$y(o); } +Hooks.getSingleton().register('persistentStateSave'); +Hooks.getSingleton().register('persistentStateLoad'); +Hooks.getSingleton().register('persistentStateReset'); +var PLUGIN_KEY$1 = 'persistentState'; +var PLUGIN_PRIORITY = 0; +/** + * @plugin PersistentState + * + * @description + * Save the state of column sorting, column positions and column sizes in local storage to preserve table state + * between page reloads. + * + * In order to enable data storage mechanism, {@link Options#persistentState} option must be set to `true`. + * + * When persistentState is enabled it exposes 3 hooks: + * - {@link Hooks#persistentStateSave} - Saves value under given key in browser local storage. + * - {@link Hooks#persistentStateLoad} - Loads value, saved under given key, from browser local storage. The loaded + * value will be saved in `saveTo.value`. + * - {@link Hooks#persistentStateReset} - Clears the value saved under key. If no key is given, all values associated + * with table will be cleared. + */ + +var PersistentState = /*#__PURE__*/function (_BasePlugin) { + _inherits$y(PersistentState, _BasePlugin); + + var _super = _createSuper$y(PersistentState); + + function PersistentState(hotInstance) { + var _this; + + _classCallCheck$1h(this, PersistentState); + + _this = _super.call(this, hotInstance); + /** + * Instance of {@link Storage}. + * + * @private + * @type {Storage} + */ + + _this.storage = void 0; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link PersistentState#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1c(PersistentState, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$1]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + if (!this.storage) { + this.storage = new Storage(this.hot.rootElement.id, this.hot.rootWindow); + } + + this.addHook('persistentStateSave', function (key, value) { + return _this2.saveValue(key, value); + }); + this.addHook('persistentStateLoad', function (key, saveTo) { + return _this2.loadValue(key, saveTo); + }); + this.addHook('persistentStateReset', function () { + return _this2.resetValue(); + }); + + _get$b(_getPrototypeOf$y(PersistentState.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.storage = void 0; + + _get$b(_getPrototypeOf$y(PersistentState.prototype), "disablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$b(_getPrototypeOf$y(PersistentState.prototype), "updatePlugin", this).call(this); + } + /** + * Loads the value from local storage. + * + * @param {string} key Storage key. + * @param {object} saveTo Saved value from local storage. + */ + + }, { + key: "loadValue", + value: function loadValue(key, saveTo) { + saveTo.value = this.storage.loadValue(key); + } + /** + * Saves the data to local storage. + * + * @param {string} key Storage key. + * @param {Mixed} value Value to save. + */ + + }, { + key: "saveValue", + value: function saveValue(key, value) { + this.storage.saveValue(key, value); + } + /** + * Resets the data or all data from local storage. + * + * @param {string} key [optional] Storage key. + */ + + }, { + key: "resetValue", + value: function resetValue(key) { + if (typeof key === 'undefined') { + this.storage.resetAll(); + } else { + this.storage.reset(key); + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + _get$b(_getPrototypeOf$y(PersistentState.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$1; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY; + } + }]); + + return PersistentState; +}(BasePlugin); + +function _defineProperty$d(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck$1i(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1d(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); } } + +function _createClass$1d(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1d(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1d(Constructor, staticProps); return Constructor; } +/** + * @class SamplesGenerator + * @util + */ + +var SamplesGenerator = /*#__PURE__*/function () { + function SamplesGenerator(dataFactory) { + _classCallCheck$1i(this, SamplesGenerator); + + /** + * Samples prepared for calculations. + * + * @type {Map} + * @default {null} + */ + this.samples = null; + /** + * Function which give the data to collect samples. + * + * @type {Function} + */ + + this.dataFactory = dataFactory; + /** + * Custom number of samples to take of each value length. + * + * @type {number} + * @default {null} + */ + + this.customSampleCount = null; + /** + * `true` if duplicate samples collection should be allowed, `false` otherwise. + * + * @type {boolean} + * @default {false} + */ + + this.allowDuplicates = false; + } + /** + * Get the sample count for this instance. + * + * @returns {number} + */ + + + _createClass$1d(SamplesGenerator, [{ + key: "getSampleCount", + value: function getSampleCount() { + if (this.customSampleCount) { + return this.customSampleCount; + } + + return SamplesGenerator.SAMPLE_COUNT; + } + /** + * Set the sample count. + * + * @param {number} sampleCount Number of samples to be collected. + */ + + }, { + key: "setSampleCount", + value: function setSampleCount(sampleCount) { + this.customSampleCount = sampleCount; + } + /** + * Set if the generator should accept duplicate values. + * + * @param {boolean} allowDuplicates `true` to allow duplicate values. + */ + + }, { + key: "setAllowDuplicates", + value: function setAllowDuplicates(allowDuplicates) { + this.allowDuplicates = allowDuplicates; + } + /** + * Generate samples for row. You can control which area should be sampled by passing `rowRange` object and `colRange` object. + * + * @param {object|number} rowRange The rows range to generate the samples. + * @param {object} colRange The column range to generate the samples. + * @returns {object} + */ + + }, { + key: "generateRowSamples", + value: function generateRowSamples(rowRange, colRange) { + return this.generateSamples('row', colRange, rowRange); + } + /** + * Generate samples for column. You can control which area should be sampled by passing `colRange` object and `rowRange` object. + * + * @param {object} colRange Column index. + * @param {object} rowRange Column index. + * @returns {object} + */ + + }, { + key: "generateColumnSamples", + value: function generateColumnSamples(colRange, rowRange) { + return this.generateSamples('col', rowRange, colRange); + } + /** + * Generate collection of samples. + * + * @param {string} type Type to generate. Can be `col` or `row`. + * @param {object} range The range to generate the samples. + * @param {object|number} specifierRange The range to generate the samples. + * @returns {Map} + */ + + }, { + key: "generateSamples", + value: function generateSamples(type, range, specifierRange) { + var _this = this; + + var samples = new Map(); + + var _ref = typeof specifierRange === 'number' ? { + from: specifierRange, + to: specifierRange + } : specifierRange, + from = _ref.from, + to = _ref.to; + + rangeEach(from, to, function (index) { + var sample = _this.generateSample(type, range, index); + + samples.set(index, sample); + }); + return samples; + } + /** + * Generate sample for specified type (`row` or `col`). + * + * @param {string} type Samples type `row` or `col`. + * @param {object} range The range to generate the samples. + * @param {number} specifierValue The range to generate the samples. + * @returns {Map} + */ + + }, { + key: "generateSample", + value: function generateSample(type, range, specifierValue) { + var _this2 = this; + + if (type !== 'row' && type !== 'col') { + throw new Error('Unsupported sample type'); + } + + var samples = new Map(); + var computedKey = type === 'row' ? 'col' : 'row'; + var sampledValues = []; + rangeEach(range.from, range.to, function (index) { + var _ref2 = type === 'row' ? _this2.dataFactory(specifierValue, index) : _this2.dataFactory(index, specifierValue), + value = _ref2.value, + bundleCountSeed = _ref2.bundleCountSeed; + + var hasCustomBundleSeed = bundleCountSeed > 0; + var length; + + if (isObject$1(value)) { + length = Object.keys(value).length; + } else if (Array.isArray(value)) { + length = value.length; + } else { + length = stringify(value).length; + } + + if (hasCustomBundleSeed) { + length += bundleCountSeed; + } + + if (!samples.has(length)) { + samples.set(length, { + needed: _this2.getSampleCount(), + strings: [] + }); + } + + var sample = samples.get(length); + + if (sample.needed) { + var duplicate = sampledValues.indexOf(value) > -1; + + if (!duplicate || _this2.allowDuplicates || hasCustomBundleSeed) { + sample.strings.push(_defineProperty$d({ + value: value + }, computedKey, index)); + sampledValues.push(value); + sample.needed -= 1; + } + } + }); + return samples; + } + }], [{ + key: "SAMPLE_COUNT", + get: + /** + * Number of samples to take of each value length. + * + * @type {number} + */ + function get() { + return 3; + } + }]); + + return SamplesGenerator; +}(); + +function _typeof$K(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$K = function _typeof(obj) { return typeof obj; }; } else { _typeof$K = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$K(obj); } + +function _slicedToArray$e(arr, i) { return _arrayWithHoles$e(arr) || _iterableToArrayLimit$e(arr, i) || _unsupportedIterableToArray$o(arr, i) || _nonIterableRest$e(); } + +function _nonIterableRest$e() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$o(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$o(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$o(o, minLen); } + +function _arrayLikeToArray$o(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$e(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$e(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$1j(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1e(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); } } + +function _createClass$1e(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1e(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1e(Constructor, staticProps); return Constructor; } + +function _get$c(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$c = Reflect.get; } else { _get$c = function _get(target, property, receiver) { var base = _superPropBase$c(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$c(target, property, receiver || target); } + +function _superPropBase$c(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$z(object); if (object === null) break; } return object; } + +function _inherits$z(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$A(subClass, superClass); } + +function _setPrototypeOf$A(o, p) { _setPrototypeOf$A = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$A(o, p); } + +function _createSuper$z(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$A(); return function _createSuperInternal() { var Super = _getPrototypeOf$z(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$z(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$z(this, result); }; } + +function _possibleConstructorReturn$z(self, call) { if (call && (_typeof$K(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$z(self); } + +function _assertThisInitialized$z(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$A() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$z(o) { _getPrototypeOf$z = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$z(o); } +var PLUGIN_KEY$2 = 'autoColumnSize'; +var PLUGIN_PRIORITY$1 = 10; +var privatePool$6 = new WeakMap(); +var COLUMN_SIZE_MAP_NAME = 'autoColumnSize'; +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @plugin AutoColumnSize + * @class AutoColumnSize + * + * @description + * This plugin allows to set column widths based on their widest cells. + * + * By default, the plugin is declared as `undefined`, which makes it enabled (same as if it was declared as `true`). + * Enabling this plugin may decrease the overall table performance, as it needs to calculate the widths of all cells to + * resize the columns accordingly. + * If you experience problems with the performance, try turning this feature off and declaring the column widths manually. + * + * Column width calculations are divided into sync and async part. Each of this parts has their own advantages and + * disadvantages. Synchronous calculations are faster but they block the browser UI, while the slower asynchronous + * operations don't block the browser UI. + * + * To configure the sync/async distribution, you can pass an absolute value (number of columns) or a percentage value to a config object: + * ```js + * // as a number (300 columns in sync, rest async) + * autoColumnSize: {syncLimit: 300},. + * + * // as a string (percent) + * autoColumnSize: {syncLimit: '40%'}, + * ``` + * + * To configure this plugin see {@link Options#autoColumnSize}. + * + * @example + * ```js + * const hot = new Handsontable(document.getElementById('example'), { + * data: getData(), + * autoColumnSize: true + * }); + * // Access to plugin instance: + * const plugin = hot.getPlugin('autoColumnSize'); + * + * plugin.getColumnWidth(4); + * + * if (plugin.isEnabled()) { + * // code... + * } + * ``` + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var AutoColumnSize = /*#__PURE__*/function (_BasePlugin) { + _inherits$z(AutoColumnSize, _BasePlugin); + + var _super = _createSuper$z(AutoColumnSize); + + function AutoColumnSize(hotInstance) { + var _this; + + _classCallCheck$1j(this, AutoColumnSize); + + _this = _super.call(this, hotInstance); + privatePool$6.set(_assertThisInitialized$z(_this), { + /** + * Cached column header names. It is used to diff current column headers with previous state and detect which + * columns width should be updated. + * + * @private + * @type {Array} + */ + cachedColumnHeaders: [] + }); + /** + * Instance of {@link GhostTable} for rows and columns size calculations. + * + * @private + * @type {GhostTable} + */ + + _this.ghostTable = new GhostTable(_this.hot); + /** + * Instance of {@link SamplesGenerator} for generating samples necessary for columns width calculations. + * + * @private + * @type {SamplesGenerator} + */ + + _this.samplesGenerator = new SamplesGenerator(function (row, column) { + var cellMeta = _this.hot.getCellMeta(row, column); + + var cellValue = ''; + + if (!cellMeta.spanned) { + cellValue = _this.hot.getDataAtCell(row, column); + } + + var bundleCountSeed = 0; + + if (cellMeta.label) { + var _cellMeta$label = cellMeta.label, + labelValue = _cellMeta$label.value, + labelProperty = _cellMeta$label.property; + var labelText = ''; + + if (labelValue) { + labelText = typeof labelValue === 'function' ? labelValue(row, column, _this.hot.colToProp(column), cellValue) : labelValue; + } else if (labelProperty) { + var labelData = _this.hot.getDataAtRowProp(row, labelProperty); + + labelText = labelData !== null ? labelData : ''; + } + + bundleCountSeed = labelText.length; + } + + return { + value: cellValue, + bundleCountSeed: bundleCountSeed + }; + }); + /** + * `true` only if the first calculation was performed. + * + * @private + * @type {boolean} + */ + + _this.firstCalculation = true; + /** + * `true` if the size calculation is in progress. + * + * @type {boolean} + */ + + _this.inProgress = false; + /** + * Number of already measured columns (we already know their sizes). + * + * @type {number} + */ + + _this.measuredColumns = 0; + /** + * PhysicalIndexToValueMap to keep and track widths for physical column indexes. + * + * @private + * @type {PhysicalIndexToValueMap} + */ + + _this.columnWidthsMap = new PhysicalIndexToValueMap(); + + _this.hot.columnIndexMapper.registerMap(COLUMN_SIZE_MAP_NAME, _this.columnWidthsMap); // Leave the listener active to allow auto-sizing the columns when the plugin is disabled. + // This is necesseary for width recalculation for resize handler doubleclick (ManualColumnResize). + + + _this.addHook('beforeColumnResize', function (size, column, isDblClick) { + return _this.onBeforeColumnResize(size, column, isDblClick); + }); + + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link AutoColumnSize#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1e(AutoColumnSize, [{ + key: "isEnabled", + value: function isEnabled() { + return this.hot.getSettings()[PLUGIN_KEY$2] !== false && !this.hot.getSettings().colWidths; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var setting = this.hot.getSettings()[PLUGIN_KEY$2]; + + if (setting && setting.useHeaders !== null && setting.useHeaders !== void 0) { + this.ghostTable.setSetting('useHeaders', setting.useHeaders); + } + + this.setSamplingOptions(); + this.addHook('afterLoadData', function () { + return _this2.onAfterLoadData(); + }); + this.addHook('beforeChange', function (changes) { + return _this2.onBeforeChange(changes); + }); + this.addHook('beforeRender', function (force) { + return _this2.onBeforeRender(force); + }); + this.addHook('modifyColWidth', function (width, col) { + return _this2.getColumnWidth(col, width); + }); + this.addHook('afterInit', function () { + return _this2.onAfterInit(); + }); + + _get$c(_getPrototypeOf$z(AutoColumnSize.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + var changedColumns = this.findColumnsWhereHeaderWasChanged(); + + if (changedColumns.length) { + this.clearCache(changedColumns); + this.calculateVisibleColumnsWidth(); + } + + _get$c(_getPrototypeOf$z(AutoColumnSize.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + var _this3 = this; + + _get$c(_getPrototypeOf$z(AutoColumnSize.prototype), "disablePlugin", this).call(this); // Leave the listener active to allow auto-sizing the columns when the plugin is disabled. + // This is necesseary for width recalculation for resize handler doubleclick (ManualColumnResize). + + + this.addHook('beforeColumnResize', function (size, column, isDblClick) { + return _this3.onBeforeColumnResize(size, column, isDblClick); + }); + } + /** + * Calculates visible columns width. + */ + + }, { + key: "calculateVisibleColumnsWidth", + value: function calculateVisibleColumnsWidth() { + var rowsCount = this.hot.countRows(); // Keep last column widths unchanged for situation when all rows was deleted or trimmed (pro #6) + + if (!rowsCount) { + return; + } + + var force = this.hot.renderCall; + var firstVisibleColumn = this.getFirstVisibleColumn(); + var lastVisibleColumn = this.getLastVisibleColumn(); + + if (firstVisibleColumn === -1 || lastVisibleColumn === -1) { + return; + } + + this.calculateColumnsWidth({ + from: firstVisibleColumn, + to: lastVisibleColumn + }, void 0, force); + } + /** + * Calculates a columns width. + * + * @param {number|object} colRange Visual column index or an object with `from` and `to` visual indexes as a range. + * @param {number|object} rowRange Visual row index or an object with `from` and `to` visual indexes as a range. + * @param {boolean} [force=false] If `true` the calculation will be processed regardless of whether the width exists in the cache. + */ + + }, { + key: "calculateColumnsWidth", + value: function calculateColumnsWidth() { + var _this4 = this; + + var colRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { + from: 0, + to: this.hot.countCols() - 1 + }; + var rowRange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { + from: 0, + to: this.hot.countRows() - 1 + }; + var force = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + // eslint-disable-line max-len + var columnsRange = typeof colRange === 'number' ? { + from: colRange, + to: colRange + } : colRange; + var rowsRange = typeof rowRange === 'number' ? { + from: rowRange, + to: rowRange + } : rowRange; + rangeEach(columnsRange.from, columnsRange.to, function (visualColumn) { + var physicalColumn = _this4.hot.toPhysicalColumn(visualColumn); + + if (physicalColumn === null) { + physicalColumn = visualColumn; + } + + if (force || _this4.columnWidthsMap.getValueAtIndex(physicalColumn) === null && !_this4.hot._getColWidthFromSettings(physicalColumn)) { + var samples = _this4.samplesGenerator.generateColumnSamples(visualColumn, rowsRange); + + arrayEach(samples, function (_ref) { + var _ref2 = _slicedToArray$e(_ref, 2), + column = _ref2[0], + sample = _ref2[1]; + + return _this4.ghostTable.addColumn(column, sample); + }); + } + }); + + if (this.ghostTable.columns.length) { + this.hot.batchExecution(function () { + _this4.ghostTable.getWidths(function (visualColumn, width) { + var physicalColumn = _this4.hot.toPhysicalColumn(visualColumn); + + _this4.columnWidthsMap.setValueAtIndex(physicalColumn, width); + }); + }, true); + this.measuredColumns = columnsRange.to + 1; + this.ghostTable.clean(); + } + } + /** + * Calculates all columns width. The calculated column will be cached in the {@link AutoColumnSize#widths} property. + * To retrieve width for specified column use {@link AutoColumnSize#getColumnWidth} method. + * + * @param {object|number} rowRange Row index or an object with `from` and `to` properties which define row range. + */ + + }, { + key: "calculateAllColumnsWidth", + value: function calculateAllColumnsWidth() { + var _this5 = this; + + var rowRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { + from: 0, + to: this.hot.countRows() - 1 + }; + var current = 0; + var length = this.hot.countCols() - 1; + var timer = null; + this.inProgress = true; + + var loop = function loop() { + // When hot was destroyed after calculating finished cancel frame + if (!_this5.hot) { + cancelAnimationFrame(timer); + _this5.inProgress = false; + return; + } + + _this5.calculateColumnsWidth({ + from: current, + to: Math.min(current + AutoColumnSize.CALCULATION_STEP, length) + }, rowRange); + + current = current + AutoColumnSize.CALCULATION_STEP + 1; + + if (current < length) { + timer = requestAnimationFrame(loop); + } else { + cancelAnimationFrame(timer); + _this5.inProgress = false; // @TODO Should call once per render cycle, currently fired separately in different plugins + + _this5.hot.view.adjustElementsSize(); + } + }; + + var syncLimit = this.getSyncCalculationLimit(); // sync + + if (this.firstCalculation && syncLimit >= 0) { + this.calculateColumnsWidth({ + from: 0, + to: syncLimit + }, rowRange); + this.firstCalculation = false; + current = syncLimit + 1; + } // async + + + if (current < length) { + loop(); + } else { + this.inProgress = false; + } + } + /** + * Sets the sampling options. + * + * @private + */ + + }, { + key: "setSamplingOptions", + value: function setSamplingOptions() { + var setting = this.hot.getSettings()[PLUGIN_KEY$2]; + var samplingRatio = setting && hasOwnProperty$1(setting, 'samplingRatio') ? setting.samplingRatio : void 0; + var allowSampleDuplicates = setting && hasOwnProperty$1(setting, 'allowSampleDuplicates') ? setting.allowSampleDuplicates : void 0; + + if (samplingRatio && !isNaN(samplingRatio)) { + this.samplesGenerator.setSampleCount(parseInt(samplingRatio, 10)); + } + + if (allowSampleDuplicates) { + this.samplesGenerator.setAllowDuplicates(allowSampleDuplicates); + } + } + /** + * Recalculates all columns width (overwrite cache values). + */ + + }, { + key: "recalculateAllColumnsWidth", + value: function recalculateAllColumnsWidth() { + if (this.hot.view && this.hot.view.wt.wtTable.isVisible()) { + this.clearCache(); + this.calculateAllColumnsWidth(); + } + } + /** + * Gets value which tells how many columns should be calculated synchronously (rest of the columns will be calculated + * asynchronously). The limit is calculated based on `syncLimit` set to `autoColumnSize` option (see {@link Options#autoColumnSize}). + * + * @returns {number} + */ + + }, { + key: "getSyncCalculationLimit", + value: function getSyncCalculationLimit() { + var settings = this.hot.getSettings()[PLUGIN_KEY$2]; + /* eslint-disable no-bitwise */ + + var limit = AutoColumnSize.SYNC_CALCULATION_LIMIT; + var colsLimit = this.hot.countCols() - 1; + + if (isObject$1(settings)) { + limit = settings.syncLimit; + + if (isPercentValue(limit)) { + limit = valueAccordingPercent(colsLimit, limit); + } else { + // Force to Number + limit >>= 0; + } + } + + return Math.min(limit, colsLimit); + } + /** + * Gets the calculated column width. + * + * @param {number} column Visual column index. + * @param {number} [defaultWidth] Default column width. It will be picked up if no calculated width found. + * @param {boolean} [keepMinimum=true] If `true` then returned value won't be smaller then 50 (default column width). + * @returns {number} + */ + + }, { + key: "getColumnWidth", + value: function getColumnWidth(column) { + var defaultWidth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : void 0; + var keepMinimum = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var width = defaultWidth; + + if (width === void 0) { + width = this.columnWidthsMap.getValueAtIndex(this.hot.toPhysicalColumn(column)); + + if (keepMinimum && typeof width === 'number') { + width = Math.max(width, ViewportColumnsCalculator.DEFAULT_WIDTH); + } + } + + return width; + } + /** + * Gets the first visible column. + * + * @returns {number} Returns visual column index, -1 if table is not rendered or if there are no columns to base the the calculations on. + */ + + }, { + key: "getFirstVisibleColumn", + value: function getFirstVisibleColumn() { + var wot = this.hot.view.wt; + + if (wot.wtViewport.columnsVisibleCalculator) { + // Fist fully visible column is stored as renderable index. + var firstFullyVisibleColumn = wot.wtTable.getFirstVisibleColumn(); + + if (firstFullyVisibleColumn !== -1) { + return this.hot.columnIndexMapper.getVisualFromRenderableIndex(firstFullyVisibleColumn); + } + } + + if (wot.wtViewport.columnsRenderCalculator) { + var firstRenderedColumn = wot.wtTable.getFirstRenderedColumn(); // There are no rendered column. + + if (firstRenderedColumn !== -1) { + return this.hot.columnIndexMapper.getVisualFromRenderableIndex(firstRenderedColumn); + } + } + + return -1; + } + /** + * Gets the last visible column. + * + * @returns {number} Returns visual column index or -1 if table is not rendered. + */ + + }, { + key: "getLastVisibleColumn", + value: function getLastVisibleColumn() { + var wot = this.hot.view.wt; + + if (wot.wtViewport.columnsVisibleCalculator) { + // Last fully visible column is stored as renderable index. + var lastFullyVisibleColumn = wot.wtTable.getLastVisibleColumn(); + + if (lastFullyVisibleColumn !== -1) { + return this.hot.columnIndexMapper.getVisualFromRenderableIndex(lastFullyVisibleColumn); + } + } + + if (wot.wtViewport.columnsRenderCalculator) { + // Last fully visible column is stored as renderable index. + var lastRenderedColumn = wot.wtTable.getLastRenderedColumn(); // There are no rendered columns. + + if (lastRenderedColumn !== -1) { + return this.hot.columnIndexMapper.getVisualFromRenderableIndex(lastRenderedColumn); + } + } + + return -1; + } + /** + * Collects all columns which titles has been changed in comparison to the previous state. + * + * @private + * @returns {Array} It returns an array of physical column indexes. + */ + + }, { + key: "findColumnsWhereHeaderWasChanged", + value: function findColumnsWhereHeaderWasChanged() { + var columnHeaders = this.hot.getColHeader(); + + var _privatePool$get = privatePool$6.get(this), + cachedColumnHeaders = _privatePool$get.cachedColumnHeaders; + + var changedColumns = arrayReduce(columnHeaders, function (acc, columnTitle, physicalColumn) { + var cachedColumnsLength = cachedColumnHeaders.length; + + if (cachedColumnsLength - 1 < physicalColumn || cachedColumnHeaders[physicalColumn] !== columnTitle) { + acc.push(physicalColumn); + } + + if (cachedColumnsLength - 1 < physicalColumn) { + cachedColumnHeaders.push(columnTitle); + } else { + cachedColumnHeaders[physicalColumn] = columnTitle; + } + + return acc; + }, []); + return changedColumns; + } + /** + * Clears cache of calculated column widths. If you want to clear only selected columns pass an array with their indexes. + * Otherwise whole cache will be cleared. + * + * @param {number[]} [columns] List of physical column indexes to clear. + */ + + }, { + key: "clearCache", + value: function clearCache() { + var _this6 = this; + + var columns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + + if (columns.length) { + this.hot.batchExecution(function () { + arrayEach(columns, function (physicalIndex) { + _this6.columnWidthsMap.setValueAtIndex(physicalIndex, null); + }); + }, true); + } else { + this.columnWidthsMap.clear(); + } + } + /** + * Checks if all widths were calculated. If not then return `true` (need recalculate). + * + * @returns {boolean} + */ + + }, { + key: "isNeedRecalculate", + value: function isNeedRecalculate() { + return !!arrayFilter(this.columnWidthsMap.getValues().slice(0, this.measuredColumns), function (item) { + return item === null; + }).length; + } + /** + * On before render listener. + * + * @private + */ + + }, { + key: "onBeforeRender", + value: function onBeforeRender() { + this.calculateVisibleColumnsWidth(); + + if (this.isNeedRecalculate() && !this.inProgress) { + this.calculateAllColumnsWidth(); + } + } + /** + * On after load data listener. + * + * @private + */ + + }, { + key: "onAfterLoadData", + value: function onAfterLoadData() { + var _this7 = this; + + if (this.hot.view) { + this.recalculateAllColumnsWidth(); + } else { + // first load - initialization + setTimeout(function () { + if (_this7.hot) { + _this7.recalculateAllColumnsWidth(); + } + }, 0); + } + } + /** + * On before change listener. + * + * @private + * @param {Array} changes An array of modified data. + */ + + }, { + key: "onBeforeChange", + value: function onBeforeChange(changes) { + var _this8 = this; + + var changedColumns = arrayMap(changes, function (_ref3) { + var _ref4 = _slicedToArray$e(_ref3, 2), + columnProperty = _ref4[1]; + + return _this8.hot.toPhysicalColumn(_this8.hot.propToCol(columnProperty)); + }); + this.clearCache(Array.from(new Set(changedColumns))); + } + /** + * On before column resize listener. + * + * @private + * @param {number} size Calculated new column width. + * @param {number} column Visual index of the resized column. + * @param {boolean} isDblClick Flag that determines whether there was a double-click. + * @returns {number} + */ + + }, { + key: "onBeforeColumnResize", + value: function onBeforeColumnResize(size, column, isDblClick) { + var newSize = size; + + if (isDblClick) { + this.calculateColumnsWidth(column, void 0, true); + newSize = this.getColumnWidth(column, void 0, false); + } + + return newSize; + } + /** + * On after Handsontable init fill plugin with all necessary values. + * + * @private + */ + + }, { + key: "onAfterInit", + value: function onAfterInit() { + privatePool$6.get(this).cachedColumnHeaders = this.hot.getColHeader(); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.columnIndexMapper.unregisterMap(COLUMN_SIZE_MAP_NAME); + this.ghostTable.clean(); + + _get$c(_getPrototypeOf$z(AutoColumnSize.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$2; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$1; + } + }, { + key: "CALCULATION_STEP", + get: function get() { + return 50; + } + }, { + key: "SYNC_CALCULATION_LIMIT", + get: function get() { + return 50; + } + }]); + + return AutoColumnSize; +}(BasePlugin); + +var DIRECTIONS = { + horizontal: 'horizontal', + vertical: 'vertical' +}; +/** + * Get deltas array. + * + * @param {CellCoords} start The point in the grid where the selection starts. + * @param {CellCoords} end The point in the grid where the selection ends. + * @param {Array} data The chunk of the data which belongs to the selected box. + * @param {string} direction The selection direction. + * @returns {Array} + */ + +function getDeltas(start, end, data, direction) { + var rowsLength = data.length; + var columnsLength = data ? data[0].length : 0; + var deltas = []; + var diffRow = end.row - start.row; + var diffCol = end.col - start.col; + + if (['down', 'up'].indexOf(direction) !== -1) { + var arr = []; + + for (var col = 0; col < diffCol; col++) { + var startValue = parseInt(data[0][col], 10); + var endValue = parseInt(data[rowsLength - 1][col], 10); + var delta = (direction === 'down' ? endValue - startValue : startValue - endValue) / (rowsLength - 1) || 0; + arr.push(delta); + } + + deltas.push(arr); + } + + if (['right', 'left'].indexOf(direction) !== -1) { + for (var row = 0; row < diffRow; row++) { + var _startValue = parseInt(data[row][0], 10); + + var _endValue = parseInt(data[row][columnsLength - 1], 10); + + var _delta = (direction === 'right' ? _endValue - _startValue : _startValue - _endValue) / (columnsLength - 1) || 0; + + deltas.push([_delta]); + } + } + + return deltas; +} +/** + * Get direction between positions and cords of selections difference (drag area). + * + * @param {Array} startSelection The coordinates where the selection starts. + * @param {Array} endSelection The coordinates where the selection ends. + * @returns {{direction: string, start: CellCoords, end: CellCoords}} + */ + +function getDragDirectionAndRange(startSelection, endSelection) { + var startOfDragCoords; + var endOfDragCoords; + var directionOfDrag; + + if (endSelection[0] === startSelection[0] && endSelection[1] < startSelection[1]) { + directionOfDrag = 'left'; + startOfDragCoords = new CellCoords(endSelection[0], endSelection[1]); + endOfDragCoords = new CellCoords(endSelection[2], startSelection[1] - 1); + } else if (endSelection[2] === startSelection[2] && endSelection[0] === startSelection[0] && endSelection[3] > startSelection[3]) { + directionOfDrag = 'right'; + startOfDragCoords = new CellCoords(endSelection[0], startSelection[3] + 1); + endOfDragCoords = new CellCoords(endSelection[2], endSelection[3]); + } else if (endSelection[0] < startSelection[0] && endSelection[1] === startSelection[1]) { + directionOfDrag = 'up'; + startOfDragCoords = new CellCoords(endSelection[0], endSelection[1]); + endOfDragCoords = new CellCoords(startSelection[0] - 1, endSelection[3]); + } else if (endSelection[2] > startSelection[2] && endSelection[1] === startSelection[1]) { + directionOfDrag = 'down'; + startOfDragCoords = new CellCoords(startSelection[2] + 1, endSelection[1]); + endOfDragCoords = new CellCoords(endSelection[2], endSelection[3]); + } + + if (startOfDragCoords) { + startOfDragCoords.normalize(); + } + + if (endOfDragCoords) { + endOfDragCoords.normalize(); + } + + return { + directionOfDrag: directionOfDrag, + startOfDragCoords: startOfDragCoords, + endOfDragCoords: endOfDragCoords + }; +} +/** + * Get mapped FillHandle setting containing information about + * allowed FillHandle directions and if allowed is automatic insertion of rows on drag. + * + * @param {boolean|object} fillHandle Property of Handsontable settings. + * @returns {{directions: Array, autoInsertRow: boolean}} Object allowing access to information + * about FillHandle in more useful way. + */ + +function getMappedFillHandleSetting(fillHandle) { + var mappedSettings = {}; + + if (fillHandle === true) { + mappedSettings.directions = Object.keys(DIRECTIONS); + mappedSettings.autoInsertRow = true; + } else if (isObject$1(fillHandle)) { + if (isDefined(fillHandle.autoInsertRow)) { + // autoInsertRow for horizontal direction will be always false + if (fillHandle.direction === DIRECTIONS.horizontal) { + mappedSettings.autoInsertRow = false; + } else { + mappedSettings.autoInsertRow = fillHandle.autoInsertRow; + } + } else { + mappedSettings.autoInsertRow = false; + } + + if (isDefined(fillHandle.direction)) { + mappedSettings.directions = [fillHandle.direction]; + } else { + mappedSettings.directions = Object.keys(DIRECTIONS); + } + } else if (typeof fillHandle === 'string') { + mappedSettings.directions = [fillHandle]; + mappedSettings.autoInsertRow = true; + } else { + mappedSettings.directions = []; + mappedSettings.autoInsertRow = false; + } + + return mappedSettings; +} + +function _typeof$L(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$L = function _typeof(obj) { return typeof obj; }; } else { _typeof$L = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$L(obj); } + +function _toConsumableArray$i(arr) { return _arrayWithoutHoles$g(arr) || _iterableToArray$g(arr) || _unsupportedIterableToArray$p(arr) || _nonIterableSpread$g(); } + +function _nonIterableSpread$g() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArray$g(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$g(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$p(arr); } + +function _slicedToArray$f(arr, i) { return _arrayWithHoles$f(arr) || _iterableToArrayLimit$f(arr, i) || _unsupportedIterableToArray$p(arr, i) || _nonIterableRest$f(); } + +function _nonIterableRest$f() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$p(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$p(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$p(o, minLen); } + +function _arrayLikeToArray$p(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$f(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$f(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$1k(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1f(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); } } + +function _createClass$1f(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1f(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1f(Constructor, staticProps); return Constructor; } + +function _get$d(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$d = Reflect.get; } else { _get$d = function _get(target, property, receiver) { var base = _superPropBase$d(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$d(target, property, receiver || target); } + +function _superPropBase$d(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$A(object); if (object === null) break; } return object; } + +function _inherits$A(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$B(subClass, superClass); } + +function _setPrototypeOf$B(o, p) { _setPrototypeOf$B = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$B(o, p); } + +function _createSuper$A(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$B(); return function _createSuperInternal() { var Super = _getPrototypeOf$A(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$A(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$A(this, result); }; } + +function _possibleConstructorReturn$A(self, call) { if (call && (_typeof$L(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$A(self); } + +function _assertThisInitialized$A(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$B() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$A(o) { _getPrototypeOf$A = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$A(o); } +Hooks.getSingleton().register('modifyAutofillRange'); +Hooks.getSingleton().register('beforeAutofill'); +Hooks.getSingleton().register('afterAutofill'); +var PLUGIN_KEY$3 = 'autofill'; +var PLUGIN_PRIORITY$2 = 20; +var INSERT_ROW_ALTER_ACTION_NAME = 'insert_row'; +var INTERVAL_FOR_ADDING_ROW = 200; +/** + * This plugin provides "drag-down" and "copy-down" functionalities, both operated using the small square in the right + * bottom of the cell selection. + * + * "Drag-down" expands the value of the selected cells to the neighbouring cells when you drag the small + * square in the corner. + * + * "Copy-down" copies the value of the selection to all empty cells below when you double click the small square. + * + * @class Autofill + * @plugin Autofill + */ + +var Autofill = /*#__PURE__*/function (_BasePlugin) { + _inherits$A(Autofill, _BasePlugin); + + var _super = _createSuper$A(Autofill); + + function Autofill(hotInstance) { + var _this; + + _classCallCheck$1k(this, Autofill); + + _this = _super.call(this, hotInstance); + /** + * Event manager instance. + * + * @private + * @type {EventManager} + */ + + _this.eventManager = new EventManager(_assertThisInitialized$A(_this)); + /** + * Specifies if adding new row started. + * + * @private + * @type {boolean} + */ + + _this.addingStarted = false; + /** + * Specifies if there was mouse down on the cell corner. + * + * @private + * @type {boolean} + */ + + _this.mouseDownOnCellCorner = false; + /** + * Specifies if mouse was dragged outside Handsontable. + * + * @private + * @type {boolean} + */ + + _this.mouseDragOutside = false; + /** + * Specifies how many cell levels were dragged using the handle. + * + * @private + * @type {boolean} + */ + + _this.handleDraggedCells = 0; + /** + * Specifies allowed directions of drag (`'horizontal'` or '`vertical`'). + * + * @private + * @type {string[]} + */ + + _this.directions = []; + /** + * Specifies if can insert new rows if needed. + * + * @type {boolean} + */ + + _this.autoInsertRow = false; + return _this; + } + /** + * Checks if the plugin is enabled in the Handsontable settings. + * + * @returns {boolean} + */ + + + _createClass$1f(Autofill, [{ + key: "isEnabled", + value: function isEnabled() { + return this.hot.getSettings().fillHandle; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.mapSettings(); + this.registerEvents(); + this.addHook('afterOnCellCornerMouseDown', function (event) { + return _this2.onAfterCellCornerMouseDown(event); + }); + this.addHook('afterOnCellCornerDblClick', function (event) { + return _this2.onCellCornerDblClick(event); + }); + this.addHook('beforeOnCellMouseOver', function (event, coords) { + return _this2.onBeforeCellMouseOver(coords); + }); + + _get$d(_getPrototypeOf$A(Autofill.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$d(_getPrototypeOf$A(Autofill.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.clearMappedSettings(); + + _get$d(_getPrototypeOf$A(Autofill.prototype), "disablePlugin", this).call(this); + } + /** + * Gets selection data. + * + * @private + * @returns {object[]} Ranges Array of objects with properties `startRow`, `startCol`, `endRow` and `endCol`. + */ + + }, { + key: "getSelectionData", + value: function getSelectionData() { + var _this3 = this; + + var selection = this.hot.getSelectedRangeLast(); + + var _selection$getTopLeft = selection.getTopLeftCorner(), + startRow = _selection$getTopLeft.row, + startCol = _selection$getTopLeft.col; + + var _selection$getBottomR = selection.getBottomRightCorner(), + endRow = _selection$getBottomR.row, + endCol = _selection$getBottomR.col; + + var copyableRanges = this.hot.runHooks('modifyCopyableRange', [{ + startRow: startRow, + startCol: startCol, + endRow: endRow, + endCol: endCol + }]); + var copyableRows = []; + var copyableColumns = []; + var data = []; + arrayEach(copyableRanges, function (range) { + for (var visualRow = range.startRow; visualRow <= range.endRow; visualRow += 1) { + if (copyableRows.indexOf(visualRow) === -1) { + copyableRows.push(visualRow); + } + } + + for (var visualColumn = range.startCol; visualColumn <= range.endCol; visualColumn += 1) { + if (copyableColumns.indexOf(visualColumn) === -1) { + copyableColumns.push(visualColumn); + } + } + }); + arrayEach(copyableRows, function (row) { + var rowSet = []; + arrayEach(copyableColumns, function (column) { + rowSet.push(_this3.hot.getCopyableData(row, column)); + }); + data.push(rowSet); + }); + return data; + } + /** + * Try to apply fill values to the area in fill border, omitting the selection border. + * + * @private + * @returns {boolean} Reports if fill was applied. + * + * @fires Hooks#modifyAutofillRange + * @fires Hooks#beforeAutofill + * @fires Hooks#afterAutofill + */ + + }, { + key: "fillIn", + value: function fillIn() { + if (this.hot.selection.highlight.getFill().isEmpty()) { + return false; + } // Fill area may starts or ends with invisible cell. There won't be any information about it as highlighted + // selection store just renderable indexes (It's part of Walkontable). I extrapolate where the start or/and + // the end is. + + + var _this$hot$selection$h = this.hot.selection.highlight.getFill().getVisualCorners(), + _this$hot$selection$h2 = _slicedToArray$f(_this$hot$selection$h, 4), + fillStartRow = _this$hot$selection$h2[0], + fillStartColumn = _this$hot$selection$h2[1], + fillEndRow = _this$hot$selection$h2[2], + fillEndColumn = _this$hot$selection$h2[3]; + + var selectionRangeLast = this.hot.getSelectedRangeLast(); + var topLeftCorner = selectionRangeLast.getTopLeftCorner(); + var bottomRightCorner = selectionRangeLast.getBottomRightCorner(); + var cornersOfSelectionAndDragAreas = [Math.min(topLeftCorner.row, fillStartRow), Math.min(topLeftCorner.col, fillStartColumn), Math.max(bottomRightCorner.row, fillEndRow), Math.max(bottomRightCorner.col, fillEndColumn)]; + this.resetSelectionOfDraggedArea(); + var cornersOfSelectedCells = [topLeftCorner.row, topLeftCorner.col, bottomRightCorner.row, bottomRightCorner.col]; + cornersOfSelectionAndDragAreas = this.hot.runHooks('modifyAutofillRange', cornersOfSelectionAndDragAreas, cornersOfSelectedCells); + + var _getDragDirectionAndR = getDragDirectionAndRange(cornersOfSelectedCells, cornersOfSelectionAndDragAreas), + directionOfDrag = _getDragDirectionAndR.directionOfDrag, + startOfDragCoords = _getDragDirectionAndR.startOfDragCoords, + endOfDragCoords = _getDragDirectionAndR.endOfDragCoords; + + if (startOfDragCoords && startOfDragCoords.row > -1 && startOfDragCoords.col > -1) { + var selectionData = this.getSelectionData(); + var beforeAutofillHook = this.hot.runHooks('beforeAutofill', startOfDragCoords, endOfDragCoords, selectionData); + + if (beforeAutofillHook === false) { + this.hot.selection.highlight.getFill().clear(); + this.hot.render(); + return false; + } + + var deltas = getDeltas(startOfDragCoords, endOfDragCoords, selectionData, directionOfDrag); + var fillData = selectionData; + + if (['up', 'left'].indexOf(directionOfDrag) > -1) { + fillData = []; + var dragLength = null; + var fillOffset = null; + + if (directionOfDrag === 'up') { + dragLength = endOfDragCoords.row - startOfDragCoords.row + 1; + fillOffset = dragLength % selectionData.length; + + for (var i = 0; i < dragLength; i++) { + fillData.push(selectionData[(i + (selectionData.length - fillOffset)) % selectionData.length]); + } + } else { + dragLength = endOfDragCoords.col - startOfDragCoords.col + 1; + fillOffset = dragLength % selectionData[0].length; + + for (var _i2 = 0; _i2 < selectionData.length; _i2++) { + fillData.push([]); + + for (var j = 0; j < dragLength; j++) { + fillData[_i2].push(selectionData[_i2][(j + (selectionData[_i2].length - fillOffset)) % selectionData[_i2].length]); + } + } + } + } + + this.hot.populateFromArray(startOfDragCoords.row, startOfDragCoords.col, fillData, endOfDragCoords.row, endOfDragCoords.col, "".concat(this.pluginName, ".fill"), null, directionOfDrag, deltas); + this.setSelection(cornersOfSelectionAndDragAreas); + this.hot.runHooks('afterAutofill', startOfDragCoords, endOfDragCoords, selectionData); + } else { + // reset to avoid some range bug + this.hot._refreshBorders(); + } + + return true; + } + /** + * Reduces the selection area if the handle was dragged outside of the table or on headers. + * + * @private + * @param {CellCoords} coords Indexes of selection corners. + * @returns {CellCoords} + */ + + }, { + key: "reduceSelectionAreaIfNeeded", + value: function reduceSelectionAreaIfNeeded(coords) { + if (coords.row < 0) { + coords.row = 0; + } + + if (coords.col < 0) { + coords.col = 0; + } + + return coords; + } + /** + * Gets the coordinates of the drag & drop borders. + * + * @private + * @param {CellCoords} coordsOfSelection `CellCoords` coord object. + * @returns {CellCoords} + */ + + }, { + key: "getCoordsOfDragAndDropBorders", + value: function getCoordsOfDragAndDropBorders(coordsOfSelection) { + var currentSelection = this.hot.getSelectedRangeLast(); + var bottomRightCorner = currentSelection.getBottomRightCorner(); + var coords = coordsOfSelection; + + if (this.directions.includes(DIRECTIONS.vertical) && this.directions.includes(DIRECTIONS.horizontal)) { + var topLeftCorner = currentSelection.getTopLeftCorner(); + + if (bottomRightCorner.col <= coordsOfSelection.col || topLeftCorner.col >= coordsOfSelection.col) { + coords = new CellCoords(bottomRightCorner.row, coordsOfSelection.col); + } + + if (bottomRightCorner.row < coordsOfSelection.row || topLeftCorner.row > coordsOfSelection.row) { + coords = new CellCoords(coordsOfSelection.row, bottomRightCorner.col); + } + } else if (this.directions.includes(DIRECTIONS.vertical)) { + coords = new CellCoords(coordsOfSelection.row, bottomRightCorner.col); + } else if (this.directions.includes(DIRECTIONS.horizontal)) { + coords = new CellCoords(bottomRightCorner.row, coordsOfSelection.col); + } else { + // wrong direction + return; + } + + return this.reduceSelectionAreaIfNeeded(coords); + } + /** + * Show the fill border. + * + * @private + * @param {CellCoords} coordsOfSelection `CellCoords` coord object. + */ + + }, { + key: "showBorder", + value: function showBorder(coordsOfSelection) { + var coordsOfDragAndDropBorders = this.getCoordsOfDragAndDropBorders(coordsOfSelection); + + if (coordsOfDragAndDropBorders) { + this.redrawBorders(coordsOfDragAndDropBorders); + } + } + /** + * Add new row. + * + * @private + */ + + }, { + key: "addRow", + value: function addRow() { + var _this4 = this; + + this.hot._registerTimeout(function () { + _this4.hot.alter(INSERT_ROW_ALTER_ACTION_NAME, void 0, 1, "".concat(_this4.pluginName, ".fill")); + + _this4.addingStarted = false; + }, INTERVAL_FOR_ADDING_ROW); + } + /** + * Add new rows if they are needed to continue auto-filling values. + * + * @private + */ + + }, { + key: "addNewRowIfNeeded", + value: function addNewRowIfNeeded() { + if (!this.hot.selection.highlight.getFill().isEmpty() && this.addingStarted === false && this.autoInsertRow) { + var cornersOfSelectedCells = this.hot.getSelectedLast(); + var cornersOfSelectedDragArea = this.hot.selection.highlight.getFill().getVisualCorners(); + var nrOfTableRows = this.hot.countRows(); + + if (cornersOfSelectedCells[2] < nrOfTableRows - 1 && cornersOfSelectedDragArea[2] === nrOfTableRows - 1) { + this.addingStarted = true; + this.addRow(); + } + } + } + /** + * Get index of last adjacent filled in row. + * + * @private + * @param {Array} cornersOfSelectedCells Indexes of selection corners. + * @returns {number} Gives number greater than or equal to zero when selection adjacent can be applied. + * Or -1 when selection adjacent can't be applied. + */ + + }, { + key: "getIndexOfLastAdjacentFilledInRow", + value: function getIndexOfLastAdjacentFilledInRow(cornersOfSelectedCells) { + var data = this.hot.getData(); + var nrOfTableRows = this.hot.countRows(); + var lastFilledInRowIndex; + + for (var rowIndex = cornersOfSelectedCells[2] + 1; rowIndex < nrOfTableRows; rowIndex++) { + for (var columnIndex = cornersOfSelectedCells[1]; columnIndex <= cornersOfSelectedCells[3]; columnIndex++) { + var dataInCell = data[rowIndex][columnIndex]; + + if (dataInCell) { + return -1; + } + } + + var dataInNextLeftCell = data[rowIndex][cornersOfSelectedCells[1] - 1]; + var dataInNextRightCell = data[rowIndex][cornersOfSelectedCells[3] + 1]; + + if (!!dataInNextLeftCell || !!dataInNextRightCell) { + lastFilledInRowIndex = rowIndex; + } + } + + return lastFilledInRowIndex; + } + /** + * Adds a selection from the start area to the specific row index. + * + * @private + * @param {Array} selectStartArea Selection area from which we start to create more comprehensive selection. + * @param {number} rowIndex The row index into the selection will be added. + */ + + }, { + key: "addSelectionFromStartAreaToSpecificRowIndex", + value: function addSelectionFromStartAreaToSpecificRowIndex(selectStartArea, rowIndex) { + this.hot.selection.highlight.getFill().clear().add(new CellCoords(selectStartArea[0], selectStartArea[1])).add(new CellCoords(rowIndex, selectStartArea[3])).commit(); + } + /** + * Sets selection based on passed corners. + * + * @private + * @param {Array} cornersOfArea An array witch defines selection. + */ + + }, { + key: "setSelection", + value: function setSelection(cornersOfArea) { + var _this$hot; + + (_this$hot = this.hot).selectCell.apply(_this$hot, _toConsumableArray$i(arrayMap(cornersOfArea, function (index) { + return Math.max(index, 0); + })).concat([false, false])); + } + /** + * Try to select cells down to the last row in the left column and then returns if selection was applied. + * + * @private + * @returns {boolean} + */ + + }, { + key: "selectAdjacent", + value: function selectAdjacent() { + var cornersOfSelectedCells = this.hot.getSelectedLast(); + var lastFilledInRowIndex = this.getIndexOfLastAdjacentFilledInRow(cornersOfSelectedCells); + + if (lastFilledInRowIndex === -1 || lastFilledInRowIndex === void 0) { + return false; + } + + this.addSelectionFromStartAreaToSpecificRowIndex(cornersOfSelectedCells, lastFilledInRowIndex); + return true; + } + /** + * Resets selection of dragged area. + * + * @private + */ + + }, { + key: "resetSelectionOfDraggedArea", + value: function resetSelectionOfDraggedArea() { + this.handleDraggedCells = 0; + this.hot.selection.highlight.getFill().clear(); + } + /** + * Redraws borders. + * + * @private + * @param {CellCoords} coords `CellCoords` coord object. + */ + + }, { + key: "redrawBorders", + value: function redrawBorders(coords) { + this.hot.selection.highlight.getFill().clear().add(this.hot.getSelectedRangeLast().from).add(this.hot.getSelectedRangeLast().to).add(coords).commit(); + this.hot.view.render(); + } + /** + * Get if mouse was dragged outside. + * + * @private + * @param {MouseEvent} event `mousemove` event properties. + * @returns {boolean} + */ + + }, { + key: "getIfMouseWasDraggedOutside", + value: function getIfMouseWasDraggedOutside(event) { + var documentElement = this.hot.rootDocument.documentElement; + var tableBottom = offset(this.hot.table).top - (this.hot.rootWindow.pageYOffset || documentElement.scrollTop) + outerHeight(this.hot.table); + var tableRight = offset(this.hot.table).left - (this.hot.rootWindow.pageXOffset || documentElement.scrollLeft) + outerWidth(this.hot.table); + return event.clientY > tableBottom && event.clientX <= tableRight; + } + /** + * Bind the events used by the plugin. + * + * @private + */ + + }, { + key: "registerEvents", + value: function registerEvents() { + var _this5 = this; + + var documentElement = this.hot.rootDocument.documentElement; + this.eventManager.addEventListener(documentElement, 'mouseup', function () { + return _this5.onMouseUp(); + }); + this.eventManager.addEventListener(documentElement, 'mousemove', function (event) { + return _this5.onMouseMove(event); + }); + } + /** + * On cell corner double click callback. + * + * @private + */ + + }, { + key: "onCellCornerDblClick", + value: function onCellCornerDblClick() { + var selectionApplied = this.selectAdjacent(); + + if (selectionApplied) { + this.fillIn(); + } + } + /** + * On after cell corner mouse down listener. + * + * @private + */ + + }, { + key: "onAfterCellCornerMouseDown", + value: function onAfterCellCornerMouseDown() { + this.handleDraggedCells = 1; + this.mouseDownOnCellCorner = true; + } + /** + * On before cell mouse over listener. + * + * @private + * @param {CellCoords} coords `CellCoords` coord object. + */ + + }, { + key: "onBeforeCellMouseOver", + value: function onBeforeCellMouseOver(coords) { + if (this.mouseDownOnCellCorner && !this.hot.view.isMouseDown() && this.handleDraggedCells) { + this.handleDraggedCells += 1; + this.showBorder(coords); + this.addNewRowIfNeeded(); + } + } + /** + * On mouse up listener. + * + * @private + */ + + }, { + key: "onMouseUp", + value: function onMouseUp() { + if (this.handleDraggedCells) { + if (this.handleDraggedCells > 1) { + this.fillIn(); + } + + this.handleDraggedCells = 0; + this.mouseDownOnCellCorner = false; + } + } + /** + * On mouse move listener. + * + * @private + * @param {MouseEvent} event `mousemove` event properties. + */ + + }, { + key: "onMouseMove", + value: function onMouseMove(event) { + var mouseWasDraggedOutside = this.getIfMouseWasDraggedOutside(event); + + if (this.addingStarted === false && this.handleDraggedCells > 0 && mouseWasDraggedOutside) { + this.mouseDragOutside = true; + this.addingStarted = true; + } else { + this.mouseDragOutside = false; + } + + if (this.mouseDragOutside && this.autoInsertRow) { + this.addRow(); + } + } + /** + * Clears mapped settings. + * + * @private + */ + + }, { + key: "clearMappedSettings", + value: function clearMappedSettings() { + this.directions.length = 0; + this.autoInsertRow = false; + } + /** + * Map settings. + * + * @private + */ + + }, { + key: "mapSettings", + value: function mapSettings() { + var mappedSettings = getMappedFillHandleSetting(this.hot.getSettings().fillHandle); + this.directions = mappedSettings.directions; + this.autoInsertRow = mappedSettings.autoInsertRow; + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + _get$d(_getPrototypeOf$A(Autofill.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$3; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$2; + } + }]); + + return Autofill; +}(BasePlugin); + +function _typeof$M(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$M = function _typeof(obj) { return typeof obj; }; } else { _typeof$M = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$M(obj); } + +function _classCallCheck$1l(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1g(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); } } + +function _createClass$1g(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1g(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1g(Constructor, staticProps); return Constructor; } + +function _get$e(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$e = Reflect.get; } else { _get$e = function _get(target, property, receiver) { var base = _superPropBase$e(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$e(target, property, receiver || target); } + +function _superPropBase$e(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$B(object); if (object === null) break; } return object; } + +function _inherits$B(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$C(subClass, superClass); } + +function _setPrototypeOf$C(o, p) { _setPrototypeOf$C = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$C(o, p); } + +function _createSuper$B(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$C(); return function _createSuperInternal() { var Super = _getPrototypeOf$B(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$B(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$B(this, result); }; } + +function _possibleConstructorReturn$B(self, call) { if (call && (_typeof$M(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$B(self); } + +function _assertThisInitialized$B(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$C() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$B(o) { _getPrototypeOf$B = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$B(o); } + +var PLUGIN_KEY$4 = 'manualRowResize'; +var PLUGIN_PRIORITY$3 = 30; +var PERSISTENT_STATE_KEY = 'manualRowHeights'; +var privatePool$7 = new WeakMap(); +/** + * @description + * This plugin allows to change rows height. To make rows height persistent the {@link Options#persistentState} + * plugin should be enabled. + * + * The plugin creates additional components to make resizing possibly using user interface: + * - handle - the draggable element that sets the desired height of the row. + * - guide - the helper guide that shows the desired height as a horizontal guide. + * + * @plugin ManualRowResize + */ + +var ManualRowResize = /*#__PURE__*/function (_BasePlugin) { + _inherits$B(ManualRowResize, _BasePlugin); + + var _super = _createSuper$B(ManualRowResize); + + function ManualRowResize(hotInstance) { + var _this; + + _classCallCheck$1l(this, ManualRowResize); + + _this = _super.call(this, hotInstance); + var rootDocument = _this.hot.rootDocument; + _this.currentTH = null; + _this.currentRow = null; + _this.selectedRows = []; + _this.currentHeight = null; + _this.newSize = null; + _this.startY = null; + _this.startHeight = null; + _this.startOffset = null; + _this.handle = rootDocument.createElement('DIV'); + _this.guide = rootDocument.createElement('DIV'); + _this.eventManager = new EventManager(_assertThisInitialized$B(_this)); + _this.pressed = null; + _this.dblclick = 0; + _this.autoresizeTimeout = null; + /** + * PhysicalIndexToValueMap to keep and track widths for physical row indexes. + * + * @private + * @type {PhysicalIndexToValueMap} + */ + + _this.rowHeightsMap = void 0; + /** + * Private pool to save configuration from updateSettings. + */ + + privatePool$7.set(_assertThisInitialized$B(_this), { + config: void 0 + }); + addClass(_this.handle, 'manualRowResizer'); + addClass(_this.guide, 'manualRowResizerGuide'); + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ManualRowResize#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1g(ManualRowResize, [{ + key: "isEnabled", + value: function isEnabled() { + return this.hot.getSettings()[PLUGIN_KEY$4]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.rowHeightsMap = new PhysicalIndexToValueMap(); + this.rowHeightsMap.addLocalHook('init', function () { + return _this2.onMapInit(); + }); + this.hot.rowIndexMapper.registerMap(this.pluginName, this.rowHeightsMap); + this.addHook('modifyRowHeight', function (height, row) { + return _this2.onModifyRowHeight(height, row); + }); + this.bindEvents(); + + _get$e(_getPrototypeOf$B(ManualRowResize.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$e(_getPrototypeOf$B(ManualRowResize.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + var priv = privatePool$7.get(this); + priv.config = this.rowHeightsMap.getValues(); + this.hot.rowIndexMapper.unregisterMap(this.pluginName); + + _get$e(_getPrototypeOf$B(ManualRowResize.prototype), "disablePlugin", this).call(this); + } + /** + * Saves the current sizes using the persistentState plugin (the {@link Options#persistentState} option has to be + * enabled). + * + * @fires Hooks#persistentStateSave + */ + + }, { + key: "saveManualRowHeights", + value: function saveManualRowHeights() { + this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY, this.rowHeightsMap.getValues()); + } + /** + * Loads the previously saved sizes using the persistentState plugin (the {@link Options#persistentState} option + * has be enabled). + * + * @returns {Array} + * @fires Hooks#persistentStateLoad + */ + + }, { + key: "loadManualRowHeights", + value: function loadManualRowHeights() { + var storedState = {}; + this.hot.runHooks('persistentStateLoad', PERSISTENT_STATE_KEY, storedState); + return storedState.value; + } + /** + * Sets the new height for specified row index. + * + * @param {number} row Visual row index. + * @param {number} height Row height. + * @returns {number} Returns new height. + */ + + }, { + key: "setManualSize", + value: function setManualSize(row, height) { + var physicalRow = this.hot.toPhysicalRow(row); + var newHeight = Math.max(height, ViewportRowsCalculator.DEFAULT_HEIGHT); + this.rowHeightsMap.setValueAtIndex(physicalRow, newHeight); + return newHeight; + } + /** + * Sets the resize handle position. + * + * @private + * @param {HTMLCellElement} TH TH HTML element. + */ + + }, { + key: "setupHandlePosition", + value: function setupHandlePosition(TH) { + var _this3 = this; + + this.currentTH = TH; + var view = this.hot.view; + var wt = view.wt; + var cellCoords = view.wt.wtTable.getCoords(this.currentTH); + var row = cellCoords.row; // Ignore row headers. + + if (row < 0) { + return; + } + + var headerWidth = outerWidth(this.currentTH); + var box = this.currentTH.getBoundingClientRect(); // Read "fixedRowsTop" and "fixedRowsBottom" through the Walkontable as in that context, the fixed + // rows are modified (reduced by the number of hidden rows) by TableView module. + + var fixedRowTop = row < wt.getSetting('fixedRowsTop'); + var fixedRowBottom = row >= view.countNotHiddenRowIndexes(0, 1) - wt.getSetting('fixedRowsBottom'); + var relativeHeaderPosition; + + if (fixedRowTop) { + relativeHeaderPosition = wt.wtOverlays.topLeftCornerOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col); + } else if (fixedRowBottom) { + relativeHeaderPosition = wt.wtOverlays.bottomLeftCornerOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col); + } // If the TH is not a child of the top-left/bottom-left overlay, recalculate using + // the left overlay - as this overlay contains the rest of the headers. + + + if (!relativeHeaderPosition) { + relativeHeaderPosition = wt.wtOverlays.leftOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col); + } + + this.currentRow = this.hot.rowIndexMapper.getVisualFromRenderableIndex(row); + this.selectedRows = []; + var isFullRowSelected = this.hot.selection.isSelectedByCorner() || this.hot.selection.isSelectedByRowHeader(); + + if (this.hot.selection.isSelected() && isFullRowSelected) { + var selectionRanges = this.hot.getSelectedRange(); + arrayEach(selectionRanges, function (selectionRange) { + var fromRow = selectionRange.getTopLeftCorner().row; + var toRow = selectionRange.getBottomLeftCorner().row; // Add every selected row for resize action. + + rangeEach(fromRow, toRow, function (rowIndex) { + if (!_this3.selectedRows.includes(rowIndex)) { + _this3.selectedRows.push(rowIndex); + } + }); + }); + } // Resizing element beyond the current selection (also when there is no selection). + + + if (!this.selectedRows.includes(this.currentRow)) { + this.selectedRows = [this.currentRow]; + } + + this.startOffset = relativeHeaderPosition.top - 6; + this.startHeight = parseInt(box.height, 10); + this.handle.style.top = "".concat(this.startOffset + this.startHeight, "px"); + this.handle.style.left = "".concat(relativeHeaderPosition.left, "px"); + this.handle.style.width = "".concat(headerWidth, "px"); + this.hot.rootElement.appendChild(this.handle); + } + /** + * Refresh the resize handle position. + * + * @private + */ + + }, { + key: "refreshHandlePosition", + value: function refreshHandlePosition() { + this.handle.style.top = "".concat(this.startOffset + this.currentHeight, "px"); + } + /** + * Sets the resize guide position. + * + * @private + */ + + }, { + key: "setupGuidePosition", + value: function setupGuidePosition() { + var handleWidth = parseInt(outerWidth(this.handle), 10); + var handleRightPosition = parseInt(this.handle.style.left, 10) + handleWidth; + var maximumVisibleElementWidth = parseInt(this.hot.view.maximumVisibleElementWidth(0), 10); + addClass(this.handle, 'active'); + addClass(this.guide, 'active'); + this.guide.style.top = this.handle.style.top; + this.guide.style.left = "".concat(handleRightPosition, "px"); + this.guide.style.width = "".concat(maximumVisibleElementWidth - handleWidth, "px"); + this.hot.rootElement.appendChild(this.guide); + } + /** + * Refresh the resize guide position. + * + * @private + */ + + }, { + key: "refreshGuidePosition", + value: function refreshGuidePosition() { + this.guide.style.top = this.handle.style.top; + } + /** + * Hides both the resize handle and resize guide. + * + * @private + */ + + }, { + key: "hideHandleAndGuide", + value: function hideHandleAndGuide() { + removeClass(this.handle, 'active'); + removeClass(this.guide, 'active'); + } + /** + * Checks if provided element is considered as a row header. + * + * @private + * @param {HTMLElement} element HTML element. + * @returns {boolean} + */ + + }, { + key: "checkIfRowHeader", + value: function checkIfRowHeader(element) { + var _element$parentNode, _element$parentNode$p; + + var thElement = closest(element, ['TH'], this.hot.rootElement); + return thElement && ((_element$parentNode = element.parentNode) === null || _element$parentNode === void 0 ? void 0 : (_element$parentNode$p = _element$parentNode.parentNode) === null || _element$parentNode$p === void 0 ? void 0 : _element$parentNode$p.tagName) === 'TBODY'; + } + /** + * Gets the TH element from the provided element. + * + * @private + * @param {HTMLElement} element HTML element. + * @returns {HTMLElement} + */ + + }, { + key: "getClosestTHParent", + value: function getClosestTHParent(element) { + if (element.tagName !== 'TABLE') { + if (element.tagName === 'TH') { + return element; + } + + return this.getClosestTHParent(element.parentNode); + } + + return null; + } + /** + * Returns the actual height for the provided row index. + * + * @private + * @param {number} row Visual row index. + * @returns {number} Actual row height. + */ + + }, { + key: "getActualRowHeight", + value: function getActualRowHeight(row) { + // TODO: this should utilize `this.hot.getRowHeight` after it's fixed and working properly. + var walkontableHeight = this.hot.view.wt.wtTable.getRowHeight(row); + + if (walkontableHeight !== void 0 && this.newSize < walkontableHeight) { + return walkontableHeight; + } + + return this.newSize; + } + /** + * 'mouseover' event callback - set the handle position. + * + * @private + * @param {MouseEvent} event The mouse event. + */ + + }, { + key: "onMouseOver", + value: function onMouseOver(event) { + // Workaround for #6926 - if the `event.target` is temporarily detached, we can skip this callback and wait for + // the next `onmouseover`. + if (isDetached(event.target)) { + return; + } + + if (this.checkIfRowHeader(event.target)) { + var th = this.getClosestTHParent(event.target); + + if (th) { + if (!this.pressed) { + this.setupHandlePosition(th); + } + } + } + } + /** + * Auto-size row after doubleclick - callback. + * + * @private + * @fires Hooks#beforeRowResize + * @fires Hooks#afterRowResize + */ + + }, { + key: "afterMouseDownTimeout", + value: function afterMouseDownTimeout() { + var _this4 = this; + + var render = function render() { + _this4.hot.forceFullRender = true; + + _this4.hot.view.render(); // updates all + + + _this4.hot.view.adjustElementsSize(true); + }; + + var resize = function resize(row, forceRender) { + var hookNewSize = _this4.hot.runHooks('beforeRowResize', _this4.getActualRowHeight(row), row, true); + + if (hookNewSize !== void 0) { + _this4.newSize = hookNewSize; + } + + _this4.setManualSize(row, _this4.newSize); // double click sets auto row size + + + _this4.hot.runHooks('afterRowResize', _this4.getActualRowHeight(row), row, true); + + if (forceRender) { + render(); + } + }; + + if (this.dblclick >= 2) { + var selectedRowsLength = this.selectedRows.length; + + if (selectedRowsLength > 1) { + arrayEach(this.selectedRows, function (selectedRow) { + resize(selectedRow); + }); + render(); + } else { + arrayEach(this.selectedRows, function (selectedRow) { + resize(selectedRow, true); + }); + } + } + + this.dblclick = 0; + this.autoresizeTimeout = null; + } + /** + * 'mousedown' event callback. + * + * @private + * @param {MouseEvent} event The mouse event. + */ + + }, { + key: "onMouseDown", + value: function onMouseDown(event) { + var _this5 = this; + + if (hasClass(event.target, 'manualRowResizer')) { + this.setupHandlePosition(this.currentTH); + this.setupGuidePosition(); + this.pressed = true; + + if (this.autoresizeTimeout === null) { + this.autoresizeTimeout = setTimeout(function () { + return _this5.afterMouseDownTimeout(); + }, 500); + + this.hot._registerTimeout(this.autoresizeTimeout); + } + + this.dblclick += 1; + this.startY = event.pageY; + this.newSize = this.startHeight; + } + } + /** + * 'mousemove' event callback - refresh the handle and guide positions, cache the new row height. + * + * @private + * @param {MouseEvent} event The mouse event. + */ + + }, { + key: "onMouseMove", + value: function onMouseMove(event) { + var _this6 = this; + + if (this.pressed) { + this.currentHeight = this.startHeight + (event.pageY - this.startY); + arrayEach(this.selectedRows, function (selectedRow) { + _this6.newSize = _this6.setManualSize(selectedRow, _this6.currentHeight); + }); + this.refreshHandlePosition(); + this.refreshGuidePosition(); + } + } + /** + * 'mouseup' event callback - apply the row resizing. + * + * @private + * + * @fires Hooks#beforeRowResize + * @fires Hooks#afterRowResize + */ + + }, { + key: "onMouseUp", + value: function onMouseUp() { + var _this7 = this; + + var render = function render() { + _this7.hot.forceFullRender = true; + + _this7.hot.view.render(); // updates all + + + _this7.hot.view.adjustElementsSize(true); + }; + + var runHooks = function runHooks(row, forceRender) { + _this7.hot.runHooks('beforeRowResize', _this7.getActualRowHeight(row), row, false); + + if (forceRender) { + render(); + } + + _this7.saveManualRowHeights(); + + _this7.hot.runHooks('afterRowResize', _this7.getActualRowHeight(row), row, false); + }; + + if (this.pressed) { + this.hideHandleAndGuide(); + this.pressed = false; + + if (this.newSize !== this.startHeight) { + var selectedRowsLength = this.selectedRows.length; + + if (selectedRowsLength > 1) { + arrayEach(this.selectedRows, function (selectedRow) { + runHooks(selectedRow); + }); + render(); + } else { + arrayEach(this.selectedRows, function (selectedRow) { + runHooks(selectedRow, true); + }); + } + } + + this.setupHandlePosition(this.currentTH); + } + } + /** + * Binds the mouse events. + * + * @private + */ + + }, { + key: "bindEvents", + value: function bindEvents() { + var _this8 = this; + + var _this$hot = this.hot, + rootElement = _this$hot.rootElement, + rootWindow = _this$hot.rootWindow; + this.eventManager.addEventListener(rootElement, 'mouseover', function (e) { + return _this8.onMouseOver(e); + }); + this.eventManager.addEventListener(rootElement, 'mousedown', function (e) { + return _this8.onMouseDown(e); + }); + this.eventManager.addEventListener(rootWindow, 'mousemove', function (e) { + return _this8.onMouseMove(e); + }); + this.eventManager.addEventListener(rootWindow, 'mouseup', function () { + return _this8.onMouseUp(); + }); + } + /** + * Modifies the provided row height, based on the plugin settings. + * + * @private + * @param {number} height Row height. + * @param {number} row Visual row index. + * @returns {number} + */ + + }, { + key: "onModifyRowHeight", + value: function onModifyRowHeight(height, row) { + var newHeight = height; + + if (this.enabled) { + var physicalRow = this.hot.toPhysicalRow(row); + var rowHeight = this.rowHeightsMap.getValueAtIndex(physicalRow); + + if (this.hot.getSettings()[PLUGIN_KEY$4] && rowHeight) { + newHeight = rowHeight; + } + } + + return newHeight; + } + /** + * Callback to call on map's `init` local hook. + * + * @private + */ + + }, { + key: "onMapInit", + value: function onMapInit() { + var _this9 = this; + + var priv = privatePool$7.get(this); + var initialSetting = this.hot.getSettings()[PLUGIN_KEY$4]; + var loadedManualRowHeights = this.loadManualRowHeights(); + this.hot.batchExecution(function () { + if (typeof loadedManualRowHeights !== 'undefined') { + loadedManualRowHeights.forEach(function (height, index) { + _this9.rowHeightsMap.setValueAtIndex(index, height); + }); + } else if (Array.isArray(initialSetting)) { + initialSetting.forEach(function (height, index) { + _this9.rowHeightsMap.setValueAtIndex(index, height); + }); + priv.config = initialSetting; + } else if (initialSetting === true && Array.isArray(priv.config)) { + priv.config.forEach(function (height, index) { + _this9.rowHeightsMap.setValueAtIndex(index, height); + }); + } + }, true); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.rowIndexMapper.unregisterMap(this.pluginName); + + _get$e(_getPrototypeOf$B(ManualRowResize.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$4; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$3; + } + }]); + + return ManualRowResize; +}(BasePlugin); + +function _typeof$N(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$N = function _typeof(obj) { return typeof obj; }; } else { _typeof$N = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$N(obj); } + +function _slicedToArray$g(arr, i) { return _arrayWithHoles$g(arr) || _iterableToArrayLimit$g(arr, i) || _unsupportedIterableToArray$q(arr, i) || _nonIterableRest$g(); } + +function _nonIterableRest$g() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$q(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$q(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$q(o, minLen); } + +function _arrayLikeToArray$q(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$g(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$g(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$1m(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1h(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); } } + +function _createClass$1h(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1h(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1h(Constructor, staticProps); return Constructor; } + +function _get$f(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$f = Reflect.get; } else { _get$f = function _get(target, property, receiver) { var base = _superPropBase$f(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$f(target, property, receiver || target); } + +function _superPropBase$f(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$C(object); if (object === null) break; } return object; } + +function _inherits$C(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$D(subClass, superClass); } + +function _setPrototypeOf$D(o, p) { _setPrototypeOf$D = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$D(o, p); } + +function _createSuper$C(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$D(); return function _createSuperInternal() { var Super = _getPrototypeOf$C(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$C(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$C(this, result); }; } + +function _possibleConstructorReturn$C(self, call) { if (call && (_typeof$N(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$C(self); } + +function _assertThisInitialized$C(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$D() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$C(o) { _getPrototypeOf$C = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$C(o); } +var PLUGIN_KEY$5 = 'autoRowSize'; +var PLUGIN_PRIORITY$4 = 40; +var ROW_WIDTHS_MAP_NAME = 'autoRowSize'; +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @plugin AutoRowSize + * @class AutoRowSize + * @description + * This plugin allows to set row heights based on their highest cells. + * + * By default, the plugin is declared as `undefined`, which makes it disabled (same as if it was declared as `false`). + * Enabling this plugin may decrease the overall table performance, as it needs to calculate the heights of all cells to + * resize the rows accordingly. + * If you experience problems with the performance, try turning this feature off and declaring the row heights manually. + * + * Row height calculations are divided into sync and async part. Each of this parts has their own advantages and + * disadvantages. Synchronous calculations are faster but they block the browser UI, while the slower asynchronous + * operations don't block the browser UI. + * + * To configure the sync/async distribution, you can pass an absolute value (number of columns) or a percentage value to a config object: + * ```js + * // as a number (300 columns in sync, rest async) + * autoRowSize: {syncLimit: 300},. + * + * // as a string (percent) + * autoRowSize: {syncLimit: '40%'},. + * + * // allow sample duplication + * autoRowSize: {syncLimit: '40%', allowSampleDuplicates: true}, + * ``` + * + * You can also use the `allowSampleDuplicates` option to allow sampling duplicate values when calculating the row + * height. __Note__, that this might have a negative impact on performance. + * + * To configure this plugin see {@link Options#autoRowSize}. + * + * @example + * + * ```js + * const hot = new Handsontable(document.getElementById('example'), { + * data: getData(), + * autoRowSize: true + * }); + * // Access to plugin instance: + * const plugin = hot.getPlugin('autoRowSize'); + * + * plugin.getRowHeight(4); + * + * if (plugin.isEnabled()) { + * // code... + * } + * ``` + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var AutoRowSize = /*#__PURE__*/function (_BasePlugin) { + _inherits$C(AutoRowSize, _BasePlugin); + + var _super = _createSuper$C(AutoRowSize); + + function AutoRowSize(hotInstance) { + var _this; + + _classCallCheck$1m(this, AutoRowSize); + + _this = _super.call(this, hotInstance); + /** + * PhysicalIndexToValueMap to keep and track heights for physical row indexes. + * + * @private + * @type {PhysicalIndexToValueMap} + */ + + _this.rowHeightsMap = void 0; + /** + * Columns header's height cache. + * + * @private + * @type {number} + */ + + _this.headerHeight = null; + /** + * Instance of {@link GhostTable} for rows and columns size calculations. + * + * @private + * @type {GhostTable} + */ + + _this.ghostTable = new GhostTable(_this.hot); + /** + * Instance of {@link SamplesGenerator} for generating samples necessary for rows height calculations. + * + * @private + * @type {SamplesGenerator} + */ + + _this.samplesGenerator = new SamplesGenerator(function (row, col) { + var cellValue; + + if (row >= 0) { + cellValue = _this.hot.getDataAtCell(row, col); + } else if (row === -1) { + cellValue = _this.hot.getColHeader(col); + } + + return { + value: cellValue + }; + }); + /** + * `true` if only the first calculation was performed. + * + * @private + * @type {boolean} + */ + + _this.firstCalculation = true; + /** + * `true` if the size calculation is in progress. + * + * @type {boolean} + */ + + _this.inProgress = false; + /** + * Number of already measured rows (we already know their sizes). + * + * @type {number} + */ + + _this.measuredRows = 0; + /** + * PhysicalIndexToValueMap to keep and track heights for physical row indexes. + * + * @private + * @type {PhysicalIndexToValueMap} + */ + + _this.rowHeightsMap = new PhysicalIndexToValueMap(); + + _this.hot.rowIndexMapper.registerMap(ROW_WIDTHS_MAP_NAME, _this.rowHeightsMap); // Leave the listener active to allow auto-sizing the rows when the plugin is disabled. + // This is necesseary for height recalculation for resize handler doubleclick (ManualRowResize). + + + _this.addHook('beforeRowResize', function (size, row, isDblClick) { + return _this.onBeforeRowResize(size, row, isDblClick); + }); + + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link AutoRowSize#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1h(AutoRowSize, [{ + key: "isEnabled", + value: function isEnabled() { + var settings = this.hot.getSettings()[PLUGIN_KEY$5]; + return settings === true || isObject$1(settings); + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.setSamplingOptions(); + this.addHook('afterLoadData', function () { + return _this2.onAfterLoadData(); + }); + this.addHook('beforeChange', function (changes) { + return _this2.onBeforeChange(changes); + }); + this.addHook('beforeColumnResize', function () { + return _this2.recalculateAllRowsHeight(); + }); + this.addHook('beforeRender', function (force) { + return _this2.onBeforeRender(force); + }); + this.addHook('modifyRowHeight', function (height, row) { + return _this2.getRowHeight(row, height); + }); + this.addHook('modifyColumnHeaderHeight', function () { + return _this2.getColumnHeaderHeight(); + }); + + _get$f(_getPrototypeOf$C(AutoRowSize.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + var _this3 = this; + + this.headerHeight = null; + + _get$f(_getPrototypeOf$C(AutoRowSize.prototype), "disablePlugin", this).call(this); // Leave the listener active to allow auto-sizing the rows when the plugin is disabled. + // This is necesseary for height recalculation for resize handler doubleclick (ManualRowResize). + + + this.addHook('beforeRowResize', function (size, row, isDblClick) { + return _this3.onBeforeRowResize(size, row, isDblClick); + }); + } + /** + * Calculate a given rows height. + * + * @param {number|object} rowRange Row index or an object with `from` and `to` indexes as a range. + * @param {number|object} colRange Column index or an object with `from` and `to` indexes as a range. + * @param {boolean} [force=false] If `true` the calculation will be processed regardless of whether the width exists in the cache. + */ + + }, { + key: "calculateRowsHeight", + value: function calculateRowsHeight() { + var _this4 = this; + + var rowRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { + from: 0, + to: this.hot.countRows() - 1 + }; + var colRange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { + from: 0, + to: this.hot.countCols() - 1 + }; + var force = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + // eslint-disable-line max-len + var rowsRange = typeof rowRange === 'number' ? { + from: rowRange, + to: rowRange + } : rowRange; + var columnsRange = typeof colRange === 'number' ? { + from: colRange, + to: colRange + } : colRange; + + if (this.hot.getColHeader(0) !== null) { + var samples = this.samplesGenerator.generateRowSamples(-1, columnsRange); + this.ghostTable.addColumnHeadersRow(samples.get(-1)); + } + + rangeEach(rowsRange.from, rowsRange.to, function (row) { + // For rows we must calculate row height even when user had set height value manually. + // We can shrink column but cannot shrink rows! + if (force || _this4.rowHeightsMap.getValueAtIndex(row) === null) { + var _samples = _this4.samplesGenerator.generateRowSamples(row, columnsRange); + + arrayEach(_samples, function (_ref) { + var _ref2 = _slicedToArray$g(_ref, 2), + rowIndex = _ref2[0], + sample = _ref2[1]; + + return _this4.ghostTable.addRow(rowIndex, sample); + }); + } + }); + + if (this.ghostTable.rows.length) { + this.hot.batchExecution(function () { + _this4.ghostTable.getHeights(function (row, height) { + if (row < 0) { + _this4.headerHeight = height; + } else { + _this4.rowHeightsMap.setValueAtIndex(_this4.hot.toPhysicalRow(row), height); + } + }); + }, true); + this.measuredRows = rowsRange.to + 1; + this.ghostTable.clean(); + } + } + /** + * Calculate all rows heights. The calculated row will be cached in the {@link AutoRowSize#heights} property. + * To retrieve height for specified row use {@link AutoRowSize#getRowHeight} method. + * + * @param {object|number} colRange Row index or an object with `from` and `to` properties which define row range. + */ + + }, { + key: "calculateAllRowsHeight", + value: function calculateAllRowsHeight() { + var _this5 = this; + + var colRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { + from: 0, + to: this.hot.countCols() - 1 + }; + var current = 0; + var length = this.hot.countRows() - 1; + var timer = null; + this.inProgress = true; + + var loop = function loop() { + // When hot was destroyed after calculating finished cancel frame + if (!_this5.hot) { + cancelAnimationFrame(timer); + _this5.inProgress = false; + return; + } + + _this5.calculateRowsHeight({ + from: current, + to: Math.min(current + AutoRowSize.CALCULATION_STEP, length) + }, colRange); + + current = current + AutoRowSize.CALCULATION_STEP + 1; + + if (current < length) { + timer = requestAnimationFrame(loop); + } else { + cancelAnimationFrame(timer); + _this5.inProgress = false; // @TODO Should call once per render cycle, currently fired separately in different plugins + + _this5.hot.view.adjustElementsSize(true); // tmp + + + if (_this5.hot.view.wt.wtOverlays.leftOverlay.needFullRender) { + _this5.hot.view.wt.wtOverlays.leftOverlay.clone.draw(); + } + } + }; + + var syncLimit = this.getSyncCalculationLimit(); // sync + + if (this.firstCalculation && syncLimit >= 0) { + this.calculateRowsHeight({ + from: 0, + to: syncLimit + }, colRange); + this.firstCalculation = false; + current = syncLimit + 1; + } // async + + + if (current < length) { + loop(); + } else { + this.inProgress = false; + this.hot.view.adjustElementsSize(false); + } + } + /** + * Sets the sampling options. + * + * @private + */ + + }, { + key: "setSamplingOptions", + value: function setSamplingOptions() { + var setting = this.hot.getSettings()[PLUGIN_KEY$5]; + var samplingRatio = setting && hasOwnProperty$1(setting, 'samplingRatio') ? setting.samplingRatio : void 0; + var allowSampleDuplicates = setting && hasOwnProperty$1(setting, 'allowSampleDuplicates') ? setting.allowSampleDuplicates : void 0; + + if (samplingRatio && !isNaN(samplingRatio)) { + this.samplesGenerator.setSampleCount(parseInt(samplingRatio, 10)); + } + + if (allowSampleDuplicates) { + this.samplesGenerator.setAllowDuplicates(allowSampleDuplicates); + } + } + /** + * Recalculates all rows height (overwrite cache values). + */ + + }, { + key: "recalculateAllRowsHeight", + value: function recalculateAllRowsHeight() { + if (isVisible(this.hot.view.wt.wtTable.TABLE)) { + this.clearCache(); + this.calculateAllRowsHeight(); + } + } + /** + * Gets value which tells how many rows should be calculated synchronously (rest of the rows will be calculated + * asynchronously). The limit is calculated based on `syncLimit` set to autoRowSize option (see {@link Options#autoRowSize}). + * + * @returns {number} + */ + + }, { + key: "getSyncCalculationLimit", + value: function getSyncCalculationLimit() { + var settings = this.hot.getSettings()[PLUGIN_KEY$5]; + /* eslint-disable no-bitwise */ + + var limit = AutoRowSize.SYNC_CALCULATION_LIMIT; + var rowsLimit = this.hot.countRows() - 1; + + if (isObject$1(settings)) { + limit = settings.syncLimit; + + if (isPercentValue(limit)) { + limit = valueAccordingPercent(rowsLimit, limit); + } else { + // Force to Number + limit >>= 0; + } + } + + return Math.min(limit, rowsLimit); + } + /** + * Gets the calculated row height. + * + * @param {number} row Visual row index. + * @param {number} [defaultHeight] Default row height. It will be picked up if no calculated height found. + * @returns {number} + */ + + }, { + key: "getRowHeight", + value: function getRowHeight(row) { + var defaultHeight = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : void 0; + var cachedHeight = row < 0 ? this.headerHeight : this.rowHeightsMap.getValueAtIndex(this.hot.toPhysicalRow(row)); + var height = defaultHeight; + + if (cachedHeight !== null && cachedHeight > (defaultHeight || 0)) { + height = cachedHeight; + } + + return height; + } + /** + * Get the calculated column header height. + * + * @returns {number|undefined} + */ + + }, { + key: "getColumnHeaderHeight", + value: function getColumnHeaderHeight() { + return this.headerHeight; + } + /** + * Get the first visible row. + * + * @returns {number} Returns row index, -1 if table is not rendered or if there are no rows to base the the calculations on. + */ + + }, { + key: "getFirstVisibleRow", + value: function getFirstVisibleRow() { + var wot = this.hot.view.wt; + + if (wot.wtViewport.rowsVisibleCalculator) { + return wot.wtTable.getFirstVisibleRow(); + } + + if (wot.wtViewport.rowsRenderCalculator) { + return wot.wtTable.getFirstRenderedRow(); + } + + return -1; + } + /** + * Gets the last visible row. + * + * @returns {number} Returns row index or -1 if table is not rendered. + */ + + }, { + key: "getLastVisibleRow", + value: function getLastVisibleRow() { + var wot = this.hot.view.wt; + + if (wot.wtViewport.rowsVisibleCalculator) { + return wot.wtTable.getLastVisibleRow(); + } + + if (wot.wtViewport.rowsRenderCalculator) { + return wot.wtTable.getLastRenderedRow(); + } + + return -1; + } + /** + * Clears cached heights. + */ + + }, { + key: "clearCache", + value: function clearCache() { + this.headerHeight = null; + this.rowHeightsMap.init(); + } + /** + * Clears cache by range. + * + * @param {object|number} range Row index or an object with `from` and `to` properties which define row range. + */ + + }, { + key: "clearCacheByRange", + value: function clearCacheByRange(range) { + var _this6 = this; + + var _ref3 = typeof range === 'number' ? { + from: range, + to: range + } : range, + from = _ref3.from, + to = _ref3.to; + + this.hot.batchExecution(function () { + rangeEach(Math.min(from, to), Math.max(from, to), function (row) { + _this6.rowHeightsMap.setValueAtIndex(row, null); + }); + }, true); + } + /** + * Checks if all heights were calculated. If not then return `true` (need recalculate). + * + * @returns {boolean} + */ + + }, { + key: "isNeedRecalculate", + value: function isNeedRecalculate() { + return !!arrayFilter(this.rowHeightsMap.getValues().slice(0, this.measuredRows), function (item) { + return item === null; + }).length; + } + /** + * On before render listener. + * + * @private + */ + + }, { + key: "onBeforeRender", + value: function onBeforeRender() { + var force = this.hot.renderCall; + var fixedRowsBottom = this.hot.getSettings().fixedRowsBottom; + var firstVisibleRow = this.getFirstVisibleRow(); + var lastVisibleRow = this.getLastVisibleRow(); + + if (firstVisibleRow === -1 || lastVisibleRow === -1) { + return; + } + + this.calculateRowsHeight({ + from: firstVisibleRow, + to: lastVisibleRow + }, void 0, force); // Calculate rows height synchronously for bottom overlay + + if (fixedRowsBottom) { + var totalRows = this.hot.countRows() - 1; + this.calculateRowsHeight({ + from: totalRows - fixedRowsBottom, + to: totalRows + }); + } + + if (this.isNeedRecalculate() && !this.inProgress) { + this.calculateAllRowsHeight(); + } + } + /** + * On before row move listener. + * + * @private + * @param {number} from Row index where was grabbed. + * @param {number} to Destination row index. + */ + + }, { + key: "onBeforeRowMove", + value: function onBeforeRowMove(from, to) { + this.clearCacheByRange({ + from: from, + to: to + }); + this.calculateAllRowsHeight(); + } + /** + * On before row resize listener. + * + * @private + * @param {number} size The size of the current row index. + * @param {number} row Current row index. + * @param {boolean} isDblClick Indicates if the resize was triggered by doubleclick. + * @returns {number} + */ + + }, { + key: "onBeforeRowResize", + value: function onBeforeRowResize(size, row, isDblClick) { + var newSize = size; + + if (isDblClick) { + this.calculateRowsHeight(row, void 0, true); + newSize = this.getRowHeight(row); + } + + return newSize; + } + /** + * On after load data listener. + * + * @private + */ + + }, { + key: "onAfterLoadData", + value: function onAfterLoadData() { + var _this7 = this; + + if (this.hot.view) { + this.recalculateAllRowsHeight(); + } else { + // first load - initialization + setTimeout(function () { + if (_this7.hot) { + _this7.recalculateAllRowsHeight(); + } + }, 0); + } + } + /** + * On before change listener. + * + * @private + * @param {Array} changes 2D array containing information about each of the edited cells. + */ + + }, { + key: "onBeforeChange", + value: function onBeforeChange(changes) { + var range = null; + + if (changes.length === 1) { + range = changes[0][0]; + } else if (changes.length > 1) { + range = { + from: changes[0][0], + to: changes[changes.length - 1][0] + }; + } + + if (range !== null) { + this.clearCacheByRange(range); + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.rowIndexMapper.unregisterMap(ROW_WIDTHS_MAP_NAME); + this.ghostTable.clean(); + + _get$f(_getPrototypeOf$C(AutoRowSize.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$5; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$4; + } + }, { + key: "CALCULATION_STEP", + get: function get() { + return 50; + } + }, { + key: "SYNC_CALCULATION_LIMIT", + get: function get() { + return 500; + } + }]); + + return AutoRowSize; +}(BasePlugin); + +var $every = arrayIteration.every; + + +var STRICT_METHOD$7 = arrayMethodIsStrict('every'); + +// `Array.prototype.every` method +// https://tc39.es/ecma262/#sec-array.prototype.every +_export({ target: 'Array', proto: true, forced: !STRICT_METHOD$7 }, { + every: function every(callbackfn /* , thisArg */) { + return $every(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +function ownKeys$9(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$8(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$9(Object(source), true).forEach(function (key) { _defineProperty$e(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$9(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$e(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _slicedToArray$h(arr, i) { return _arrayWithHoles$h(arr) || _iterableToArrayLimit$h(arr, i) || _unsupportedIterableToArray$r(arr, i) || _nonIterableRest$h(); } + +function _nonIterableRest$h() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$r(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$r(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$r(o, minLen); } + +function _arrayLikeToArray$r(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$h(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$h(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$1n(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1i(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); } } + +function _createClass$1i(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1i(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1i(Constructor, staticProps); return Constructor; } +var inheritedColumnProperties = ['sortEmptyCells', 'indicator', 'headerAction', 'compareFunctionFactory']; +var SORT_EMPTY_CELLS_DEFAULT = false; +var SHOW_SORT_INDICATOR_DEFAULT = true; +var HEADER_ACTION_DEFAULT = true; +/** + * Store and manages states of sorted columns. + * + * @class ColumnStatesManager + * @plugin ColumnSorting + */ + +var ColumnStatesManager = /*#__PURE__*/function () { + function ColumnStatesManager(hot, mapName) { + _classCallCheck$1n(this, ColumnStatesManager); + + /** + * Handsontable instance. + * + * @type {Core} + */ + this.hot = hot; + /** + * Index map storing sorting states for every column. ColumnStatesManager write and read to/from this element. + * + * @type {LinkedPhysicalIndexToValueMap} + */ + + this.sortingStates = new LinkedPhysicalIndexToValueMap(); + /** + * Determines whether we should sort empty cells. + * + * @type {boolean} + */ + + this.sortEmptyCells = SORT_EMPTY_CELLS_DEFAULT; + /** + * Determines whether indicator should be visible (for sorted columns). + * + * @type {boolean} + */ + + this.indicator = SHOW_SORT_INDICATOR_DEFAULT; + /** + * Determines whether click on the header perform sorting. + * + * @type {boolean} + */ + + this.headerAction = HEADER_ACTION_DEFAULT; + /** + * Determines compare function factory. Method get as parameters `sortOder` and `columnMeta` and return compare function. + */ + + this.compareFunctionFactory = void 0; + /** + * Name of map storing sorting states. Required for unique name (PR #7440 introduced it). It's needed as + * both ColumnSorting and MultiColumnSorting plugins create state manager and as a consequence register maps. + * Objects are destroyed in strange order as the updateSettings doesn't work well. + */ + + this.mapName = mapName; + this.hot.columnIndexMapper.registerMap(mapName, this.sortingStates); + } + /** + * Update column properties which affect the sorting result. + * + * **Note**: All column properties can be overwritten by [columns](https://handsontable.com/docs/Options.html#columns) option. + * + * @param {object} allSortSettings Column sorting plugin's configuration object. + */ + + + _createClass$1i(ColumnStatesManager, [{ + key: "updateAllColumnsProperties", + value: function updateAllColumnsProperties(allSortSettings) { + var _this = this; + + if (!isObject$1(allSortSettings)) { + return; + } + + objectEach(allSortSettings, function (newValue, propertyName) { + if (inheritedColumnProperties.includes(propertyName)) { + _this[propertyName] = newValue; + } + }); + } + /** + * Get all column properties which affect the sorting result. + * + * @returns {object} + */ + + }, { + key: "getAllColumnsProperties", + value: function getAllColumnsProperties() { + var columnProperties = { + sortEmptyCells: this.sortEmptyCells, + indicator: this.indicator, + headerAction: this.headerAction + }; + + if (typeof this.compareFunctionFactory === 'function') { + columnProperties.compareFunctionFactory = this.compareFunctionFactory; + } + + return columnProperties; + } + /** + * Get sort order of column. + * + * @param {number} searchedColumn Visual column index. + * @returns {string|undefined} Sort order (`asc` for ascending, `desc` for descending and undefined for not sorted). + */ + + }, { + key: "getSortOrderOfColumn", + value: function getSortOrderOfColumn(searchedColumn) { + var _this$sortingStates$g; + + return (_this$sortingStates$g = this.sortingStates.getValueAtIndex(this.hot.toPhysicalColumn(searchedColumn))) === null || _this$sortingStates$g === void 0 ? void 0 : _this$sortingStates$g.sortOrder; + } + /** + * Get order of particular column in the states queue. + * + * @param {number} column Visual column index. + * @returns {number} + */ + + }, { + key: "getIndexOfColumnInSortQueue", + value: function getIndexOfColumnInSortQueue(column) { + column = this.hot.toPhysicalColumn(column); + return this.sortingStates.getEntries().findIndex(function (_ref) { + var _ref2 = _slicedToArray$h(_ref, 1), + physicalColumn = _ref2[0]; + + return physicalColumn === column; + }); + } + /** + * Get number of sorted columns. + * + * @returns {number} + */ + + }, { + key: "getNumberOfSortedColumns", + value: function getNumberOfSortedColumns() { + return this.sortingStates.getLength(); + } + /** + * Get if list of sorted columns is empty. + * + * @returns {boolean} + */ + + }, { + key: "isListOfSortedColumnsEmpty", + value: function isListOfSortedColumnsEmpty() { + return this.getNumberOfSortedColumns() === 0; + } + /** + * Get if particular column is sorted. + * + * @param {number} column Visual column index. + * @returns {boolean} + */ + + }, { + key: "isColumnSorted", + value: function isColumnSorted(column) { + return isObject$1(this.sortingStates.getValueAtIndex(this.hot.toPhysicalColumn(column))); + } + /** + * Queue of sort states containing sorted columns and their orders (Array of objects containing `column` and `sortOrder` properties). + * + * **Note**: Please keep in mind that returned objects expose **visual** column index under the `column` key. + * + * @returns {Array} + */ + + }, { + key: "getSortStates", + value: function getSortStates() { + var _this2 = this; + + if (this.sortingStates === null) { + return []; + } + + var sortingStatesQueue = this.sortingStates.getEntries(); + return sortingStatesQueue.map(function (_ref3) { + var _ref4 = _slicedToArray$h(_ref3, 2), + physicalColumn = _ref4[0], + value = _ref4[1]; + + return _objectSpread$8({ + column: _this2.hot.toVisualColumn(physicalColumn) + }, value); + }); + } + /** + * Get sort state for particular column. Object contains `column` and `sortOrder` properties. + * + * **Note**: Please keep in mind that returned objects expose **visual** column index under the `column` key. + * + * @param {number} column Visual column index. + * @returns {object|undefined} + */ + + }, { + key: "getColumnSortState", + value: function getColumnSortState(column) { + var sortOrder = this.getSortOrderOfColumn(column); + + if (isDefined(sortOrder)) { + return { + column: column, + sortOrder: sortOrder + }; + } + } + /** + * Set all column states. + * + * @param {Array} sortStates Sort states. + */ + + }, { + key: "setSortStates", + value: function setSortStates(sortStates) { + this.sortingStates.clear(); + + for (var i = 0; i < sortStates.length; i += 1) { + this.sortingStates.setValueAtIndex(this.hot.toPhysicalColumn(sortStates[i].column), { + sortOrder: sortStates[i].sortOrder + }); + } + } + /** + * Destroy the state manager. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.columnIndexMapper.unregisterMap(this.mapName); + this.sortingStates = null; + } + }]); + + return ColumnStatesManager; +}(); + +var ASC_SORT_STATE = 'asc'; +var DESC_SORT_STATE = 'desc'; +var HEADER_SPAN_CLASS = 'colHeader'; +/** + * Get if column state is valid. + * + * @param {number} columnState Particular column state. + * @returns {boolean} + */ + +function isValidColumnState(columnState) { + if (isObject$1(columnState) === false) { + return false; + } + + var column = columnState.column, + sortOrder = columnState.sortOrder; + return Number.isInteger(column) && [ASC_SORT_STATE, DESC_SORT_STATE].includes(sortOrder); +} +/** + * Get if all sorted columns states are valid. + * + * @param {Array} sortStates The sort state collection. + * @returns {boolean} + */ + + +function areValidSortStates(sortStates) { + if (sortStates.some(function (columnState) { + return isValidColumnState(columnState) === false; + })) { + return false; + } + + var sortedColumns = sortStates.map(function (_ref) { + var column = _ref.column; + return column; + }); // Indexes occurs only once. + + return new Set(sortedColumns).size === sortedColumns.length; +} +/** + * Get next sort order for particular column. The order sequence looks as follows: 'asc' -> 'desc' -> undefined -> 'asc'. + * + * @param {string|undefined} sortOrder Sort order (`asc` for ascending, `desc` for descending and undefined for not sorted). + * @returns {string|undefined} Next sort order (`asc` for ascending, `desc` for descending and undefined for not sorted). + */ + +function getNextSortOrder(sortOrder) { + if (sortOrder === DESC_SORT_STATE) { + return; + } else if (sortOrder === ASC_SORT_STATE) { + return DESC_SORT_STATE; + } + + return ASC_SORT_STATE; +} +/** + * Get `span` DOM element inside `th` DOM element. + * + * @param {Element} TH Th HTML element. + * @returns {Element | null} + */ + +function getHeaderSpanElement(TH) { + var headerSpanElement = TH.querySelector(".".concat(HEADER_SPAN_CLASS)); + return headerSpanElement; +} +/** + * + * Get if handled header is first level column header. + * + * @param {number} column Visual column index. + * @param {Element} TH Th HTML element. + * @returns {boolean} + */ + +function isFirstLevelColumnHeader(column, TH) { + if (column < 0 || !TH.parentNode) { + return false; + } + + var TRs = TH.parentNode.parentNode.childNodes; + var headerLevel = Array.from(TRs).indexOf(TH.parentNode) - TRs.length; + + if (headerLevel !== -1) { + return false; + } + + return true; +} +/** + * Get if header was clicked properly. Click on column header and NOT done by right click return `true`. + * + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {Event} clickEvent Click event. + * @returns {boolean} + */ + +function wasHeaderClickedProperly(row, column, clickEvent) { + return row === -1 && column >= 0 && isRightClick(clickEvent) === false; +} + +var HEADER_CLASS_ASC_SORT = 'ascending'; +var HEADER_CLASS_DESC_SORT = 'descending'; +var HEADER_CLASS_INDICATOR_DISABLED = 'indicatorDisabled'; +var HEADER_SORT_CLASS = 'columnSorting'; +var HEADER_ACTION_CLASS = 'sortAction'; +var orderToCssClass = new Map([[ASC_SORT_STATE, HEADER_CLASS_ASC_SORT], [DESC_SORT_STATE, HEADER_CLASS_DESC_SORT]]); +/** + * Get CSS classes which should be added to particular column header. + * + * @param {object} columnStatesManager Instance of column state manager. + * @param {number} column Visual column index. + * @param {boolean} showSortIndicator Indicates if indicator should be shown for the particular column. + * @param {boolean} headerAction Indicates if header click to sort should be possible. + * @returns {Array} Array of CSS classes. + */ + +function getClassesToAdd(columnStatesManager, column, showSortIndicator, headerAction) { + var cssClasses = [HEADER_SORT_CLASS]; + + if (headerAction) { + cssClasses.push(HEADER_ACTION_CLASS); + } + + if (showSortIndicator === false) { + cssClasses.push(HEADER_CLASS_INDICATOR_DISABLED); + return cssClasses; + } + + var columnOrder = columnStatesManager.getSortOrderOfColumn(column); + + if (isDefined(columnOrder)) { + cssClasses.push(orderToCssClass.get(columnOrder)); + } + + return cssClasses; +} +/** + * Get CSS classes which should be removed from column header. + * + * @returns {Array} Array of CSS classes. + */ + +function getClassesToRemove() { + return Array.from(orderToCssClass.values()).concat(HEADER_ACTION_CLASS, HEADER_CLASS_INDICATOR_DISABLED, HEADER_SORT_CLASS); +} + +/** + * Default sorting compare function factory. Method get as parameters `sortOrder` and `columnMeta` and return compare function. + * + * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending). + * @param {object} columnMeta Column meta object. + * @param {object} columnPluginSettings Plugin settings for the column. + * @returns {Function} The compare function. + */ + +function compareFunctionFactory(sortOrder, columnMeta, columnPluginSettings) { + return function (value, nextValue) { + var sortEmptyCells = columnPluginSettings.sortEmptyCells; + + if (typeof value === 'string') { + value = value.toLowerCase(); + } + + if (typeof nextValue === 'string') { + nextValue = nextValue.toLowerCase(); + } + + if (value === nextValue) { + return DO_NOT_SWAP; + } + + if (isEmpty(value)) { + if (isEmpty(nextValue)) { + return DO_NOT_SWAP; + } // Just fist value is empty and `sortEmptyCells` option was set + + + if (sortEmptyCells) { + return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND; + } + + return FIRST_AFTER_SECOND; + } + + if (isEmpty(nextValue)) { + // Just second value is empty and `sortEmptyCells` option was set + if (sortEmptyCells) { + return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND; + } + + return FIRST_BEFORE_SECOND; + } + + if (isNaN(value) && !isNaN(nextValue)) { + return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND; + } else if (!isNaN(value) && isNaN(nextValue)) { + return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND; + } else if (!(isNaN(value) || isNaN(nextValue))) { + value = parseFloat(value); + nextValue = parseFloat(nextValue); + } + + if (value < nextValue) { + return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND; + } + + if (value > nextValue) { + return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND; + } + + return DO_NOT_SWAP; + }; +} +var COLUMN_DATA_TYPE = 'default'; + +/** + * Numeric sorting compare function factory. Method get as parameters `sortOrder` and `columnMeta` and return compare function. + * + * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending). + * @param {object} columnMeta Column meta object. + * @param {object} columnPluginSettings Plugin settings for the column. + * @returns {Function} The compare function. + */ + +function compareFunctionFactory$1(sortOrder, columnMeta, columnPluginSettings) { + return function (value, nextValue) { + var parsedFirstValue = parseFloat(value); + var parsedSecondValue = parseFloat(nextValue); + var sortEmptyCells = columnPluginSettings.sortEmptyCells; // Watch out when changing this part of code! Check below returns 0 (as expected) when comparing empty string, null, undefined + + if (parsedFirstValue === parsedSecondValue || isNaN(parsedFirstValue) && isNaN(parsedSecondValue)) { + return DO_NOT_SWAP; + } + + if (sortEmptyCells) { + if (isEmpty(value)) { + return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND; + } + + if (isEmpty(nextValue)) { + return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND; + } + } + + if (isNaN(parsedFirstValue)) { + return FIRST_AFTER_SECOND; + } + + if (isNaN(parsedSecondValue)) { + return FIRST_BEFORE_SECOND; + } + + if (parsedFirstValue < parsedSecondValue) { + return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND; + } else if (parsedFirstValue > parsedSecondValue) { + return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND; + } + + return DO_NOT_SWAP; + }; +} +var COLUMN_DATA_TYPE$1 = 'numeric'; + +/** + * Date sorting compare function factory. Method get as parameters `sortOrder` and `columnMeta` and return compare function. + * + * @param {string} sortOrder Sort order (`asc` for ascending, `desc` for descending). + * @param {object} columnMeta Column meta object. + * @param {object} columnPluginSettings Plugin settings for the column. + * @returns {Function} The compare function. + */ + +function compareFunctionFactory$2(sortOrder, columnMeta, columnPluginSettings) { + return function (value, nextValue) { + var sortEmptyCells = columnPluginSettings.sortEmptyCells; + + if (value === nextValue) { + return DO_NOT_SWAP; + } + + if (isEmpty(value)) { + if (isEmpty(nextValue)) { + return DO_NOT_SWAP; + } // Just fist value is empty and `sortEmptyCells` option was set + + + if (sortEmptyCells) { + return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND; + } + + return FIRST_AFTER_SECOND; + } + + if (isEmpty(nextValue)) { + // Just second value is empty and `sortEmptyCells` option was set + if (sortEmptyCells) { + return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND; + } + + return FIRST_BEFORE_SECOND; + } + + var dateFormat = columnMeta.dateFormat; + var firstDate = moment(value, dateFormat); + var nextDate = moment(nextValue, dateFormat); + + if (!firstDate.isValid()) { + return FIRST_AFTER_SECOND; + } + + if (!nextDate.isValid()) { + return FIRST_BEFORE_SECOND; + } + + if (nextDate.isAfter(firstDate)) { + return sortOrder === 'asc' ? FIRST_BEFORE_SECOND : FIRST_AFTER_SECOND; + } + + if (nextDate.isBefore(firstDate)) { + return sortOrder === 'asc' ? FIRST_AFTER_SECOND : FIRST_BEFORE_SECOND; + } + + return DO_NOT_SWAP; + }; +} +var COLUMN_DATA_TYPE$2 = 'date'; + +var _staticRegister$7 = staticRegister('sorting.compareFunctionFactory'), + registerCompareFunctionFactory = _staticRegister$7.register, + getGloballyCompareFunctionFactory = _staticRegister$7.getItem, + hasGloballyCompareFunctionFactory = _staticRegister$7.hasItem; + +var _staticRegister2 = staticRegister('sorting.mainSortComparator'), + registerRootComparator = _staticRegister2.register, + getRootComparator = _staticRegister2.getItem; +/** + * Gets sort function for the particular column basing on it's data type. + * + * @param {string} type The data type. + * @returns {Function} + */ + + +function getCompareFunctionFactory(type) { + if (hasGloballyCompareFunctionFactory(type)) { + return getGloballyCompareFunctionFactory(type); + } + + return getGloballyCompareFunctionFactory(COLUMN_DATA_TYPE); +} +registerCompareFunctionFactory(COLUMN_DATA_TYPE$1, compareFunctionFactory$1); +registerCompareFunctionFactory(COLUMN_DATA_TYPE$2, compareFunctionFactory$2); +registerCompareFunctionFactory(COLUMN_DATA_TYPE, compareFunctionFactory); + +function _defineProperties$1j(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); } } + +function _createClass$1j(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1j(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1j(Constructor, staticProps); return Constructor; } + +function _classCallCheck$1o(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * Refactored implementation of LinkedList (part of javascript-algorithms project) by Github users: + * mgechev, AndriiHeonia, Microfed and Jakeh (part of javascript-algorithms project - all project contributors + * at repository website). + * + * Link to repository: https://github.com/mgechev/javascript-algorithms. + */ + +/** + * Linked list node. + * + * @class NodeStructure + * @util + */ +var NodeStructure = function NodeStructure(data) { + _classCallCheck$1o(this, NodeStructure); + + /** + * Data of the node. + * + * @member {object} + */ + this.data = data; + /** + * Next node. + * + * @member {NodeStructure} + */ + + this.next = null; + /** + * Previous node. + * + * @member {NodeStructure} + */ + + this.prev = null; +}; +/** + * Linked list. + * + * @class LinkedList + * @util + */ + + +var LinkedList = /*#__PURE__*/function () { + function LinkedList() { + _classCallCheck$1o(this, LinkedList); + + this.first = null; + this.last = null; + } + /** + * Add data to the end of linked list. + * + * @param {object} data Data which should be added. + */ + + + _createClass$1j(LinkedList, [{ + key: "push", + value: function push(data) { + var node = new NodeStructure(data); + + if (this.first === null) { + this.first = node; + this.last = node; + } else { + var temp = this.last; + this.last = node; + node.prev = temp; + temp.next = node; + } + } + /** + * Add data to the beginning of linked list. + * + * @param {object} data Data which should be added. + */ + + }, { + key: "unshift", + value: function unshift(data) { + var node = new NodeStructure(data); + + if (this.first === null) { + this.first = node; + this.last = node; + } else { + var temp = this.first; + this.first = node; + node.next = temp; + temp.prev = node; + } + } + /** + * In order traversal of the linked list. + * + * @param {Function} callback Callback which should be executed on each node. + */ + + }, { + key: "inorder", + value: function inorder(callback) { + var temp = this.first; + + while (temp) { + callback(temp); + temp = temp.next; + } + } + /** + * Remove data from the linked list. + * + * @param {object} data Data which should be removed. + * @returns {boolean} Returns true if data has been removed. + */ + + }, { + key: "remove", + value: function remove(data) { + if (this.first === null) { + return false; + } + + var temp = this.first; + var next; + var prev; + + while (temp) { + if (temp.data === data) { + next = temp.next; + prev = temp.prev; + + if (next) { + next.prev = prev; + } + + if (prev) { + prev.next = next; + } + + if (temp === this.first) { + this.first = next; + } + + if (temp === this.last) { + this.last = prev; + } + + return true; + } + + temp = temp.next; + } + + return false; + } + /** + * Check if linked list contains cycle. + * + * @returns {boolean} Returns true if linked list contains cycle. + */ + + }, { + key: "hasCycle", + value: function hasCycle() { + var fast = this.first; + var slow = this.first; + + while (true) { + if (fast === null) { + return false; + } + + fast = fast.next; + + if (fast === null) { + return false; + } + + fast = fast.next; + slow = slow.next; + + if (fast === slow) { + return true; + } + } + } + /** + * Return last node from the linked list. + * + * @returns {NodeStructure} Last node. + */ + + }, { + key: "pop", + value: function pop() { + if (this.last === null) { + return null; + } + + var temp = this.last; + this.last = this.last.prev; + return temp; + } + /** + * Return first node from the linked list. + * + * @returns {NodeStructure} First node. + */ + + }, { + key: "shift", + value: function shift() { + if (this.first === null) { + return null; + } + + var temp = this.first; + this.first = this.first.next; + return temp; + } + /** + * Reverses the linked list recursively. + */ + + }, { + key: "recursiveReverse", + value: function recursiveReverse() { + /** + * @param {*} current The current value. + * @param {*} next The next value. + */ + function inverse(current, next) { + if (!next) { + return; + } + + inverse(next, next.next); + next.next = current; + } + + if (!this.first) { + return; + } + + inverse(this.first, this.first.next); + this.first.next = null; + var temp = this.first; + this.first = this.last; + this.last = temp; + } + /** + * Reverses the linked list iteratively. + */ + + }, { + key: "reverse", + value: function reverse() { + if (!this.first || !this.first.next) { + return; + } + + var current = this.first.next; + var prev = this.first; + var temp; + + while (current) { + temp = current.next; + current.next = prev; + prev.prev = current; + prev = current; + current = temp; + } + + this.first.next = null; + this.last.prev = null; + temp = this.first; + this.first = prev; + this.last = temp; + } + }]); + + return LinkedList; +}(); + +/** + * Refactored implementation of mergeSort (part of javascript-algorithms project) by Github users: + * mgechev, AndriiHeonia and lekkas (part of javascript-algorithms project - all project contributors + * at repository website). + * + * Link to repository: https://github.com/mgechev/javascript-algorithms. + */ + +/** + * Specifies a function that defines the sort order. The array is sorted according to each + * character's Unicode code point value, according to the string conversion of each element. + * + * @param {*} a The first compared element. + * @param {*} b The second compared element. + * @returns {number} + */ + +var defaultCompareFunction = function defaultCompareFunction(a, b) { + // sort lexically + var firstValue = a.toString(); + var secondValue = b.toString(); + + if (firstValue === secondValue) { + return 0; + } else if (firstValue < secondValue) { + return -1; + } + + return 1; +}; +/** + * Mergesort method which is recursively called for sorting the input array. + * + * @param {Array} array The array which should be sorted. + * @param {Function} compareFunction Compares two items in an array. If compareFunction is not supplied, + * elements are sorted by converting them to strings and comparing strings in Unicode code point order. + * @param {number} startIndex Left side of the subarray. + * @param {number} endIndex Right side of the subarray. + * @returns {Array} Array with sorted subarray. + */ + + +function mergeSort(array) { + var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultCompareFunction; + var startIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; + var endIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length; + + // eslint-disable-line max-len + if (Math.abs(endIndex - startIndex) <= 1) { + return []; + } + + var middleIndex = Math.ceil((startIndex + endIndex) / 2); + mergeSort(array, compareFunction, startIndex, middleIndex); + mergeSort(array, compareFunction, middleIndex, endIndex); + return merge(array, compareFunction, startIndex, middleIndex, endIndex); +} +/** + * Devides and sort merges two subarrays of given array. + * + * @param {Array} array The array which subarrays should be sorted. + * @param {Function} compareFunction The function with comparision logic. + * @param {number} startIndex The start of the first subarray. + * This subarray is with end middle - 1. + * @param {number} middleIndex The start of the second array. + * @param {number} endIndex End - 1 is the end of the second array. + * @returns {Array} The array with sorted subarray. + */ + +function merge(array, compareFunction, startIndex, middleIndex, endIndex) { + var leftElements = new LinkedList(); + var rightElements = new LinkedList(); + var leftSize = middleIndex - startIndex; + var rightSize = endIndex - middleIndex; + var maxSize = Math.max(leftSize, rightSize); + var size = endIndex - startIndex; + + for (var _i = 0; _i < maxSize; _i += 1) { + if (_i < leftSize) { + leftElements.push(array[startIndex + _i]); + } + + if (_i < rightSize) { + rightElements.push(array[middleIndex + _i]); + } + } + + var i = 0; + + while (i < size) { + if (leftElements.first && rightElements.first) { + if (compareFunction(leftElements.first.data, rightElements.first.data) > 0) { + array[startIndex + i] = rightElements.shift().data; + } else { + array[startIndex + i] = leftElements.shift().data; + } + } else if (leftElements.first) { + array[startIndex + i] = leftElements.shift().data; + } else { + array[startIndex + i] = rightElements.shift().data; + } + + i += 1; + } + + return array; +} + +var DO_NOT_SWAP = 0; +var FIRST_BEFORE_SECOND = -1; +var FIRST_AFTER_SECOND = 1; +/** + * @param {Array} indexesWithData The data to sort. + * @param {string} rootComparatorId The comparator logic to use. + * @param {Array} argsForRootComparator Additional arguments for comparator function. + */ + +function sort(indexesWithData, rootComparatorId) { + var rootComparator = getRootComparator(rootComparatorId); + + for (var _len = arguments.length, argsForRootComparator = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { + argsForRootComparator[_key - 2] = arguments[_key]; + } + + mergeSort(indexesWithData, rootComparator.apply(void 0, argsForRootComparator)); +} + +function _toArray(arr) { return _arrayWithHoles$i(arr) || _iterableToArray$h(arr) || _unsupportedIterableToArray$s(arr) || _nonIterableRest$i(); } + +function _nonIterableRest$i() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$s(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$s(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$s(o, minLen); } + +function _arrayLikeToArray$s(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArray$h(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithHoles$i(arr) { if (Array.isArray(arr)) return arr; } +/** + * Sort comparator handled by conventional sort algorithm. + * + * @param {Array} sortingOrders Sort orders (`asc` for ascending, `desc` for descending). + * @param {Array} columnMetas Column meta objects. + * @returns {Function} + */ + +function rootComparator(sortingOrders, columnMetas) { + return function (rowIndexWithValues, nextRowIndexWithValues) { + // We sort array of arrays. Single array is in form [rowIndex, ...values]. + // We compare just values, stored at second index of array. + var _rowIndexWithValues = _toArray(rowIndexWithValues), + values = _rowIndexWithValues.slice(1); + + var _nextRowIndexWithValu = _toArray(nextRowIndexWithValues), + nextValues = _nextRowIndexWithValu.slice(1); + + return function getCompareResult(column) { + var sortingOrder = sortingOrders[column]; + var columnMeta = columnMetas[column]; + var value = values[column]; + var nextValue = nextValues[column]; + var pluginSettings = columnMeta.columnSorting; + var compareFunctionFactory = pluginSettings.compareFunctionFactory ? pluginSettings.compareFunctionFactory : getCompareFunctionFactory(columnMeta.type); + var compareResult = compareFunctionFactory(sortingOrder, columnMeta, pluginSettings)(value, nextValue); // DIFF - MultiColumnSorting & ColumnSorting: removed iteration through next sorted columns. + + return compareResult; + }(0); + }; +} + +function _typeof$O(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$O = function _typeof(obj) { return typeof obj; }; } else { _typeof$O = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$O(obj); } + +function _toConsumableArray$j(arr) { return _arrayWithoutHoles$h(arr) || _iterableToArray$i(arr) || _unsupportedIterableToArray$t(arr) || _nonIterableSpread$h(); } + +function _nonIterableSpread$h() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$t(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$t(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$t(o, minLen); } + +function _iterableToArray$i(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$h(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$t(arr); } + +function _arrayLikeToArray$t(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function ownKeys$a(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$9(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$a(Object(source), true).forEach(function (key) { _defineProperty$f(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$a(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$f(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _objectWithoutProperties$5(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$5(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose$5(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +function _classCallCheck$1p(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1k(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); } } + +function _createClass$1k(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1k(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1k(Constructor, staticProps); return Constructor; } + +function _get$g(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$g = Reflect.get; } else { _get$g = function _get(target, property, receiver) { var base = _superPropBase$g(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$g(target, property, receiver || target); } + +function _superPropBase$g(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$D(object); if (object === null) break; } return object; } + +function _inherits$D(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$E(subClass, superClass); } + +function _setPrototypeOf$E(o, p) { _setPrototypeOf$E = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$E(o, p); } + +function _createSuper$D(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$E(); return function _createSuperInternal() { var Super = _getPrototypeOf$D(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$D(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$D(this, result); }; } + +function _possibleConstructorReturn$D(self, call) { if (call && (_typeof$O(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$D(self); } + +function _assertThisInitialized$D(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$E() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$D(o) { _getPrototypeOf$D = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$D(o); } +var PLUGIN_KEY$6 = 'columnSorting'; +var PLUGIN_PRIORITY$5 = 50; +var APPEND_COLUMN_CONFIG_STRATEGY = 'append'; +var REPLACE_COLUMN_CONFIG_STRATEGY = 'replace'; +registerRootComparator(PLUGIN_KEY$6, rootComparator); +Hooks.getSingleton().register('beforeColumnSort'); +Hooks.getSingleton().register('afterColumnSort'); // DIFF - MultiColumnSorting & ColumnSorting: changed configuration documentation. + +/** + * @plugin ColumnSorting + * + * @description + * This plugin sorts the view by columns (but does not sort the data source!). To enable the plugin, set the + * {@link Options#columnSorting} property to the correct value (see the examples below). + * + * @example + * ```js + * // as boolean + * columnSorting: true + * + * // as an object with initial sort config (sort ascending for column at index 1) + * columnSorting: { + * initialConfig: { + * column: 1, + * sortOrder: 'asc' + * } + * } + * + * // as an object which define specific sorting options for all columns + * columnSorting: { + * sortEmptyCells: true, // true = the table sorts empty cells, false = the table moves all empty cells to the end of the table (by default) + * indicator: true, // true = shows indicator for all columns (by default), false = don't show indicator for columns + * headerAction: true, // true = allow to click on the headers to sort (by default), false = turn off possibility to click on the headers to sort + * compareFunctionFactory: function(sortOrder, columnMeta) { + * return function(value, nextValue) { + * // Some value comparisons which will return -1, 0 or 1... + * } + * } + * } + * + * // as an object passed to the `column` property, allows specifying a custom options for the desired column. + * // please take a look at documentation of `column` property: https://handsontable.com/docs/Options.html#columns + * columns: [{ + * columnSorting: { + * indicator: false, // disable indicator for the first column, + * sortEmptyCells: true, + * headerAction: false, // clicks on the first column won't sort + * compareFunctionFactory: function(sortOrder, columnMeta) { + * return function(value, nextValue) { + * return 0; // Custom compare function for the first column (don't sort) + * } + * } + * } + * }]``` + */ + +var ColumnSorting = /*#__PURE__*/function (_BasePlugin) { + _inherits$D(ColumnSorting, _BasePlugin); + + var _super = _createSuper$D(ColumnSorting); + + function ColumnSorting(hotInstance) { + var _this; + + _classCallCheck$1p(this, ColumnSorting); + + _this = _super.call(this, hotInstance); + /** + * Instance of column state manager. + * + * @private + * @type {null|ColumnStatesManager} + */ + + _this.columnStatesManager = null; + /** + * Cached column properties from plugin like i.e. `indicator`, `headerAction`. + * + * @private + * @type {null|PhysicalIndexToValueMap} + */ + + _this.columnMetaCache = null; + /** + * Main settings key designed for the plugin. + * + * @private + * @type {string} + */ + + _this.pluginKey = PLUGIN_KEY$6; + /** + * Plugin indexes cache. + * + * @private + * @type {null|IndexesSequence} + */ + + _this.indexesSequenceCache = null; + return _this; + } + /** + * Checks if the plugin is enabled in the Handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ColumnSorting#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1k(ColumnSorting, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[this.pluginKey]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.columnStatesManager = new ColumnStatesManager(this.hot, "".concat(this.pluginKey, ".sortingStates")); + this.columnMetaCache = new PhysicalIndexToValueMap(function (physicalIndex) { + var visualIndex = _this2.hot.toVisualColumn(physicalIndex); + + if (visualIndex === null) { + visualIndex = physicalIndex; + } + + return _this2.getMergedPluginSettings(visualIndex); + }); + this.hot.columnIndexMapper.registerMap("".concat(this.pluginKey, ".columnMeta"), this.columnMetaCache); + this.addHook('afterGetColHeader', function (column, TH) { + return _this2.onAfterGetColHeader(column, TH); + }); + this.addHook('beforeOnCellMouseDown', function (event, coords, TD, controller) { + return _this2.onBeforeOnCellMouseDown(event, coords, TD, controller); + }); + this.addHook('afterOnCellMouseDown', function (event, target) { + return _this2.onAfterOnCellMouseDown(event, target); + }); + this.addHook('afterInit', function () { + return _this2.loadOrSortBySettings(); + }); + this.addHook('afterLoadData', function (sourceData, initialLoad) { + return _this2.onAfterLoadData(initialLoad); + }); // TODO: Workaround? It should be refactored / described. + + if (this.hot.view) { + this.loadOrSortBySettings(); + } + + _get$g(_getPrototypeOf$D(ColumnSorting.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + var _this3 = this; + + var clearColHeader = function clearColHeader(column, TH) { + var headerSpanElement = getHeaderSpanElement(TH); + + if (isFirstLevelColumnHeader(column, TH) === false || headerSpanElement === null) { + return; + } + + _this3.updateHeaderClasses(headerSpanElement); + }; // Changing header width and removing indicator. + + + this.hot.addHook('afterGetColHeader', clearColHeader); + this.hot.addHookOnce('afterRender', function () { + _this3.hot.removeHook('afterGetColHeader', clearColHeader); + }); + this.hot.batchExecution(function () { + if (_this3.indexesSequenceCache !== null) { + _this3.hot.rowIndexMapper.setIndexesSequence(_this3.indexesSequenceCache.getValues()); + + _this3.hot.rowIndexMapper.unregisterMap(_this3.pluginKey); + } + }, true); + this.hot.columnIndexMapper.unregisterMap("".concat(this.pluginKey, ".columnMeta")); + this.columnStatesManager.destroy(); + this.columnMetaCache = null; + this.columnStatesManager = null; + + _get$g(_getPrototypeOf$D(ColumnSorting.prototype), "disablePlugin", this).call(this); + } // DIFF - MultiColumnSorting & ColumnSorting: changed function documentation. + + /** + * Sorts the table by chosen columns and orders. + * + * @param {undefined|object} sortConfig Single column sort configuration. The configuration object contains `column` and `sortOrder` properties. + * First of them contains visual column index, the second one contains sort order (`asc` for ascending, `desc` for descending). + * + * **Note**: Please keep in mind that every call of `sort` function set an entirely new sort order. Previous sort configs aren't preserved. + * + * @example + * ```js + * // sort ascending first visual column + * hot.getPlugin('columnSorting').sort({ column: 0, sortOrder: 'asc' }); + * ``` + * + * @fires Hooks#beforeColumnSort + * @fires Hooks#afterColumnSort + */ + + }, { + key: "sort", + value: function sort(sortConfig) { + var currentSortConfig = this.getSortConfig(); // We always pass configs defined as an array to `beforeColumnSort` and `afterColumnSort` hooks. + + var destinationSortConfigs = this.getNormalizedSortConfigs(sortConfig); + var sortPossible = this.areValidSortConfigs(destinationSortConfigs); + var allowSort = this.hot.runHooks('beforeColumnSort', currentSortConfig, destinationSortConfigs, sortPossible); + + if (allowSort === false) { + return; + } + + if (currentSortConfig.length === 0 && this.indexesSequenceCache === null) { + this.indexesSequenceCache = this.hot.rowIndexMapper.registerMap(this.pluginKey, new IndexesSequence()); + this.indexesSequenceCache.setValues(this.hot.rowIndexMapper.getIndexesSequence()); + } + + if (sortPossible) { + this.columnStatesManager.setSortStates(destinationSortConfigs); + this.sortByPresetSortStates(destinationSortConfigs); + this.saveAllSortSettings(destinationSortConfigs); + } + + this.hot.runHooks('afterColumnSort', currentSortConfig, sortPossible ? destinationSortConfigs : currentSortConfig, sortPossible); + + if (sortPossible) { + this.hot.render(); // TODO: Workaround? This triggers fast redraw. One test won't pass after removal. + // It should be refactored / described. + + this.hot.forceFullRender = false; + this.hot.view.render(); + } + } + /** + * Clear the sort performed on the table. + */ + + }, { + key: "clearSort", + value: function clearSort() { + this.sort([]); + } + /** + * Checks if the table is sorted (any column have to be sorted). + * + * @returns {boolean} + */ + + }, { + key: "isSorted", + value: function isSorted() { + return this.enabled && !this.columnStatesManager.isListOfSortedColumnsEmpty(); + } + /** + * Get sort configuration for particular column or for all sorted columns. Objects contain `column` and `sortOrder` properties. + * + * **Note**: Please keep in mind that returned objects expose **visual** column index under the `column` key. They are handled by the `sort` function. + * + * @param {number} [column] Visual column index. + * @returns {undefined|object|Array} + */ + + }, { + key: "getSortConfig", + value: function getSortConfig(column) { + if (isDefined(column)) { + return this.columnStatesManager.getColumnSortState(column); + } + + return this.columnStatesManager.getSortStates(); + } + /** + * @description + * Warn: Useful mainly for providing server side sort implementation (see in the example below). It doesn't sort the data set. It just sets sort configuration for all sorted columns. + * Note: Please keep in mind that this method doesn't re-render the table. + * + * @example + * ```js + * beforeColumnSort: function(currentSortConfig, destinationSortConfigs) { + * const columnSortPlugin = this.getPlugin('columnSorting'); + * + * columnSortPlugin.setSortConfig(destinationSortConfigs); + * + * // const newData = ... // Calculated data set, ie. from an AJAX call. + * + * this.loadData(newData); // Load new data set and re-render the table. + * + * return false; // The blockade for the default sort action. + * }``` + * + * @param {undefined|object|Array} sortConfig Single column sort configuration or full sort configuration (for all sorted columns). + * The configuration object contains `column` and `sortOrder` properties. First of them contains visual column index, the second one contains + * sort order (`asc` for ascending, `desc` for descending). + */ + + }, { + key: "setSortConfig", + value: function setSortConfig(sortConfig) { + // We always set configs defined as an array. + var destinationSortConfigs = this.getNormalizedSortConfigs(sortConfig); + + if (this.areValidSortConfigs(destinationSortConfigs)) { + this.columnStatesManager.setSortStates(destinationSortConfigs); + } + } + /** + * Get normalized sort configs. + * + * @private + * @param {object|Array} [sortConfig=[]] Single column sort configuration or full sort configuration (for all sorted columns). + * The configuration object contains `column` and `sortOrder` properties. First of them contains visual column index, the second one contains + * sort order (`asc` for ascending, `desc` for descending). + * @returns {Array} + */ + + }, { + key: "getNormalizedSortConfigs", + value: function getNormalizedSortConfigs() { + var sortConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + + if (Array.isArray(sortConfig)) { + return sortConfig.slice(0, 1); + } + + return [sortConfig]; + } + /** + * Get if sort configs are valid. + * + * @private + * @param {Array} sortConfigs Sort configuration for all sorted columns. Objects contain `column` and `sortOrder` properties. + * @returns {boolean} + */ + + }, { + key: "areValidSortConfigs", + value: function areValidSortConfigs(sortConfigs) { + var numberOfColumns = this.hot.countCols(); // We don't translate visual indexes to physical indexes. + + return areValidSortStates(sortConfigs) && sortConfigs.every(function (_ref) { + var column = _ref.column; + return column <= numberOfColumns && column >= 0; + }); + } + /** + * Saves all sorting settings. Saving works only when {@link Options#persistentState} option is enabled. + * + * @param {Array} sortConfigs Sort configuration for all sorted columns. Objects contain `column` and `sortOrder` properties. + * + * @private + * @fires Hooks#persistentStateSave + */ + + }, { + key: "saveAllSortSettings", + value: function saveAllSortSettings(sortConfigs) { + var _this4 = this; + + var allSortSettings = this.columnStatesManager.getAllColumnsProperties(); + + var translateColumnToPhysical = function translateColumnToPhysical(_ref2) { + var visualColumn = _ref2.column, + restOfProperties = _objectWithoutProperties$5(_ref2, ["column"]); + + return _objectSpread$9({ + column: _this4.hot.toPhysicalColumn(visualColumn) + }, restOfProperties); + }; + + allSortSettings.initialConfig = arrayMap(sortConfigs, translateColumnToPhysical); + this.hot.runHooks('persistentStateSave', 'columnSorting', allSortSettings); + } + /** + * Get all saved sorting settings. Loading works only when {@link Options#persistentState} option is enabled. + * + * @private + * @returns {object} Previously saved sort settings. + * + * @fires Hooks#persistentStateLoad + */ + + }, { + key: "getAllSavedSortSettings", + value: function getAllSavedSortSettings() { + var _this5 = this; + + var storedAllSortSettings = {}; + this.hot.runHooks('persistentStateLoad', 'columnSorting', storedAllSortSettings); + var allSortSettings = storedAllSortSettings.value; + + var translateColumnToVisual = function translateColumnToVisual(_ref3) { + var physicalColumn = _ref3.column, + restOfProperties = _objectWithoutProperties$5(_ref3, ["column"]); + + return _objectSpread$9({ + column: _this5.hot.toVisualColumn(physicalColumn) + }, restOfProperties); + }; + + if (isDefined(allSortSettings) && Array.isArray(allSortSettings.initialConfig)) { + allSortSettings.initialConfig = arrayMap(allSortSettings.initialConfig, translateColumnToVisual); + } + + return allSortSettings; + } + /** + * Get next sort configuration for particular column. Object contain `column` and `sortOrder` properties. + * + * **Note**: Please keep in mind that returned object expose **visual** column index under the `column` key. + * + * @private + * @param {number} column Visual column index. + * @returns {undefined|object} + */ + + }, { + key: "getColumnNextConfig", + value: function getColumnNextConfig(column) { + var sortOrder = this.columnStatesManager.getSortOrderOfColumn(column); + + if (isDefined(sortOrder)) { + var nextSortOrder = getNextSortOrder(sortOrder); + + if (isDefined(nextSortOrder)) { + return { + column: column, + sortOrder: nextSortOrder + }; + } + + return; + } + + var nrOfColumns = this.hot.countCols(); + + if (Number.isInteger(column) && column >= 0 && column < nrOfColumns) { + return { + column: column, + sortOrder: getNextSortOrder() + }; + } + } + /** + * Get sort configuration with "next order" for particular column. + * + * @private + * @param {number} columnToChange Visual column index of column which order will be changed. + * @param {string} strategyId ID of strategy. Possible values: 'append' and 'replace'. The first one + * change order of particular column and change it's position in the sort queue to the last one. The second one + * just change order of particular column. + * + * **Note**: Please keep in mind that returned objects expose **visual** column index under the `column` key. + * + * @returns {Array} + */ + + }, { + key: "getNextSortConfig", + value: function getNextSortConfig(columnToChange) { + var strategyId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : APPEND_COLUMN_CONFIG_STRATEGY; + var indexOfColumnToChange = this.columnStatesManager.getIndexOfColumnInSortQueue(columnToChange); + var isColumnSorted = indexOfColumnToChange !== -1; + var currentSortConfig = this.getSortConfig(); + var nextColumnConfig = this.getColumnNextConfig(columnToChange); + + if (isColumnSorted) { + if (isUndefined(nextColumnConfig)) { + return [].concat(_toConsumableArray$j(currentSortConfig.slice(0, indexOfColumnToChange)), _toConsumableArray$j(currentSortConfig.slice(indexOfColumnToChange + 1))); + } + + if (strategyId === APPEND_COLUMN_CONFIG_STRATEGY) { + return [].concat(_toConsumableArray$j(currentSortConfig.slice(0, indexOfColumnToChange)), _toConsumableArray$j(currentSortConfig.slice(indexOfColumnToChange + 1)), [nextColumnConfig]); + } else if (strategyId === REPLACE_COLUMN_CONFIG_STRATEGY) { + return [].concat(_toConsumableArray$j(currentSortConfig.slice(0, indexOfColumnToChange)), [nextColumnConfig], _toConsumableArray$j(currentSortConfig.slice(indexOfColumnToChange + 1))); + } + } + + if (isDefined(nextColumnConfig)) { + return currentSortConfig.concat(nextColumnConfig); + } + + return currentSortConfig; + } + /** + * Get plugin's column config for the specified column index. + * + * @private + * @param {object} columnConfig Configuration inside `columns` property for the specified column index. + * @returns {object} + */ + + }, { + key: "getPluginColumnConfig", + value: function getPluginColumnConfig(columnConfig) { + if (isObject$1(columnConfig)) { + var pluginColumnConfig = columnConfig[this.pluginKey]; + + if (isObject$1(pluginColumnConfig)) { + return pluginColumnConfig; + } + } + + return {}; + } + /** + * Get plugin settings related properties, properly merged from cascade settings. + * + * @private + * @param {number} column Visual column index. + * @returns {object} + */ + + }, { + key: "getMergedPluginSettings", + value: function getMergedPluginSettings(column) { + var pluginMainSettings = this.hot.getSettings()[this.pluginKey]; + var storedColumnProperties = this.columnStatesManager.getAllColumnsProperties(); + var cellMeta = this.hot.getCellMeta(0, column); + var columnMeta = Object.getPrototypeOf(cellMeta); + + if (Array.isArray(columnMeta.columns)) { + return Object.assign(storedColumnProperties, pluginMainSettings, this.getPluginColumnConfig(columnMeta.columns[column])); + } else if (isFunction(columnMeta.columns)) { + return Object.assign(storedColumnProperties, pluginMainSettings, this.getPluginColumnConfig(columnMeta.columns(column))); + } + + return Object.assign(storedColumnProperties, pluginMainSettings); + } + /** + * Get copy of settings for first cell in the column. + * + * @private + * @param {number} column Visual column index. + * @returns {object} + */ + // TODO: Workaround. Inheriting of non-primitive cell meta values doesn't work. Instead of getting properties from column meta we call this function. + // TODO: Remove test named: "should not break the dataset when inserted new row" (#5431). + + }, { + key: "getFirstCellSettings", + value: function getFirstCellSettings(column) { + var cellMeta = this.hot.getCellMeta(0, column); + var cellMetaCopy = Object.create(cellMeta); + cellMetaCopy[this.pluginKey] = this.columnMetaCache.getValueAtIndex(this.hot.toPhysicalColumn(column)); + return cellMetaCopy; + } + /** + * Get number of rows which should be sorted. + * + * @private + * @param {number} numberOfRows Total number of displayed rows. + * @returns {number} + */ + + }, { + key: "getNumberOfRowsToSort", + value: function getNumberOfRowsToSort(numberOfRows) { + var settings = this.hot.getSettings(); // `maxRows` option doesn't take into account `minSpareRows` option in this case. + + if (settings.maxRows <= numberOfRows) { + return settings.maxRows; + } + + return numberOfRows - settings.minSpareRows; + } + /** + * Performs the sorting using a stable sort function basing on internal state of sorting. + * + * @param {Array} sortConfigs Sort configuration for all sorted columns. Objects contain `column` and `sortOrder` properties. + * @private + */ + + }, { + key: "sortByPresetSortStates", + value: function sortByPresetSortStates(sortConfigs) { + var _this6 = this; + + if (sortConfigs.length === 0) { + this.hot.rowIndexMapper.setIndexesSequence(this.indexesSequenceCache.getValues()); + return; + } + + var indexesWithData = []; + var numberOfRows = this.hot.countRows(); + + var getDataForSortedColumns = function getDataForSortedColumns(visualRowIndex) { + return arrayMap(sortConfigs, function (sortConfig) { + return _this6.hot.getDataAtCell(visualRowIndex, sortConfig.column); + }); + }; + + for (var visualRowIndex = 0; visualRowIndex < this.getNumberOfRowsToSort(numberOfRows); visualRowIndex += 1) { + indexesWithData.push([this.hot.toPhysicalRow(visualRowIndex)].concat(getDataForSortedColumns(visualRowIndex))); + } + + var indexesBefore = arrayMap(indexesWithData, function (indexWithData) { + return indexWithData[0]; + }); + sort(indexesWithData, this.pluginKey, arrayMap(sortConfigs, function (sortConfig) { + return sortConfig.sortOrder; + }), arrayMap(sortConfigs, function (sortConfig) { + return _this6.getFirstCellSettings(sortConfig.column); + })); // Append spareRows + + for (var _visualRowIndex = indexesWithData.length; _visualRowIndex < numberOfRows; _visualRowIndex += 1) { + indexesWithData.push([_visualRowIndex].concat(getDataForSortedColumns(_visualRowIndex))); + } + + var indexesAfter = arrayMap(indexesWithData, function (indexWithData) { + return indexWithData[0]; + }); + var indexMapping = new Map(arrayMap(indexesBefore, function (indexBefore, indexInsideArray) { + return [indexBefore, indexesAfter[indexInsideArray]]; + })); + var newIndexesSequence = arrayMap(this.hot.rowIndexMapper.getIndexesSequence(), function (physicalIndex) { + if (indexMapping.has(physicalIndex)) { + return indexMapping.get(physicalIndex); + } + + return physicalIndex; + }); + this.hot.rowIndexMapper.setIndexesSequence(newIndexesSequence); + } + /** + * Load saved settings or sort by predefined plugin configuration. + * + * @private + */ + + }, { + key: "loadOrSortBySettings", + value: function loadOrSortBySettings() { + var storedAllSortSettings = this.getAllSavedSortSettings(); + + if (isObject$1(storedAllSortSettings)) { + this.sortBySettings(storedAllSortSettings); + } else { + var allSortSettings = this.hot.getSettings()[this.pluginKey]; + this.sortBySettings(allSortSettings); + } + } + /** + * Sort the table by provided configuration. + * + * @private + * @param {object} allSortSettings All sort config settings. Object may contain `initialConfig`, `indicator`, + * `sortEmptyCells`, `headerAction` and `compareFunctionFactory` properties. + */ + + }, { + key: "sortBySettings", + value: function sortBySettings(allSortSettings) { + if (isObject$1(allSortSettings)) { + this.columnStatesManager.updateAllColumnsProperties(allSortSettings); + var initialConfig = allSortSettings.initialConfig; + + if (Array.isArray(initialConfig) || isObject$1(initialConfig)) { + this.sort(initialConfig); + } + } else { + // Extra render for headers. Their width may change. + this.hot.render(); + } + } + /** + * Callback for the `onAfterGetColHeader` hook. Adds column sorting CSS classes. + * + * @private + * @param {number} column Visual column index. + * @param {Element} TH TH HTML element. + */ + + }, { + key: "onAfterGetColHeader", + value: function onAfterGetColHeader(column, TH) { + var headerSpanElement = getHeaderSpanElement(TH); + + if (isFirstLevelColumnHeader(column, TH) === false || headerSpanElement === null) { + return; + } + + var pluginSettingsForColumn = this.getFirstCellSettings(column)[this.pluginKey]; + var showSortIndicator = pluginSettingsForColumn.indicator; + var headerActionEnabled = pluginSettingsForColumn.headerAction; + this.updateHeaderClasses(headerSpanElement, this.columnStatesManager, column, showSortIndicator, headerActionEnabled); + } + /** + * Update header classes. + * + * @private + * @param {HTMLElement} headerSpanElement Header span element. + * @param {...*} args Extra arguments for helpers. + */ + + }, { + key: "updateHeaderClasses", + value: function updateHeaderClasses(headerSpanElement) { + removeClass(headerSpanElement, getClassesToRemove()); + + if (this.enabled !== false) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + addClass(headerSpanElement, getClassesToAdd.apply(void 0, args)); + } + } + /** + * Overwriting base plugin's `onUpdateSettings` method. Please keep in mind that `onAfterUpdateSettings` isn't called + * for `updateSettings` in specific situations. + * + * @private + * @param {object} newSettings New settings object. + */ + + }, { + key: "onUpdateSettings", + value: function onUpdateSettings(newSettings) { + _get$g(_getPrototypeOf$D(ColumnSorting.prototype), "onUpdateSettings", this).call(this); + + if (this.columnMetaCache !== null) { + // Column meta cache base on settings, thus we should re-init the map. + this.columnMetaCache.init(this.hot.columnIndexMapper.getNumberOfIndexes()); + } + + if (isDefined(newSettings[this.pluginKey])) { + this.sortBySettings(newSettings[this.pluginKey]); + } + } + /** + * Callback for the `afterLoadData` hook. + * + * @private + * @param {boolean} initialLoad Flag that determines whether the data has been loaded during the initialization. + */ + + }, { + key: "onAfterLoadData", + value: function onAfterLoadData(initialLoad) { + if (initialLoad === true) { + // TODO: Workaround? It should be refactored / described. + if (this.hot.view) { + this.loadOrSortBySettings(); + } + } + } + /** + * Indicates if clickable header was clicked. + * + * @private + * @param {MouseEvent} event The `mousedown` event. + * @param {number} column Visual column index. + * @returns {boolean} + */ + + }, { + key: "wasClickableHeaderClicked", + value: function wasClickableHeaderClicked(event, column) { + var pluginSettingsForColumn = this.getFirstCellSettings(column)[this.pluginKey]; + var headerActionEnabled = pluginSettingsForColumn.headerAction; + return headerActionEnabled && event.target.nodeName === 'SPAN'; + } + /** + * Changes the behavior of selection / dragging. + * + * @private + * @param {MouseEvent} event The `mousedown` event. + * @param {CellCoords} coords Visual coordinates. + * @param {HTMLElement} TD The cell element. + * @param {object} blockCalculations A literal object which holds boolean values which controls + * how the selection while selecting neighboring cells. + */ + + }, { + key: "onBeforeOnCellMouseDown", + value: function onBeforeOnCellMouseDown(event, coords, TD, blockCalculations) { + if (wasHeaderClickedProperly(coords.row, coords.col, event) === false) { + return; + } + + if (this.wasClickableHeaderClicked(event, coords.col) && isPressedCtrlKey()) { + blockCalculations.column = true; + } + } + /** + * Callback for the `onAfterOnCellMouseDown` hook. + * + * @private + * @param {Event} event Event which are provided by hook. + * @param {CellCoords} coords Visual coords of the selected cell. + */ + + }, { + key: "onAfterOnCellMouseDown", + value: function onAfterOnCellMouseDown(event, coords) { + if (wasHeaderClickedProperly(coords.row, coords.col, event) === false) { + return; + } + + if (this.wasClickableHeaderClicked(event, coords.col)) { + if (isPressedCtrlKey()) { + this.hot.deselectCell(); + this.hot.selectColumns(coords.col); + } + + this.sort(this.getColumnNextConfig(coords.col)); + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + var _this$columnStatesMan; + + // TODO: Probably not supported yet by ESLint: https://github.com/eslint/eslint/issues/11045 + // eslint-disable-next-line no-unused-expressions + (_this$columnStatesMan = this.columnStatesManager) === null || _this$columnStatesMan === void 0 ? void 0 : _this$columnStatesMan.destroy(); + this.hot.rowIndexMapper.unregisterMap(this.pluginKey); + this.hot.columnIndexMapper.unregisterMap("".concat(this.pluginKey, ".columnMeta")); + + _get$g(_getPrototypeOf$D(ColumnSorting.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$6; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$5; + } + }]); + + return ColumnSorting; +}(BasePlugin); + +function _classCallCheck$1q(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1l(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); } } + +function _createClass$1l(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1l(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1l(Constructor, staticProps); return Constructor; } +/** + * Comment editor for the Comments plugin. + * + * @class CommentEditor + * @plugin Comments + */ + +var CommentEditor = /*#__PURE__*/function () { + function CommentEditor(rootDocument) { + _classCallCheck$1q(this, CommentEditor); + + this.container = null; + this.rootDocument = rootDocument; + this.editor = this.createEditor(); + this.editorStyle = this.editor.style; + this.hidden = true; + this.hide(); + } + /** + * Set position of the comments editor according to the provided x and y coordinates. + * + * @param {number} x X position (in pixels). + * @param {number} y Y position (in pixels). + */ + + + _createClass$1l(CommentEditor, [{ + key: "setPosition", + value: function setPosition(x, y) { + this.editorStyle.left = "".concat(x, "px"); + this.editorStyle.top = "".concat(y, "px"); + } + /** + * Set the editor size according to the provided arguments. + * + * @param {number} width Width in pixels. + * @param {number} height Height in pixels. + */ + + }, { + key: "setSize", + value: function setSize(width, height) { + if (width && height) { + var input = this.getInputElement(); + input.style.width = "".concat(width, "px"); + input.style.height = "".concat(height, "px"); + } + } + /** + * Reset the editor size to its initial state. + */ + + }, { + key: "resetSize", + value: function resetSize() { + var input = this.getInputElement(); + input.style.width = ''; + input.style.height = ''; + } + /** + * Set the read-only state for the comments editor. + * + * @param {boolean} state The new read only state. + */ + + }, { + key: "setReadOnlyState", + value: function setReadOnlyState(state) { + var input = this.getInputElement(); + input.readOnly = state; + } + /** + * Show the comments editor. + */ + + }, { + key: "show", + value: function show() { + this.editorStyle.display = 'block'; + this.hidden = false; + } + /** + * Hide the comments editor. + */ + + }, { + key: "hide", + value: function hide() { + this.editorStyle.display = 'none'; + this.hidden = true; + } + /** + * Checks if the editor is visible. + * + * @returns {boolean} + */ + + }, { + key: "isVisible", + value: function isVisible() { + return this.editorStyle.display === 'block'; + } + /** + * Set the comment value. + * + * @param {string} [value] The value to use. + */ + + }, { + key: "setValue", + value: function setValue() { + var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + var comment = value || ''; + this.getInputElement().value = comment; + } + /** + * Get the comment value. + * + * @returns {string} + */ + + }, { + key: "getValue", + value: function getValue() { + return this.getInputElement().value; + } + /** + * Checks if the comment input element is focused. + * + * @returns {boolean} + */ + + }, { + key: "isFocused", + value: function isFocused() { + return this.rootDocument.activeElement === this.getInputElement(); + } + /** + * Focus the comments input element. + */ + + }, { + key: "focus", + value: function focus() { + this.getInputElement().focus(); + } + /** + * Create the `textarea` to be used as a comments editor. + * + * @returns {HTMLElement} + */ + + }, { + key: "createEditor", + value: function createEditor() { + var editor = this.rootDocument.createElement('div'); + var textArea = this.rootDocument.createElement('textarea'); + this.container = this.rootDocument.querySelector(".".concat(CommentEditor.CLASS_EDITOR_CONTAINER)); + + if (!this.container) { + this.container = this.rootDocument.createElement('div'); + addClass(this.container, CommentEditor.CLASS_EDITOR_CONTAINER); + this.rootDocument.body.appendChild(this.container); + } + + addClass(editor, CommentEditor.CLASS_EDITOR); + addClass(textArea, CommentEditor.CLASS_INPUT); + editor.appendChild(textArea); + this.container.appendChild(editor); + return editor; + } + /** + * Get the input element. + * + * @returns {HTMLElement} + */ + + }, { + key: "getInputElement", + value: function getInputElement() { + return this.editor.querySelector(".".concat(CommentEditor.CLASS_INPUT)); + } + /** + * Destroy the comments editor. + */ + + }, { + key: "destroy", + value: function destroy() { + var containerParentElement = this.container ? this.container.parentNode : null; + this.editor.parentNode.removeChild(this.editor); + this.editor = null; + this.editorStyle = null; + + if (containerParentElement) { + containerParentElement.removeChild(this.container); + } + } + }], [{ + key: "CLASS_EDITOR_CONTAINER", + get: function get() { + return 'htCommentsContainer'; + } + }, { + key: "CLASS_EDITOR", + get: function get() { + return 'htComments'; + } + }, { + key: "CLASS_INPUT", + get: function get() { + return 'htCommentTextArea'; + } + }, { + key: "CLASS_CELL", + get: function get() { + return 'htCommentCell'; + } + }]); + + return CommentEditor; +}(); + +var defineProperty$7 = objectDefineProperty.f; + +var FunctionPrototype = Function.prototype; +var FunctionPrototypeToString = FunctionPrototype.toString; +var nameRE = /^\s*function ([^ (]*)/; +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.es/ecma262/#sec-function-instances-name +if (descriptors && !(NAME in FunctionPrototype)) { + defineProperty$7(FunctionPrototype, NAME, { + configurable: true, + get: function () { + try { + return FunctionPrototypeToString.call(this).match(nameRE)[1]; + } catch (error) { + return ''; + } + } + }); +} + +var KEY = '---------'; +/** + * @returns {object} + */ + +function separatorItem() { + return { + name: KEY + }; +} + +/** + * @param {CellRange[]} selRanges An array of the cell ranges. + * @returns {object[]} + */ + +function normalizeSelection(selRanges) { + return arrayMap(selRanges, function (range) { + return { + start: range.getTopLeftCorner(), + end: range.getBottomRightCorner() + }; + }); +} +/** + * @param {HTMLElement} cell The HTML cell element to check. + * @returns {boolean} + */ + +function isSeparator(cell) { + return hasClass(cell, 'htSeparator'); +} +/** + * @param {HTMLElement} cell The HTML cell element to check. + * @returns {boolean} + */ + +function hasSubMenu(cell) { + return hasClass(cell, 'htSubmenu'); +} +/** + * @param {HTMLElement} cell The HTML cell element to check. + * @returns {boolean} + */ + +function isDisabled(cell) { + return hasClass(cell, 'htDisabled'); +} +/** + * @param {HTMLElement} cell The HTML cell element to check. + * @returns {boolean} + */ + +function isSelectionDisabled(cell) { + return hasClass(cell, 'htSelectionDisabled'); +} +/** + * @param {Core} hot The Handsontable instance. + * @returns {Array[]|null} + */ + +function getValidSelection(hot) { + var selected = hot.getSelected(); + + if (!selected) { + return null; + } + + if (selected[0] < 0) { + return null; + } + + return selected; +} +/** + * @param {string} className The full element class name to process. + * @param {string} alignment The slignment class name to compare with. + * @returns {string} + */ + +function prepareVerticalAlignClass(className, alignment) { + if (className.indexOf(alignment) !== -1) { + return className; + } + + var replacedClassName = className.replace('htTop', '').replace('htMiddle', '').replace('htBottom', '').replace(' ', ''); + return "".concat(replacedClassName, " ").concat(alignment); +} +/** + * @param {string} className The full element class name to process. + * @param {string} alignment The slignment class name to compare with. + * @returns {string} + */ + +function prepareHorizontalAlignClass(className, alignment) { + if (className.indexOf(alignment) !== -1) { + return className; + } + + var replacedClassName = className.replace('htLeft', '').replace('htCenter', '').replace('htRight', '').replace('htJustify', '').replace(' ', ''); + return "".concat(replacedClassName, " ").concat(alignment); +} +/** + * @param {CellRange[]} ranges An array of the cell ranges. + * @param {Function} callback The callback function. + * @returns {object} + */ + +function getAlignmentClasses(ranges, callback) { + var classes = {}; + arrayEach(ranges, function (range) { + range.forAll(function (row, col) { + // Alignment classes should only collected within cell ranges. We skip header coordinates. + if (row >= 0 && col >= 0) { + if (!classes[row]) { + classes[row] = []; + } + + classes[row][col] = callback(row, col); + } + }); + }); + return classes; +} +/** + * @param {CellRange[]} ranges An array of the cell ranges. + * @param {string} type The type of the alignment axis ('horizontal' or 'vertical'). + * @param {string} alignment CSS class name to add. + * @param {Function} cellDescriptor The function which fetches the cell meta object based in passed coordinates. + * @param {Function} propertySetter The function which contains logic for added/removed alignment. + */ + +function align(ranges, type, alignment, cellDescriptor, propertySetter) { + arrayEach(ranges, function (range) { + range.forAll(function (row, col) { + // Alignment classes should only collected within cell ranges. We skip header coordinates. + if (row >= 0 && col >= 0) { + applyAlignClassName(row, col, type, alignment, cellDescriptor, propertySetter); + } + }); + }); +} +/** + * @param {number} row The visual row index. + * @param {number} col The visual column index. + * @param {string} type The type of the alignment axis ('horizontal' or 'vertical'). + * @param {string} alignment CSS class name to add. + * @param {Function} cellDescriptor The function which fetches the cell meta object based in passed coordinates. + * @param {Function} propertySetter The function which contains logic for added/removed alignment. + */ + +function applyAlignClassName(row, col, type, alignment, cellDescriptor, propertySetter) { + var cellMeta = cellDescriptor(row, col); + var className = alignment; + + if (cellMeta.className) { + if (type === 'vertical') { + className = prepareVerticalAlignClass(cellMeta.className, alignment); + } else { + className = prepareHorizontalAlignClass(cellMeta.className, alignment); + } + } + + propertySetter(row, col, 'className', className); +} +/** + * @param {CellRange[]} ranges An array of the cell ranges. + * @param {Function} comparator The comparator function. + * @returns {boolean} + */ + + +function checkSelectionConsistency(ranges, comparator) { + var result = false; + + if (Array.isArray(ranges)) { + arrayEach(ranges, function (range) { + range.forAll(function (row, col) { + // Selection consistency should only check within cell ranges. We skip header coordinates. + if (row >= 0 && col >= 0 && comparator(row, col)) { + result = true; + return false; + } + }); + return result; + }); + } + + return result; +} +/** + * @param {string} label The label text. + * @returns {string} + */ + +function markLabelAsSelected(label) { + // workaround for https://github.com/handsontable/handsontable/issues/1946 + return "".concat(String.fromCharCode(10003), "").concat(label); +} +/** + * @param {object} item The object which describes the context menu item properties. + * @param {Core} instance The Handsontable instance. + * @returns {boolean} + */ + +function isItemHidden(item, instance) { + return !item.hidden || !(typeof item.hidden === 'function' && item.hidden.call(instance)); +} +/** + * @param {object[]} items The context menu items collection. + * @param {string} separator The string which identifies the context menu separator item. + * @returns {object[]} + */ + +function shiftSeparators(items, separator) { + var result = items.slice(0); + + for (var i = 0; i < result.length;) { + if (result[i].name === separator) { + result.shift(); + } else { + break; + } + } + + return result; +} +/** + * @param {object[]} items The context menu items collection. + * @param {string} separator The string which identifies the context menu separator item. + * @returns {object[]} + */ + + +function popSeparators(items, separator) { + var result = items.slice(0); + result.reverse(); + result = shiftSeparators(result, separator); + result.reverse(); + return result; +} +/** + * Removes duplicated menu separators from the context menu items collection. + * + * @param {object[]} items The context menu items collection. + * @returns {object[]} + */ + + +function removeDuplicatedSeparators(items) { + var result = []; + arrayEach(items, function (value, index) { + if (index > 0) { + if (result[result.length - 1].name !== value.name) { + result.push(value); + } + } else { + result.push(value); + } + }); + return result; +} +/** + * Removes menu separators from the context menu items collection. + * + * @param {object[]} items The context menu items collection. + * @param {string} separator The string which identifies the context menu separator item. + * @returns {object[]} + */ + + +function filterSeparators(items) { + var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : KEY; + var result = items.slice(0); + result = shiftSeparators(result, separator); + result = popSeparators(result, separator); + result = removeDuplicatedSeparators(result); + return result; +} + +function _classCallCheck$1r(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1m(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); } } + +function _createClass$1m(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1m(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1m(Constructor, staticProps); return Constructor; } +var DEFAULT_DISPLAY_DELAY = 250; +var DEFAULT_HIDE_DELAY = 250; +/** + * Display switch for the Comments plugin. Manages the time of delayed displaying / hiding comments. + * + * @class DisplaySwitch + * @plugin Comments + */ + +var DisplaySwitch = /*#__PURE__*/function () { + function DisplaySwitch(displayDelay) { + _classCallCheck$1r(this, DisplaySwitch); + + /** + * Flag to determine if comment can be showed or hidden. State `true` mean that last performed action + * was an attempt to show comment element. State `false` mean that it was attempt to hide comment element. + * + * @type {boolean} + */ + this.wasLastActionShow = true; + /** + * Show comment after predefined delay. It keeps reference to immutable `debounce` function. + * + * @type {Function} + */ + + this.showDebounced = null; + /** + * Reference to timer, run by `setTimeout`, which is hiding comment. + * + * @type {number} + */ + + this.hidingTimer = null; + this.updateDelay(displayDelay); + } + /** + * Responsible for hiding comment after proper delay. + */ + + + _createClass$1m(DisplaySwitch, [{ + key: "hide", + value: function hide() { + var _this = this; + + this.wasLastActionShow = false; + this.hidingTimer = setTimeout(function () { + if (_this.wasLastActionShow === false) { + _this.runLocalHooks('hide'); + } + }, DEFAULT_HIDE_DELAY); + } + /** + * Responsible for showing comment after proper delay. + * + * @param {object} range Coordinates of selected cell. + */ + + }, { + key: "show", + value: function show(range) { + this.wasLastActionShow = true; + this.showDebounced(range); + } + /** + * Cancel hiding comment. + */ + + }, { + key: "cancelHiding", + value: function cancelHiding() { + this.wasLastActionShow = true; + clearTimeout(this.hidingTimer); + this.hidingTimer = null; + } + /** + * Update the switch settings. + * + * @param {number} displayDelay Delay of showing the comments (in milliseconds). + */ + + }, { + key: "updateDelay", + value: function updateDelay() { + var _this2 = this; + + var displayDelay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_DISPLAY_DELAY; + this.showDebounced = debounce(function (range) { + if (_this2.wasLastActionShow) { + _this2.runLocalHooks('show', range.from.row, range.from.col); + } + }, displayDelay); + } + /** + * Destroy the switcher. + */ + + }, { + key: "destroy", + value: function destroy() { + this.clearLocalHooks(); + } + }]); + + return DisplaySwitch; +}(); + +mixin(DisplaySwitch, localHooks); + +function _typeof$P(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$P = function _typeof(obj) { return typeof obj; }; } else { _typeof$P = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$P(obj); } + +function _defineProperty$g(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck$1s(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1n(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); } } + +function _createClass$1n(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1n(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1n(Constructor, staticProps); return Constructor; } + +function _get$h(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$h = Reflect.get; } else { _get$h = function _get(target, property, receiver) { var base = _superPropBase$h(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$h(target, property, receiver || target); } + +function _superPropBase$h(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$E(object); if (object === null) break; } return object; } + +function _inherits$E(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$F(subClass, superClass); } + +function _setPrototypeOf$F(o, p) { _setPrototypeOf$F = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$F(o, p); } + +function _createSuper$E(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$F(); return function _createSuperInternal() { var Super = _getPrototypeOf$E(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$E(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$E(this, result); }; } + +function _possibleConstructorReturn$E(self, call) { if (call && (_typeof$P(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$E(self); } + +function _assertThisInitialized$E(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$F() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$E(o) { _getPrototypeOf$E = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$E(o); } +var PLUGIN_KEY$7 = 'comments'; +var PLUGIN_PRIORITY$6 = 60; +var privatePool$8 = new WeakMap(); +var META_COMMENT = 'comment'; +var META_COMMENT_VALUE = 'value'; +var META_STYLE = 'style'; +var META_READONLY = 'readOnly'; +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @class Comments + * @plugin Comments + * + * @description + * This plugin allows setting and managing cell comments by either an option in the context menu or with the use of + * the API. + * + * To enable the plugin, you'll need to set the comments property of the config object to `true`: + * ```js + * comments: true + * ``` + * + * or an object with extra predefined plugin config: + * + * ```js + * comments: { + * displayDelay: 1000 + * } + * ``` + * + * To add comments at the table initialization, define the `comment` property in the `cell` config array as in an example below. + * + * @example + * + * ```js + * const hot = new Handsontable(document.getElementById('example'), { + * data: getData(), + * comments: true, + * cell: [ + * {row: 1, col: 1, comment: {value: 'Foo'}}, + * {row: 2, col: 2, comment: {value: 'Bar'}} + * ] + * }); + * + * // Access to the Comments plugin instance: + * const commentsPlugin = hot.getPlugin('comments'); + * + * // Manage comments programmatically: + * commentsPlugin.setCommentAtCell(1, 6, 'Comment contents'); + * commentsPlugin.showAtCell(1, 6); + * commentsPlugin.removeCommentAtCell(1, 6); + * + * // You can also set range once and use proper methods: + * commentsPlugin.setRange({from: {row: 1, col: 6}}); + * commentsPlugin.setComment('Comment contents'); + * commentsPlugin.show(); + * commentsPlugin.removeComment(); + * ``` + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var Comments = /*#__PURE__*/function (_BasePlugin) { + _inherits$E(Comments, _BasePlugin); + + var _super = _createSuper$E(Comments); + + function Comments(hotInstance) { + var _this; + + _classCallCheck$1s(this, Comments); + + _this = _super.call(this, hotInstance); + /** + * Instance of {@link CommentEditor}. + * + * @private + * @type {CommentEditor} + */ + + _this.editor = null; + /** + * Instance of {@link DisplaySwitch}. + * + * @private + * @type {DisplaySwitch} + */ + + _this.displaySwitch = null; + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + _this.eventManager = null; + /** + * Current cell range, an object with `from` property, with `row` and `col` properties (e.q. `{from: {row: 1, col: 6}}`). + * + * @type {object} + */ + + _this.range = {}; + /** + * @private + * @type {boolean} + */ + + _this.mouseDown = false; + /** + * @private + * @type {boolean} + */ + + _this.contextMenuEvent = false; + /** + * @private + * @type {*} + */ + + _this.timer = null; + privatePool$8.set(_assertThisInitialized$E(_this), { + tempEditorDimensions: {}, + cellBelowCursor: null + }); + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link Comments#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1n(Comments, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$7]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + if (!this.editor) { + this.editor = new CommentEditor(this.hot.rootDocument); + } + + if (!this.eventManager) { + this.eventManager = new EventManager(this); + } + + if (!this.displaySwitch) { + this.displaySwitch = new DisplaySwitch(this.getDisplayDelaySetting()); + } + + this.addHook('afterContextMenuDefaultOptions', function (options) { + return _this2.addToContextMenu(options); + }); + this.addHook('afterRenderer', function (TD, row, col, prop, value, cellProperties) { + return _this2.onAfterRenderer(TD, cellProperties); + }); + this.addHook('afterScrollHorizontally', function () { + return _this2.hide(); + }); + this.addHook('afterScrollVertically', function () { + return _this2.hide(); + }); + this.addHook('afterBeginEditing', function () { + return _this2.onAfterBeginEditing(); + }); + this.displaySwitch.addLocalHook('hide', function () { + return _this2.hide(); + }); + this.displaySwitch.addLocalHook('show', function (row, col) { + return _this2.showAtCell(row, col); + }); + this.registerListeners(); + + _get$h(_getPrototypeOf$E(Comments.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$h(_getPrototypeOf$E(Comments.prototype), "updatePlugin", this).call(this); + + this.displaySwitch.updateDelay(this.getDisplayDelaySetting()); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + _get$h(_getPrototypeOf$E(Comments.prototype), "disablePlugin", this).call(this); + } + /** + * Registers all necessary DOM listeners. + * + * @private + */ + + }, { + key: "registerListeners", + value: function registerListeners() { + var _this3 = this; + + var rootDocument = this.hot.rootDocument; + this.eventManager.addEventListener(rootDocument, 'mouseover', function (event) { + return _this3.onMouseOver(event); + }); + this.eventManager.addEventListener(rootDocument, 'mousedown', function (event) { + return _this3.onMouseDown(event); + }); + this.eventManager.addEventListener(rootDocument, 'mouseup', function () { + return _this3.onMouseUp(); + }); + this.eventManager.addEventListener(this.editor.getInputElement(), 'blur', function () { + return _this3.onEditorBlur(); + }); + this.eventManager.addEventListener(this.editor.getInputElement(), 'mousedown', function (event) { + return _this3.onEditorMouseDown(event); + }); + this.eventManager.addEventListener(this.editor.getInputElement(), 'mouseup', function (event) { + return _this3.onEditorMouseUp(event); + }); + } + /** + * Sets the current cell range to be able to use general methods like {@link Comments#setComment}, {@link Comments#removeComment}, {@link Comments#show}. + * + * @param {object} range Object with `from` property, each with `row` and `col` properties. + */ + + }, { + key: "setRange", + value: function setRange(range) { + this.range = range; + } + /** + * Clears the currently selected cell. + */ + + }, { + key: "clearRange", + value: function clearRange() { + this.range = {}; + } + /** + * Checks if the event target is a cell containing a comment. + * + * @private + * @param {Event} event DOM event. + * @returns {boolean} + */ + + }, { + key: "targetIsCellWithComment", + value: function targetIsCellWithComment(event) { + var closestCell = closest(event.target, 'TD', 'TBODY'); + return !!(closestCell && hasClass(closestCell, 'htCommentCell') && closest(closestCell, [this.hot.rootElement])); + } + /** + * Checks if the event target is a comment textarea. + * + * @private + * @param {Event} event DOM event. + * @returns {boolean} + */ + + }, { + key: "targetIsCommentTextArea", + value: function targetIsCommentTextArea(event) { + return this.editor.getInputElement() === event.target; + } + /** + * Sets a comment for a cell according to the previously set range (see {@link Comments#setRange}). + * + * @param {string} value Comment contents. + */ + + }, { + key: "setComment", + value: function setComment(value) { + if (!this.range.from) { + throw new Error('Before using this method, first set cell range (hot.getPlugin("comment").setRange())'); + } + + var editorValue = this.editor.getValue(); + var comment = ''; + + if (value !== null && value !== void 0) { + comment = value; + } else if (editorValue !== null && editorValue !== void 0) { + comment = editorValue; + } + + var row = this.range.from.row; + var col = this.range.from.col; + this.updateCommentMeta(row, col, _defineProperty$g({}, META_COMMENT_VALUE, comment)); + this.hot.render(); + } + /** + * Sets a comment for a specified cell. + * + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string} value Comment contents. + */ + + }, { + key: "setCommentAtCell", + value: function setCommentAtCell(row, column, value) { + this.setRange({ + from: new CellCoords(row, column) + }); + this.setComment(value); + } + /** + * Removes a comment from a cell according to previously set range (see {@link Comments#setRange}). + * + * @param {boolean} [forceRender=true] If set to `true`, the table will be re-rendered at the end of the operation. + */ + + }, { + key: "removeComment", + value: function removeComment() { + var forceRender = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + if (!this.range.from) { + throw new Error('Before using this method, first set cell range (hot.getPlugin("comment").setRange())'); + } + + this.hot.setCellMeta(this.range.from.row, this.range.from.col, META_COMMENT, void 0); + + if (forceRender) { + this.hot.render(); + } + + this.hide(); + } + /** + * Removes a comment from a specified cell. + * + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {boolean} [forceRender=true] If `true`, the table will be re-rendered at the end of the operation. + */ + + }, { + key: "removeCommentAtCell", + value: function removeCommentAtCell(row, column) { + var forceRender = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + this.setRange({ + from: new CellCoords(row, column) + }); + this.removeComment(forceRender); + } + /** + * Gets comment from a cell according to previously set range (see {@link Comments#setRange}). + * + * @returns {string|undefined} Returns a content of the comment. + */ + + }, { + key: "getComment", + value: function getComment() { + var row = this.range.from.row; + var column = this.range.from.col; + return this.getCommentMeta(row, column, META_COMMENT_VALUE); + } + /** + * Gets comment from a cell at the provided coordinates. + * + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @returns {string|undefined} Returns a content of the comment. + */ + + }, { + key: "getCommentAtCell", + value: function getCommentAtCell(row, column) { + return this.getCommentMeta(row, column, META_COMMENT_VALUE); + } + /** + * Shows the comment editor accordingly to the previously set range (see {@link Comments#setRange}). + * + * @returns {boolean} Returns `true` if comment editor was shown. + */ + + }, { + key: "show", + value: function show() { + if (!this.range.from) { + throw new Error('Before using this method, first set cell range (hot.getPlugin("comment").setRange())'); + } + + var _this$range$from = this.range.from, + row = _this$range$from.row, + col = _this$range$from.col; + + if (row < 0 || row > this.hot.countSourceRows() - 1 || col < 0 || col > this.hot.countSourceCols() - 1) { + return false; + } + + var meta = this.hot.getCellMeta(this.range.from.row, this.range.from.col); + this.refreshEditor(true); + this.editor.setValue(meta[META_COMMENT] ? meta[META_COMMENT][META_COMMENT_VALUE] : ''); + + if (this.editor.hidden) { + this.editor.show(); + } + + return true; + } + /** + * Shows comment editor according to cell coordinates. + * + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @returns {boolean} Returns `true` if comment editor was shown. + */ + + }, { + key: "showAtCell", + value: function showAtCell(row, column) { + this.setRange({ + from: new CellCoords(row, column) + }); + return this.show(); + } + /** + * Hides the comment editor. + */ + + }, { + key: "hide", + value: function hide() { + if (!this.editor.hidden) { + this.editor.hide(); + } + } + /** + * Refreshes comment editor position and styling. + * + * @param {boolean} [force=false] If `true` then recalculation will be forced. + */ + + }, { + key: "refreshEditor", + value: function refreshEditor() { + var _renderableRow, _renderableColumn; + + var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + if (!force && (!this.range.from || !this.editor.isVisible())) { + return; + } + + var _this$hot = this.hot, + rowIndexMapper = _this$hot.rowIndexMapper, + columnIndexMapper = _this$hot.columnIndexMapper; + var _this$range$from2 = this.range.from, + visualRow = _this$range$from2.row, + visualColumn = _this$range$from2.col; + var renderableRow = rowIndexMapper.getRenderableFromVisualIndex(visualRow); + var renderableColumn = columnIndexMapper.getRenderableFromVisualIndex(visualColumn); // Used when the requested row is hidden, and the editor needs to be positioned on the previous row's coords. + + var targetingPreviousRow = renderableRow === null; + + if (renderableRow === null) { + renderableRow = rowIndexMapper.getRenderableFromVisualIndex(rowIndexMapper.getFirstNotHiddenIndex(visualRow, -1)); + } + + if (renderableColumn === null) { + renderableColumn = columnIndexMapper.getRenderableFromVisualIndex(columnIndexMapper.getFirstNotHiddenIndex(visualColumn, -1)); + } + + var isBeforeRenderedRows = renderableRow === null; + var isBeforeRenderedColumns = renderableColumn === null; + renderableRow = (_renderableRow = renderableRow) !== null && _renderableRow !== void 0 ? _renderableRow : 0; + renderableColumn = (_renderableColumn = renderableColumn) !== null && _renderableColumn !== void 0 ? _renderableColumn : 0; + var _this$hot2 = this.hot, + rootWindow = _this$hot2.rootWindow, + wt = _this$hot2.view.wt; + var wtTable = wt.wtTable, + wtOverlays = wt.wtOverlays, + wtViewport = wt.wtViewport; + var scrollableElement = wtOverlays.scrollableElement; + var TD = wtTable.getCell({ + row: renderableRow, + col: renderableColumn + }); + var cellOffset = offset(TD); + var lastColWidth = isBeforeRenderedColumns ? 0 : wtTable.getStretchedColumnWidth(renderableColumn); + var lastRowHeight = targetingPreviousRow && !isBeforeRenderedRows ? outerHeight(TD) : 0; + var cellTopOffset = cellOffset.top; + var cellLeftOffset = cellOffset.left; + + if (wtViewport.hasVerticalScroll() && scrollableElement !== rootWindow) { + cellTopOffset -= wtOverlays.topOverlay.getScrollPosition(); + } + + if (wtViewport.hasHorizontalScroll() && scrollableElement !== rootWindow) { + cellLeftOffset -= wtOverlays.leftOverlay.getScrollPosition(); + } + + var x = cellLeftOffset + lastColWidth; + var y = cellTopOffset + lastRowHeight; + var commentStyle = this.getCommentMeta(visualRow, visualColumn, META_STYLE); + var readOnly = this.getCommentMeta(visualRow, visualColumn, META_READONLY); + + if (commentStyle) { + this.editor.setSize(commentStyle.width, commentStyle.height); + } else { + this.editor.resetSize(); + } + + this.editor.setReadOnlyState(readOnly); + this.editor.setPosition(x, y); + } + /** + * Checks if there is a comment for selected range. + * + * @private + * @returns {boolean} + */ + + }, { + key: "checkSelectionCommentsConsistency", + value: function checkSelectionCommentsConsistency() { + var selected = this.hot.getSelectedRangeLast(); + + if (!selected) { + return false; + } + + var hasComment = false; + var cell = selected.getTopLeftCorner(); // IN EXCEL THERE IS COMMENT ONLY FOR TOP LEFT CELL IN SELECTION + + if (this.getCommentMeta(cell.row, cell.col, META_COMMENT_VALUE)) { + hasComment = true; + } + + return hasComment; + } + /** + * Sets or update the comment-related cell meta. + * + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {object} metaObject Object defining all the comment-related meta information. + */ + + }, { + key: "updateCommentMeta", + value: function updateCommentMeta(row, column, metaObject) { + var oldComment = this.hot.getCellMeta(row, column)[META_COMMENT]; + var newComment; + + if (oldComment) { + newComment = deepClone(oldComment); + deepExtend(newComment, metaObject); + } else { + newComment = metaObject; + } + + this.hot.setCellMeta(row, column, META_COMMENT, newComment); + } + /** + * Gets the comment related meta information. + * + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string} property Cell meta property. + * @returns {Mixed} + */ + + }, { + key: "getCommentMeta", + value: function getCommentMeta(row, column, property) { + var cellMeta = this.hot.getCellMeta(row, column); + + if (!cellMeta[META_COMMENT]) { + return void 0; + } + + return cellMeta[META_COMMENT][property]; + } + /** + * `mousedown` event callback. + * + * @private + * @param {MouseEvent} event The `mousedown` event. + */ + + }, { + key: "onMouseDown", + value: function onMouseDown(event) { + this.mouseDown = true; + + if (!this.hot.view || !this.hot.view.wt) { + return; + } + + if (!this.contextMenuEvent && !this.targetIsCommentTextArea(event)) { + var eventCell = closest(event.target, 'TD', 'TBODY'); + var coordinates = null; + + if (eventCell) { + coordinates = this.hot.view.wt.wtTable.getCoords(eventCell); + coordinates = { + row: this.hot.rowIndexMapper.getVisualFromRenderableIndex(coordinates.row), + col: this.hot.columnIndexMapper.getVisualFromRenderableIndex(coordinates.col) + }; + } + + if (!eventCell || this.range.from && coordinates && (this.range.from.row !== coordinates.row || this.range.from.col !== coordinates.col)) { + this.hide(); + } + } + + this.contextMenuEvent = false; + } + /** + * `mouseover` event callback. + * + * @private + * @param {MouseEvent} event The `mouseover` event. + */ + + }, { + key: "onMouseOver", + value: function onMouseOver(event) { + var priv = privatePool$8.get(this); + var rootDocument = this.hot.rootDocument; + priv.cellBelowCursor = rootDocument.elementFromPoint(event.clientX, event.clientY); + + if (this.mouseDown || this.editor.isFocused() || hasClass(event.target, 'wtBorder') || priv.cellBelowCursor !== event.target || !this.editor) { + return; + } + + if (this.targetIsCellWithComment(event)) { + var coordinates = this.hot.view.wt.wtTable.getCoords(event.target); + var range = { + from: new CellCoords(this.hot.rowIndexMapper.getVisualFromRenderableIndex(coordinates.row), this.hot.columnIndexMapper.getVisualFromRenderableIndex(coordinates.col)) + }; + this.displaySwitch.show(range); + } else if (isChildOf(event.target, rootDocument) && !this.targetIsCommentTextArea(event)) { + this.displaySwitch.hide(); + } + } + /** + * `mouseup` event callback. + * + * @private + */ + + }, { + key: "onMouseUp", + value: function onMouseUp() { + this.mouseDown = false; + } + /** + * The `afterRenderer` hook callback. + * + * @private + * @param {HTMLTableCellElement} TD The rendered `TD` element. + * @param {object} cellProperties The rendered cell's property object. + */ + + }, { + key: "onAfterRenderer", + value: function onAfterRenderer(TD, cellProperties) { + if (cellProperties[META_COMMENT] && cellProperties[META_COMMENT][META_COMMENT_VALUE]) { + addClass(TD, cellProperties.commentedCellClassName); + } + } + /** + * `blur` event callback for the comment editor. + * + * @private + */ + + }, { + key: "onEditorBlur", + value: function onEditorBlur() { + this.setComment(); + } + /** + * `mousedown` hook. Along with `onEditorMouseUp` used to simulate the textarea resizing event. + * + * @private + * @param {MouseEvent} event The `mousedown` event. + */ + + }, { + key: "onEditorMouseDown", + value: function onEditorMouseDown(event) { + var priv = privatePool$8.get(this); + priv.tempEditorDimensions = { + width: outerWidth(event.target), + height: outerHeight(event.target) + }; + } + /** + * `mouseup` hook. Along with `onEditorMouseDown` used to simulate the textarea resizing event. + * + * @private + * @param {MouseEvent} event The `mouseup` event. + */ + + }, { + key: "onEditorMouseUp", + value: function onEditorMouseUp(event) { + var priv = privatePool$8.get(this); + var currentWidth = outerWidth(event.target); + var currentHeight = outerHeight(event.target); + + if (currentWidth !== priv.tempEditorDimensions.width + 1 || currentHeight !== priv.tempEditorDimensions.height + 2) { + this.updateCommentMeta(this.range.from.row, this.range.from.col, _defineProperty$g({}, META_STYLE, { + width: currentWidth, + height: currentHeight + })); + } + } + /** + * Context Menu's "Add comment" callback. Results in showing the comment editor. + * + * @private + */ + + }, { + key: "onContextMenuAddComment", + value: function onContextMenuAddComment() { + var _this4 = this; + + this.displaySwitch.cancelHiding(); + var coords = this.hot.getSelectedRangeLast(); + this.contextMenuEvent = true; + this.setRange({ + from: coords.highlight + }); + this.show(); + setTimeout(function () { + if (_this4.hot) { + _this4.hot.deselectCell(); + + _this4.editor.focus(); + } + }, 10); + } + /** + * Context Menu's "remove comment" callback. + * + * @private + */ + + }, { + key: "onContextMenuRemoveComment", + value: function onContextMenuRemoveComment() { + var _this5 = this; + + var coords = this.hot.getSelectedRangeLast(); + this.contextMenuEvent = true; + coords.forAll(function (row, column) { + if (row >= 0 && column >= 0) { + _this5.removeCommentAtCell(row, column, false); + } + }); + this.hot.render(); + } + /** + * Context Menu's "make comment read-only" callback. + * + * @private + */ + + }, { + key: "onContextMenuMakeReadOnly", + value: function onContextMenuMakeReadOnly() { + var _this6 = this; + + var coords = this.hot.getSelectedRangeLast(); + this.contextMenuEvent = true; + coords.forAll(function (row, column) { + if (row >= 0 && column >= 0) { + var currentState = !!_this6.getCommentMeta(row, column, META_READONLY); + + _this6.updateCommentMeta(row, column, _defineProperty$g({}, META_READONLY, !currentState)); + } + }); + } + /** + * Add Comments plugin options to the Context Menu. + * + * @private + * @param {object} defaultOptions The menu options. + */ + + }, { + key: "addToContextMenu", + value: function addToContextMenu(defaultOptions) { + var _this7 = this; + + var isThereAnyCellRendered = function isThereAnyCellRendered() { + return _this7.hot.rowIndexMapper.getRenderableIndexesLength() > 0 && _this7.hot.columnIndexMapper.getRenderableIndexesLength() > 0; + }; + + defaultOptions.items.push({ + name: '---------' + }, { + key: 'commentsAddEdit', + name: function name() { + if (_this7.checkSelectionCommentsConsistency()) { + return _this7.hot.getTranslatedPhrase(CONTEXTMENU_ITEMS_EDIT_COMMENT); + } + + return _this7.hot.getTranslatedPhrase(CONTEXTMENU_ITEMS_ADD_COMMENT); + }, + callback: function callback() { + return _this7.onContextMenuAddComment(); + }, + disabled: function disabled() { + if (!isThereAnyCellRendered()) { + return true; + } + + return !(_this7.hot.getSelectedLast() && !_this7.hot.selection.isSelectedByCorner()); + } + }, { + key: 'commentsRemove', + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_REMOVE_COMMENT); + }, + callback: function callback() { + return _this7.onContextMenuRemoveComment(); + }, + disabled: function disabled() { + if (!isThereAnyCellRendered()) { + return true; + } + + return !(_this7.hot.getSelectedLast() && !_this7.hot.selection.isSelectedByCorner()); + } + }, { + key: 'commentsReadOnly', + name: function name() { + var _this8 = this; + + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_READ_ONLY_COMMENT); + var hasProperty = checkSelectionConsistency(this.getSelectedRangeLast(), function (row, col) { + var readOnlyProperty = _this8.getCellMeta(row, col)[META_COMMENT]; + + if (readOnlyProperty) { + readOnlyProperty = readOnlyProperty[META_READONLY]; + } + + if (readOnlyProperty) { + return true; + } + }); + + if (hasProperty) { + label = markLabelAsSelected(label); + } + + return label; + }, + callback: function callback() { + return _this7.onContextMenuMakeReadOnly(); + }, + disabled: function disabled() { + if (!isThereAnyCellRendered()) { + return true; + } + + return !(_this7.hot.getSelectedLast() && !_this7.hot.selection.isSelectedByCorner()) || !_this7.checkSelectionCommentsConsistency(); + } + }); + } + /** + * Get `displayDelay` setting of comment plugin. + * + * @private + * @returns {number|undefined} + */ + + }, { + key: "getDisplayDelaySetting", + value: function getDisplayDelaySetting() { + var commentSetting = this.hot.getSettings()[PLUGIN_KEY$7]; + + if (isObject$1(commentSetting)) { + return commentSetting.displayDelay; + } + + return void 0; + } + /** + * `afterBeginEditing` hook callback. + * + * @private + */ + + }, { + key: "onAfterBeginEditing", + value: function onAfterBeginEditing() { + this.hide(); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + if (this.editor) { + this.editor.destroy(); + } + + if (this.displaySwitch) { + this.displaySwitch.destroy(); + } + + _get$h(_getPrototypeOf$E(Comments.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$7; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$6; + } + }]); + + return Comments; +}(BasePlugin); + +function _classCallCheck$1t(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1o(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); } } + +function _createClass$1o(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1o(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1o(Constructor, staticProps); return Constructor; } +/** + * Command executor for ContextMenu. + * + * @class CommandExecutor + * @plugin ContextMenu + */ + +var CommandExecutor = /*#__PURE__*/function () { + function CommandExecutor(hotInstance) { + _classCallCheck$1t(this, CommandExecutor); + + this.hot = hotInstance; + this.commands = {}; + this.commonCallback = null; + } + /** + * Register command. + * + * @param {string} name Command name. + * @param {object} commandDescriptor Command descriptor object with properties like `key` (command id), + * `callback` (task to execute), `name` (command name), `disabled` (command availability). + */ + + + _createClass$1o(CommandExecutor, [{ + key: "registerCommand", + value: function registerCommand(name, commandDescriptor) { + this.commands[name] = commandDescriptor; + } + /** + * Set common callback which will be trigger on every executed command. + * + * @param {Function} callback Function which will be fired on every command execute. + */ + + }, { + key: "setCommonCallback", + value: function setCommonCallback(callback) { + this.commonCallback = callback; + } + /** + * Execute command by its name. + * + * @param {string} commandName Command id. + * @param {*} params Arguments passed to command task. + */ + + }, { + key: "execute", + value: function execute(commandName) { + var _this = this; + + for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + params[_key - 1] = arguments[_key]; + } + + var commandSplit = commandName.split(':'); + var commandNamePrimary = commandSplit[0]; + var subCommandName = commandSplit.length === 2 ? commandSplit[1] : null; + var command = this.commands[commandNamePrimary]; + + if (!command) { + throw new Error("Menu command '".concat(commandNamePrimary, "' not exists.")); + } + + if (subCommandName && command.submenu) { + command = findSubCommand(subCommandName, command.submenu.items); + } + + if (command.disabled === true) { + return; + } + + if (typeof command.disabled === 'function' && command.disabled.call(this.hot) === true) { + return; + } + + if (hasOwnProperty$1(command, 'submenu')) { + return; + } + + var callbacks = []; + + if (typeof command.callback === 'function') { + callbacks.push(command.callback); + } + + if (typeof this.commonCallback === 'function') { + callbacks.push(this.commonCallback); + } + + params.unshift(commandSplit.join(':')); + arrayEach(callbacks, function (callback) { + return callback.apply(_this.hot, params); + }); + } + }]); + + return CommandExecutor; +}(); +/** + * @param {string} subCommandName The subcommand name. + * @param {string[]} subCommands The collection of the commands. + * @returns {boolean} + */ + + +function findSubCommand(subCommandName, subCommands) { + var command; + arrayEach(subCommands, function (cmd) { + var cmds = cmd.key ? cmd.key.split(':') : null; + + if (Array.isArray(cmds) && cmds[1] === subCommandName) { + command = cmd; + return false; + } + }); + return command; +} + +var KEY$1 = 'alignment'; +/** + * @returns {object} + */ + +function alignmentItem() { + return { + key: KEY$1, + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ALIGNMENT); + }, + disabled: function disabled() { + if (this.countRows() === 0 || this.countCols() === 0) { + return true; + } + + return !(this.getSelectedRange() && !this.selection.isSelectedByCorner()); + }, + submenu: { + items: [{ + key: "".concat(KEY$1, ":left"), + name: function name() { + var _this = this; + + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ALIGNMENT_LEFT); + var hasClass = checkSelectionConsistency(this.getSelectedRange(), function (row, col) { + var className = _this.getCellMeta(row, col).className; + + if (className && className.indexOf('htLeft') !== -1) { + return true; + } + }); + + if (hasClass) { + label = markLabelAsSelected(label); + } + + return label; + }, + callback: function callback() { + var _this2 = this; + + var selectedRange = this.getSelectedRange(); + var stateBefore = getAlignmentClasses(selectedRange, function (row, col) { + return _this2.getCellMeta(row, col).className; + }); + var type = 'horizontal'; + var alignment = 'htLeft'; + this.runHooks('beforeCellAlignment', stateBefore, selectedRange, type, alignment); + align(selectedRange, type, alignment, function (row, col) { + return _this2.getCellMeta(row, col); + }, function (row, col, key, value) { + return _this2.setCellMeta(row, col, key, value); + }); + this.render(); + }, + disabled: false + }, { + key: "".concat(KEY$1, ":center"), + name: function name() { + var _this3 = this; + + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ALIGNMENT_CENTER); + var hasClass = checkSelectionConsistency(this.getSelectedRange(), function (row, col) { + var className = _this3.getCellMeta(row, col).className; + + if (className && className.indexOf('htCenter') !== -1) { + return true; + } + }); + + if (hasClass) { + label = markLabelAsSelected(label); + } + + return label; + }, + callback: function callback() { + var _this4 = this; + + var selectedRange = this.getSelectedRange(); + var stateBefore = getAlignmentClasses(selectedRange, function (row, col) { + return _this4.getCellMeta(row, col).className; + }); + var type = 'horizontal'; + var alignment = 'htCenter'; + this.runHooks('beforeCellAlignment', stateBefore, selectedRange, type, alignment); + align(selectedRange, type, alignment, function (row, col) { + return _this4.getCellMeta(row, col); + }, function (row, col, key, value) { + return _this4.setCellMeta(row, col, key, value); + }); + this.render(); + }, + disabled: false + }, { + key: "".concat(KEY$1, ":right"), + name: function name() { + var _this5 = this; + + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ALIGNMENT_RIGHT); + var hasClass = checkSelectionConsistency(this.getSelectedRange(), function (row, col) { + var className = _this5.getCellMeta(row, col).className; + + if (className && className.indexOf('htRight') !== -1) { + return true; + } + }); + + if (hasClass) { + label = markLabelAsSelected(label); + } + + return label; + }, + callback: function callback() { + var _this6 = this; + + var selectedRange = this.getSelectedRange(); + var stateBefore = getAlignmentClasses(selectedRange, function (row, col) { + return _this6.getCellMeta(row, col).className; + }); + var type = 'horizontal'; + var alignment = 'htRight'; + this.runHooks('beforeCellAlignment', stateBefore, selectedRange, type, alignment); + align(selectedRange, type, alignment, function (row, col) { + return _this6.getCellMeta(row, col); + }, function (row, col, key, value) { + return _this6.setCellMeta(row, col, key, value); + }); + this.render(); + }, + disabled: false + }, { + key: "".concat(KEY$1, ":justify"), + name: function name() { + var _this7 = this; + + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ALIGNMENT_JUSTIFY); + var hasClass = checkSelectionConsistency(this.getSelectedRange(), function (row, col) { + var className = _this7.getCellMeta(row, col).className; + + if (className && className.indexOf('htJustify') !== -1) { + return true; + } + }); + + if (hasClass) { + label = markLabelAsSelected(label); + } + + return label; + }, + callback: function callback() { + var _this8 = this; + + var selectedRange = this.getSelectedRange(); + var stateBefore = getAlignmentClasses(selectedRange, function (row, col) { + return _this8.getCellMeta(row, col).className; + }); + var type = 'horizontal'; + var alignment = 'htJustify'; + this.runHooks('beforeCellAlignment', stateBefore, selectedRange, type, alignment); + align(selectedRange, type, alignment, function (row, col) { + return _this8.getCellMeta(row, col); + }, function (row, col, key, value) { + return _this8.setCellMeta(row, col, key, value); + }); + this.render(); + }, + disabled: false + }, { + name: KEY + }, { + key: "".concat(KEY$1, ":top"), + name: function name() { + var _this9 = this; + + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ALIGNMENT_TOP); + var hasClass = checkSelectionConsistency(this.getSelectedRange(), function (row, col) { + var className = _this9.getCellMeta(row, col).className; + + if (className && className.indexOf('htTop') !== -1) { + return true; + } + }); + + if (hasClass) { + label = markLabelAsSelected(label); + } + + return label; + }, + callback: function callback() { + var _this10 = this; + + var selectedRange = this.getSelectedRange(); + var stateBefore = getAlignmentClasses(selectedRange, function (row, col) { + return _this10.getCellMeta(row, col).className; + }); + var type = 'vertical'; + var alignment = 'htTop'; + this.runHooks('beforeCellAlignment', stateBefore, selectedRange, type, alignment); + align(selectedRange, type, alignment, function (row, col) { + return _this10.getCellMeta(row, col); + }, function (row, col, key, value) { + return _this10.setCellMeta(row, col, key, value); + }); + this.render(); + }, + disabled: false + }, { + key: "".concat(KEY$1, ":middle"), + name: function name() { + var _this11 = this; + + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ALIGNMENT_MIDDLE); + var hasClass = checkSelectionConsistency(this.getSelectedRange(), function (row, col) { + var className = _this11.getCellMeta(row, col).className; + + if (className && className.indexOf('htMiddle') !== -1) { + return true; + } + }); + + if (hasClass) { + label = markLabelAsSelected(label); + } + + return label; + }, + callback: function callback() { + var _this12 = this; + + var selectedRange = this.getSelectedRange(); + var stateBefore = getAlignmentClasses(selectedRange, function (row, col) { + return _this12.getCellMeta(row, col).className; + }); + var type = 'vertical'; + var alignment = 'htMiddle'; + this.runHooks('beforeCellAlignment', stateBefore, selectedRange, type, alignment); + align(selectedRange, type, alignment, function (row, col) { + return _this12.getCellMeta(row, col); + }, function (row, col, key, value) { + return _this12.setCellMeta(row, col, key, value); + }); + this.render(); + }, + disabled: false + }, { + key: "".concat(KEY$1, ":bottom"), + name: function name() { + var _this13 = this; + + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ALIGNMENT_BOTTOM); + var hasClass = checkSelectionConsistency(this.getSelectedRange(), function (row, col) { + var className = _this13.getCellMeta(row, col).className; + + if (className && className.indexOf('htBottom') !== -1) { + return true; + } + }); + + if (hasClass) { + label = markLabelAsSelected(label); + } + + return label; + }, + callback: function callback() { + var _this14 = this; + + var selectedRange = this.getSelectedRange(); + var stateBefore = getAlignmentClasses(selectedRange, function (row, col) { + return _this14.getCellMeta(row, col).className; + }); + var type = 'vertical'; + var alignment = 'htBottom'; + this.runHooks('beforeCellAlignment', stateBefore, selectedRange, type, alignment); + align(selectedRange, type, alignment, function (row, col) { + return _this14.getCellMeta(row, col); + }, function (row, col, key, value) { + return _this14.setCellMeta(row, col, key, value); + }); + this.render(); + }, + disabled: false + }] + } + }; +} + +var KEY$2 = 'clear_column'; +/** + * @returns {object} + */ + +function clearColumnItem() { + return { + key: KEY$2, + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_CLEAR_COLUMN); + }, + callback: function callback(key, selection) { + var startColumn = selection[0].start.col; + var endColumn = selection[0].end.col; + + if (this.countRows()) { + this.populateFromArray(0, startColumn, [[null]], Math.max(selection[0].start.row, selection[0].end.row), endColumn, 'ContextMenu.clearColumn'); + } + }, + disabled: function disabled() { + var selected = getValidSelection(this); + + if (!selected) { + return true; + } + + return !this.selection.isSelectedByColumnHeader(); + } + }; +} + +var KEY$3 = 'col_left'; +/** + * @returns {object} + */ + +function columnLeftItem() { + return { + key: KEY$3, + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_INSERT_LEFT); + }, + callback: function callback(key, normalizedSelection) { + var isSelectedByCorner = this.selection.isSelectedByCorner(); + var columnLeft = 0; + + if (!isSelectedByCorner) { + var latestSelection = normalizedSelection[Math.max(normalizedSelection.length - 1, 0)]; + columnLeft = latestSelection.start.col; + } + + this.alter('insert_col', columnLeft, 1, 'ContextMenu.columnLeft'); + + if (isSelectedByCorner) { + this.selectAll(); + } + }, + disabled: function disabled() { + if (!this.isColumnModificationAllowed()) { + return true; + } + + var selected = getValidSelection(this); + + if (!selected) { + return true; + } + + if (this.selection.isSelectedByCorner()) { + var totalColumns = this.countCols(); // Enable "Insert column left" only when there is at least one column. + + return totalColumns === 0; + } + + return this.selection.isSelectedByRowHeader() || this.countCols() >= this.getSettings().maxCols; + }, + hidden: function hidden() { + return !this.getSettings().allowInsertColumn; + } + }; +} + +var KEY$4 = 'col_right'; +/** + * @returns {object} + */ + +function columnRightItem() { + return { + key: KEY$4, + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_INSERT_RIGHT); + }, + callback: function callback(key, normalizedSelection) { + var isSelectedByCorner = this.selection.isSelectedByCorner(); + var columnRight = 0; + + if (isSelectedByCorner) { + columnRight = this.countCols(); + } else { + var _latestSelection$end; + + var latestSelection = normalizedSelection[Math.max(normalizedSelection.length - 1, 0)]; + var selectedColumn = latestSelection === null || latestSelection === void 0 ? void 0 : (_latestSelection$end = latestSelection.end) === null || _latestSelection$end === void 0 ? void 0 : _latestSelection$end.col; // If there is no selection we have clicked on the corner and there is no data. + + columnRight = isDefined(selectedColumn) ? selectedColumn + 1 : 0; + } + + this.alter('insert_col', columnRight, 1, 'ContextMenu.columnRight'); + + if (isSelectedByCorner) { + this.selectAll(); + } + }, + disabled: function disabled() { + if (!this.isColumnModificationAllowed()) { + return true; + } + + var selected = getValidSelection(this); + + if (!selected) { + return true; + } + + if (this.selection.isSelectedByCorner()) { + // Enable "Insert column right" always when the menu is triggered by corner click. + return false; + } + + return this.selection.isSelectedByRowHeader() || this.countCols() >= this.getSettings().maxCols; + }, + hidden: function hidden() { + return !this.getSettings().allowInsertColumn; + } + }; +} + +var KEY$5 = 'make_read_only'; +/** + * @returns {object} + */ + +function readOnlyItem() { + return { + key: KEY$5, + name: function name() { + var _this = this; + + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_READ_ONLY); + var atLeastOneReadOnly = checkSelectionConsistency(this.getSelectedRange(), function (row, col) { + return _this.getCellMeta(row, col).readOnly; + }); + + if (atLeastOneReadOnly) { + label = markLabelAsSelected(label); + } + + return label; + }, + callback: function callback() { + var _this2 = this; + + var ranges = this.getSelectedRange(); + var atLeastOneReadOnly = checkSelectionConsistency(ranges, function (row, col) { + return _this2.getCellMeta(row, col).readOnly; + }); + arrayEach(ranges, function (range) { + range.forAll(function (row, col) { + if (row >= 0 && col >= 0) { + _this2.setCellMeta(row, col, 'readOnly', !atLeastOneReadOnly); + } + }); + }); + this.render(); + }, + disabled: function disabled() { + if (this.selection.isSelectedByCorner()) { + return true; + } + + if (this.countRows() === 0 || this.countCols() === 0) { + return true; + } + + if (!this.getSelectedRange() || this.getSelectedRange().length === 0) { + return true; + } + + return false; + } + }; +} + +var KEY$6 = 'redo'; +/** + * @returns {object} + */ + +function redoItem() { + return { + key: KEY$6, + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_REDO); + }, + callback: function callback() { + this.redo(); + }, + hidden: function hidden() { + var undoRedo = this.getPlugin('undoRedo'); + return !undoRedo || !undoRedo.isEnabled(); + }, + disabled: function disabled() { + return !this.getPlugin('undoRedo').isRedoAvailable(); + } + }; +} + +function _slicedToArray$i(arr, i) { return _arrayWithHoles$j(arr) || _iterableToArrayLimit$i(arr, i) || _unsupportedIterableToArray$u(arr, i) || _nonIterableRest$j(); } + +function _nonIterableRest$j() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$u(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$u(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$u(o, minLen); } + +function _arrayLikeToArray$u(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$i(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$j(arr) { if (Array.isArray(arr)) return arr; } +var KEY$7 = 'remove_col'; +/** + * @returns {object} + */ + +function removeColumnItem() { + return { + key: KEY$7, + name: function name() { + var selection = this.getSelected(); + var pluralForm = 0; + + if (selection) { + if (selection.length > 1) { + pluralForm = 1; + } else { + var _selection$ = _slicedToArray$i(selection[0], 4), + fromColumn = _selection$[1], + toColumn = _selection$[3]; + + if (fromColumn - toColumn !== 0) { + pluralForm = 1; + } + } + } + + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_REMOVE_COLUMN, pluralForm); + }, + callback: function callback() { + this.alter('remove_col', transformSelectionToColumnDistance(this.getSelected()), null, 'ContextMenu.removeColumn'); + }, + disabled: function disabled() { + if (!this.isColumnModificationAllowed()) { + return true; + } + + var selected = getValidSelection(this); + + if (!selected) { + return true; + } + + var totalColumns = this.countCols(); + + if (this.selection.isSelectedByCorner()) { + // Enable "Remove column" only when there is at least one column. + return totalColumns === 0; + } + + return this.selection.isSelectedByRowHeader() || totalColumns === 0; + }, + hidden: function hidden() { + return !this.getSettings().allowRemoveColumn; + } + }; +} + +function _slicedToArray$j(arr, i) { return _arrayWithHoles$k(arr) || _iterableToArrayLimit$j(arr, i) || _unsupportedIterableToArray$v(arr, i) || _nonIterableRest$k(); } + +function _nonIterableRest$k() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$v(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$v(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$v(o, minLen); } + +function _arrayLikeToArray$v(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$j(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$k(arr) { if (Array.isArray(arr)) return arr; } +var KEY$8 = 'remove_row'; +/** + * @returns {object} + */ + +function removeRowItem() { + return { + key: KEY$8, + name: function name() { + var selection = this.getSelected(); + var pluralForm = 0; + + if (selection) { + if (selection.length > 1) { + pluralForm = 1; + } else { + var _selection$ = _slicedToArray$j(selection[0], 3), + fromRow = _selection$[0], + toRow = _selection$[2]; + + if (fromRow - toRow !== 0) { + pluralForm = 1; + } + } + } + + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_REMOVE_ROW, pluralForm); + }, + callback: function callback() { + // TODO: Please keep in mind that below `1` may be improper. The table's way of work, before change `f1747b3912ea3b21fe423fd102ca94c87db81379` was restored. + // There is still problem when removing more than one row. + this.alter('remove_row', transformSelectionToRowDistance(this.getSelected()), 1, 'ContextMenu.removeRow'); + }, + disabled: function disabled() { + var selected = getValidSelection(this); + + if (!selected) { + return true; + } + + var totalRows = this.countRows(); + + if (this.selection.isSelectedByCorner()) { + // Enable "Remove row" only when there is at least one row. + return totalRows === 0; + } + + return this.selection.isSelectedByColumnHeader() || totalRows === 0; + }, + hidden: function hidden() { + return !this.getSettings().allowRemoveRow; + } + }; +} + +var KEY$9 = 'row_above'; +/** + * @returns {object} + */ + +function rowAboveItem() { + return { + key: KEY$9, + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ROW_ABOVE); + }, + callback: function callback(key, normalizedSelection) { + var isSelectedByCorner = this.selection.isSelectedByCorner(); + var rowAbove = 0; + + if (!isSelectedByCorner) { + var latestSelection = normalizedSelection[Math.max(normalizedSelection.length - 1, 0)]; + rowAbove = latestSelection.start.row; + } + + this.alter('insert_row', rowAbove, 1, 'ContextMenu.rowAbove'); + + if (isSelectedByCorner) { + this.selectAll(); + } + }, + disabled: function disabled() { + var selected = getValidSelection(this); + + if (!selected) { + return true; + } + + if (this.selection.isSelectedByCorner()) { + var totalRows = this.countRows(); // Enable "Insert row above" only when there is at least one row. + + return totalRows === 0; + } + + return this.selection.isSelectedByColumnHeader() || this.countRows() >= this.getSettings().maxRows; + }, + hidden: function hidden() { + return !this.getSettings().allowInsertRow; + } + }; +} + +var KEY$a = 'row_below'; +/** + * @returns {object} + */ + +function rowBelowItem() { + return { + key: KEY$a, + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_ROW_BELOW); + }, + callback: function callback(key, normalizedSelection) { + var isSelectedByCorner = this.selection.isSelectedByCorner(); + var rowBelow = 0; + + if (isSelectedByCorner) { + rowBelow = this.countRows(); + } else { + var _latestSelection$end; + + var latestSelection = normalizedSelection[Math.max(normalizedSelection.length - 1, 0)]; + var selectedRow = latestSelection === null || latestSelection === void 0 ? void 0 : (_latestSelection$end = latestSelection.end) === null || _latestSelection$end === void 0 ? void 0 : _latestSelection$end.row; // If there is no selection we have clicked on the corner and there is no data. + + rowBelow = isDefined(selectedRow) ? selectedRow + 1 : 0; + } + + this.alter('insert_row', rowBelow, 1, 'ContextMenu.rowBelow'); + + if (isSelectedByCorner) { + this.selectAll(); + } + }, + disabled: function disabled() { + var selected = getValidSelection(this); + + if (!selected) { + return true; + } + + if (this.selection.isSelectedByCorner()) { + // Enable "Insert row below" always when the menu is triggered by corner click. + return false; + } + + return this.selection.isSelectedByColumnHeader() || this.countRows() >= this.getSettings().maxRows; + }, + hidden: function hidden() { + return !this.getSettings().allowInsertRow; + } + }; +} + +var KEY$b = 'no_items'; +/** + * @returns {object} + */ + +function noItemsItem() { + return { + key: KEY$b, + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_NO_ITEMS); + }, + disabled: true, + isCommand: false + }; +} + +var KEY$c = 'undo'; +/** + * @returns {object} + */ + +function undoItem() { + return { + key: KEY$c, + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_UNDO); + }, + callback: function callback() { + this.undo(); + }, + hidden: function hidden() { + var undoRedo = this.getPlugin('undoRedo'); + return !undoRedo || !undoRedo.isEnabled(); + }, + disabled: function disabled() { + return !this.getPlugin('undoRedo').isUndoAvailable(); + } + }; +} + +var _predefinedItems2; + +function _defineProperty$h(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +var ITEMS = [KEY$9, KEY$a, KEY$3, KEY$4, KEY$2, KEY$8, KEY$7, KEY$c, KEY$6, KEY$5, KEY$1, KEY, KEY$b]; + +var _predefinedItems = (_predefinedItems2 = {}, _defineProperty$h(_predefinedItems2, KEY, separatorItem), _defineProperty$h(_predefinedItems2, KEY$b, noItemsItem), _defineProperty$h(_predefinedItems2, KEY$9, rowAboveItem), _defineProperty$h(_predefinedItems2, KEY$a, rowBelowItem), _defineProperty$h(_predefinedItems2, KEY$3, columnLeftItem), _defineProperty$h(_predefinedItems2, KEY$4, columnRightItem), _defineProperty$h(_predefinedItems2, KEY$2, clearColumnItem), _defineProperty$h(_predefinedItems2, KEY$8, removeRowItem), _defineProperty$h(_predefinedItems2, KEY$7, removeColumnItem), _defineProperty$h(_predefinedItems2, KEY$c, undoItem), _defineProperty$h(_predefinedItems2, KEY$6, redoItem), _defineProperty$h(_predefinedItems2, KEY$5, readOnlyItem), _defineProperty$h(_predefinedItems2, KEY$1, alignmentItem), _predefinedItems2); +/** + * Gets new object with all predefined menu items. + * + * @returns {object} + */ + + +function predefinedItems() { + var items = {}; + objectEach(_predefinedItems, function (itemFactory, key) { + items[key] = itemFactory(); + }); + return items; +} + +function _classCallCheck$1u(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1p(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); } } + +function _createClass$1p(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1p(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1p(Constructor, staticProps); return Constructor; } +/** + * Predefined items class factory for menu items. + * + * @class ItemsFactory + * @plugin ContextMenu + */ + +var ItemsFactory = /*#__PURE__*/function () { + function ItemsFactory(hotInstance) { + var orderPattern = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + _classCallCheck$1u(this, ItemsFactory); + + this.hot = hotInstance; + this.predefinedItems = predefinedItems(); + this.defaultOrderPattern = orderPattern; + } + /** + * Set predefined items. + * + * @param {Array} predefinedItemsCollection Array of predefined items. + */ + + + _createClass$1p(ItemsFactory, [{ + key: "setPredefinedItems", + value: function setPredefinedItems(predefinedItemsCollection) { + var _this = this; + + var items = {}; + this.defaultOrderPattern.length = 0; + objectEach(predefinedItemsCollection, function (value, key) { + var menuItemKey = ''; + + if (value.name === KEY) { + items[KEY] = value; + menuItemKey = KEY; // Menu item added as a property to array + } else if (isNaN(parseInt(key, 10))) { + value.key = value.key === void 0 ? key : value.key; + items[key] = value; + menuItemKey = value.key; + } else { + items[value.key] = value; + menuItemKey = value.key; + } + + _this.defaultOrderPattern.push(menuItemKey); + }); + this.predefinedItems = items; + } + /** + * Get all menu items based on pattern. + * + * @param {Array|object|boolean} pattern Pattern which you can define by displaying menu items order. If `true` default + * pattern will be used. + * @returns {Array} + */ + + }, { + key: "getItems", + value: function getItems() { + var pattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + return _getItems(pattern, this.defaultOrderPattern, this.predefinedItems); + } + }]); + + return ItemsFactory; +}(); +/** + * @param {object[]} itemsPattern The user defined menu items collection. + * @param {object[]} defaultPattern The menu default items collection. + * @param {object} items Additional options. + * @returns {object[]} Returns parsed and merged menu items collection ready to render. + */ + + +function _getItems() { + var itemsPattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + var defaultPattern = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + var items = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + var result = []; + var pattern = itemsPattern; + + if (pattern && pattern.items) { + pattern = pattern.items; + } else if (!Array.isArray(pattern)) { + pattern = defaultPattern; + } + + if (isObject$1(pattern)) { + objectEach(pattern, function (value, key) { + var item = items[typeof value === 'string' ? value : key]; + + if (!item) { + item = value; + } + + if (isObject$1(value)) { + extend(item, value); + } else if (typeof item === 'string') { + item = { + name: item + }; + } + + if (item.key === void 0) { + item.key = key; + } + + result.push(item); + }); + } else { + arrayEach(pattern, function (name, key) { + var item = items[name]; // Item deleted from settings `allowInsertRow: false` etc. + + if (!item && ITEMS.indexOf(name) >= 0) { + return; + } + + if (!item) { + item = { + name: name, + key: "".concat(key) + }; + } + + if (isObject$1(name)) { + extend(item, name); + } + + if (item.key === void 0) { + item.key = key; + } + + result.push(item); + }); + } + + return result; +} + +function _classCallCheck$1v(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1q(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); } } + +function _createClass$1q(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1q(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1q(Constructor, staticProps); return Constructor; } +/** + * Helper class for checking if element will fit at the desired side of cursor. + * + * @class Cursor + * @plugin ContextMenu + */ + +var Cursor = /*#__PURE__*/function () { + function Cursor(object, rootWindow) { + _classCallCheck$1v(this, Cursor); + + var windowScrollTop = getWindowScrollTop(rootWindow); + var windowScrollLeft = getWindowScrollLeft(rootWindow); + var top; + var topRelative; + var left; + var leftRelative; + var cellHeight; + var cellWidth; + this.rootWindow = rootWindow; + this.type = this.getSourceType(object); + + if (this.type === 'literal') { + top = parseInt(object.top, 10); + left = parseInt(object.left, 10); + cellHeight = object.height || 0; + cellWidth = object.width || 0; + topRelative = top; + leftRelative = left; + top += windowScrollTop; + left += windowScrollLeft; + } else if (this.type === 'event') { + top = parseInt(object.pageY, 10); + left = parseInt(object.pageX, 10); + cellHeight = object.target.clientHeight; + cellWidth = object.target.clientWidth; + topRelative = top - windowScrollTop; + leftRelative = left - windowScrollLeft; + } + + this.top = top; + this.topRelative = topRelative; + this.left = left; + this.leftRelative = leftRelative; + this.scrollTop = windowScrollTop; + this.scrollLeft = windowScrollLeft; + this.cellHeight = cellHeight; + this.cellWidth = cellWidth; + } + /** + * Get source type name. + * + * @param {*} object Event or Object with coordinates. + * @returns {string} Returns one of this values: `'literal'`, `'event'`. + */ + + + _createClass$1q(Cursor, [{ + key: "getSourceType", + value: function getSourceType(object) { + var type = 'literal'; + + if (object instanceof Event) { + type = 'event'; + } + + return type; + } + /** + * Checks if element can be placed above the cursor. + * + * @param {HTMLElement} element Element to check if it's size will fit above the cursor. + * @returns {boolean} + */ + + }, { + key: "fitsAbove", + value: function fitsAbove(element) { + return this.topRelative >= element.offsetHeight; + } + /** + * Checks if element can be placed below the cursor. + * + * @param {HTMLElement} element Element to check if it's size will fit below the cursor. + * @param {number} [viewportHeight] The viewport height. + * @returns {boolean} + */ + + }, { + key: "fitsBelow", + value: function fitsBelow(element) { + var viewportHeight = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.rootWindow.innerHeight; + return this.topRelative + element.offsetHeight <= viewportHeight; + } + /** + * Checks if element can be placed on the right of the cursor. + * + * @param {HTMLElement} element Element to check if it's size will fit on the right of the cursor. + * @param {number} [viewportWidth] The viewport width. + * @returns {boolean} + */ + + }, { + key: "fitsOnRight", + value: function fitsOnRight(element) { + var viewportWidth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.rootWindow.innerWidth; + return this.leftRelative + this.cellWidth + element.offsetWidth <= viewportWidth; + } + /** + * Checks if element can be placed on the left on the cursor. + * + * @param {HTMLElement} element Element to check if it's size will fit on the left of the cursor. + * @returns {boolean} + */ + + }, { + key: "fitsOnLeft", + value: function fitsOnLeft(element) { + return this.leftRelative >= element.offsetWidth; + } + }]); + + return Cursor; +}(); + +function _classCallCheck$1w(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1r(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); } } + +function _createClass$1r(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1r(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1r(Constructor, staticProps); return Constructor; } +var MIN_WIDTH = 215; +/** + * @class Menu + * @plugin ContextMenu + */ + +var Menu = /*#__PURE__*/function () { + function Menu(hotInstance, options) { + _classCallCheck$1w(this, Menu); + + this.hot = hotInstance; + this.options = options || { + parent: null, + name: null, + className: '', + keepInViewport: true, + standalone: false, + minWidth: MIN_WIDTH, + container: this.hot.rootDocument.documentElement + }; + this.eventManager = new EventManager(this); + this.container = this.createContainer(this.options.name); + this.hotMenu = null; + this.hotSubMenus = {}; + this.parentMenu = this.options.parent || null; + this.menuItems = null; + this.origOutsideClickDeselects = null; + this.keyEvent = false; + this.offset = { + above: 0, + below: 0, + left: 0, + right: 0 + }; + this._afterScrollCallback = null; + this.registerEvents(); + } + /** + * Register event listeners. + * + * @private + */ + + + _createClass$1r(Menu, [{ + key: "registerEvents", + value: function registerEvents() { + var _this = this; + + var frame = this.hot.rootWindow; + + while (frame) { + this.eventManager.addEventListener(frame.document, 'mousedown', function (event) { + return _this.onDocumentMouseDown(event); + }); + this.eventManager.addEventListener(frame.document, 'contextmenu', function (event) { + return _this.onDocumentContextMenu(event); + }); + frame = getParentWindow(frame); + } + } + /** + * Set array of objects which defines menu items. + * + * @param {Array} menuItems Menu items to display. + */ + + }, { + key: "setMenuItems", + value: function setMenuItems(menuItems) { + this.menuItems = menuItems; + } + /** + * Returns currently selected menu item. Returns `null` if no item was selected. + * + * @returns {object|null} + */ + + }, { + key: "getSelectedItem", + value: function getSelectedItem() { + return this.hasSelectedItem() ? this.hotMenu.getSourceDataAtRow(this.hotMenu.getSelectedLast()[0]) : null; + } + /** + * Checks if the menu has selected (highlighted) any item from the menu list. + * + * @returns {boolean} + */ + + }, { + key: "hasSelectedItem", + value: function hasSelectedItem() { + return Array.isArray(this.hotMenu.getSelectedLast()); + } + /** + * Set offset menu position for specified area (`above`, `below`, `left` or `right`). + * + * @param {string} area Specified area name (`above`, `below`, `left` or `right`). + * @param {number} offset Offset value. + */ + + }, { + key: "setOffset", + value: function setOffset(area) { + var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + this.offset[area] = offset; + } + /** + * Check if menu is using as sub-menu. + * + * @returns {boolean} + */ + + }, { + key: "isSubMenu", + value: function isSubMenu() { + return this.parentMenu !== null; + } + /** + * Open menu. + * + * @fires Hooks#beforeContextMenuShow + * @fires Hooks#afterContextMenuShow + */ + + }, { + key: "open", + value: function open() { + var _this2 = this; + + this.runLocalHooks('beforeOpen'); + this.container.removeAttribute('style'); + this.container.style.display = 'block'; + var delayedOpenSubMenu = debounce(function (row) { + return _this2.openSubMenu(row); + }, 300); + var minWidthOfMenu = this.options.minWidth || MIN_WIDTH; + var noItemsDefined = false; + var filteredItems = arrayFilter(this.menuItems, function (item) { + if (item.key === KEY$b) { + noItemsDefined = true; + } + + return isItemHidden(item, _this2.hot); + }); + + if (filteredItems.length < 1 && !noItemsDefined) { + filteredItems.push(predefinedItems()[KEY$b]); + } else if (filteredItems.length === 0) { + return; + } + + filteredItems = filterSeparators(filteredItems, KEY); + var shouldAutoCloseMenu = false; + var settings = { + data: filteredItems, + colHeaders: false, + autoColumnSize: true, + autoWrapRow: false, + modifyColWidth: function modifyColWidth(width) { + if (isDefined(width) && width < minWidthOfMenu) { + return minWidthOfMenu; + } + + return width; + }, + autoRowSize: false, + readOnly: true, + editor: false, + copyPaste: false, + maxCols: 1, + columns: [{ + data: 'name', + renderer: function renderer(hot, TD, row, col, prop, value) { + return _this2.menuItemRenderer(hot, TD, row, col, prop, value); + } + }], + renderAllRows: true, + fragmentSelection: false, + outsideClickDeselects: false, + disableVisualSelection: 'area', + beforeKeyDown: function beforeKeyDown(event) { + return _this2.onBeforeKeyDown(event); + }, + afterOnCellMouseOver: function afterOnCellMouseOver(event, coords) { + if (_this2.isAllSubMenusClosed()) { + delayedOpenSubMenu(coords.row); + } else { + _this2.openSubMenu(coords.row); + } + }, + rowHeights: function rowHeights(row) { + return filteredItems[row].name === KEY ? 1 : 23; + }, + afterOnCellContextMenu: function afterOnCellContextMenu(event) { + event.preventDefault(); // On the Windows platform, the "contextmenu" is triggered after the "mouseup" so that's + // why the closing menu is here. (#6507#issuecomment-582392301). + + if (isWindowsOS() && shouldAutoCloseMenu && _this2.hasSelectedItem()) { + _this2.close(true); + } + }, + beforeOnCellMouseUp: function beforeOnCellMouseUp(event) { + if (_this2.hasSelectedItem()) { + shouldAutoCloseMenu = !_this2.isCommandPassive(_this2.getSelectedItem()); + + _this2.executeCommand(event); + } + }, + afterOnCellMouseUp: function afterOnCellMouseUp(event) { + // If the code runs on the other platform than Windows, the "mouseup" is triggered + // after the "contextmenu". So then "mouseup" closes the menu. Otherwise, the closing + // menu responsibility is forwarded to "afterOnCellContextMenu" callback (#6507#issuecomment-582392301). + if ((!isWindowsOS() || !isRightClick(event)) && shouldAutoCloseMenu && _this2.hasSelectedItem()) { + _this2.close(true); + } + }, + afterUnlisten: function afterUnlisten() { + // Restore menu focus, fix for `this.instance.unlisten();` call in the tableView.js@260 file. + // This prevents losing table responsiveness for keyboard events when filter select menu is closed (#6497). + if (!_this2.hasSelectedItem() && _this2.isOpened()) { + _this2.hotMenu.listen(); + } + } + }; + this.origOutsideClickDeselects = this.hot.getSettings().outsideClickDeselects; + this.hot.getSettings().outsideClickDeselects = false; + this.hotMenu = new Core(this.container, settings); + this.hotMenu.addHook('afterInit', function () { + return _this2.onAfterInit(); + }); + this.hotMenu.addHook('afterSelection', function () { + return _this2.onAfterSelection.apply(_this2, arguments); + }); + this.hotMenu.init(); + this.hotMenu.listen(); + this.blockMainTableCallbacks(); + this.runLocalHooks('afterOpen'); + } + /** + * Close menu. + * + * @param {boolean} [closeParent=false] If `true` try to close parent menu if exists. + */ + + }, { + key: "close", + value: function close() { + var closeParent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + if (!this.isOpened()) { + return; + } + + if (closeParent && this.parentMenu) { + this.parentMenu.close(); + } else { + this.closeAllSubMenus(); + this.container.style.display = 'none'; + this.releaseMainTableCallbacks(); + this.hotMenu.destroy(); + this.hotMenu = null; + this.hot.getSettings().outsideClickDeselects = this.origOutsideClickDeselects; + this.runLocalHooks('afterClose'); + + if (this.parentMenu) { + this.parentMenu.hotMenu.listen(); + } + } + } + /** + * Open sub menu at the provided row index. + * + * @param {number} row Row index. + * @returns {Menu|boolean} Returns created menu or `false` if no one menu was created. + */ + + }, { + key: "openSubMenu", + value: function openSubMenu(row) { + if (!this.hotMenu) { + return false; + } + + var cell = this.hotMenu.getCell(row, 0); + this.closeAllSubMenus(); + + if (!cell || !hasSubMenu(cell)) { + return false; + } + + var dataItem = this.hotMenu.getSourceDataAtRow(row); + var subMenu = new Menu(this.hot, { + parent: this, + name: dataItem.name, + className: this.options.className, + keepInViewport: true, + container: this.options.container + }); + subMenu.setMenuItems(dataItem.submenu.items); + subMenu.open(); + subMenu.setPosition(cell.getBoundingClientRect()); + this.hotSubMenus[dataItem.key] = subMenu; + return subMenu; + } + /** + * Close sub menu at row index. + * + * @param {number} row Row index. + */ + + }, { + key: "closeSubMenu", + value: function closeSubMenu(row) { + var dataItem = this.hotMenu.getSourceDataAtRow(row); + var menus = this.hotSubMenus[dataItem.key]; + + if (menus) { + menus.destroy(); + delete this.hotSubMenus[dataItem.key]; + } + } + /** + * Close all opened sub menus. + */ + + }, { + key: "closeAllSubMenus", + value: function closeAllSubMenus() { + var _this3 = this; + + arrayEach(this.hotMenu.getData(), function (value, row) { + return _this3.closeSubMenu(row); + }); + } + /** + * Checks if all created and opened sub menus are closed. + * + * @returns {boolean} + */ + + }, { + key: "isAllSubMenusClosed", + value: function isAllSubMenusClosed() { + return Object.keys(this.hotSubMenus).length === 0; + } + /** + * Destroy instance. + */ + + }, { + key: "destroy", + value: function destroy() { + var menuContainerParentElement = this.container.parentNode; + this.clearLocalHooks(); + this.close(); + this.parentMenu = null; + this.eventManager.destroy(); + + if (menuContainerParentElement) { + menuContainerParentElement.removeChild(this.container); + } + } + /** + * Checks if menu was opened. + * + * @returns {boolean} Returns `true` if menu was opened. + */ + + }, { + key: "isOpened", + value: function isOpened() { + return this.hotMenu !== null; + } + /** + * Execute menu command. + * + * @param {Event} [event] The mouse event object. + */ + + }, { + key: "executeCommand", + value: function executeCommand(event) { + if (!this.isOpened() || !this.hasSelectedItem()) { + return; + } + + var selectedItem = this.getSelectedItem(); + this.runLocalHooks('select', selectedItem, event); + + if (this.isCommandPassive(selectedItem)) { + return; + } + + var selRanges = this.hot.getSelectedRange(); + var normalizedSelection = selRanges ? normalizeSelection(selRanges) : []; + this.runLocalHooks('executeCommand', selectedItem.key, normalizedSelection, event); + + if (this.isSubMenu()) { + this.parentMenu.runLocalHooks('executeCommand', selectedItem.key, normalizedSelection, event); + } + } + /** + * Checks if the passed command is passive or not. The command is passive when it's marked as + * disabled, the descriptor object contains `isCommand` property set to `false`, command + * is a separator, or the item is recognized as submenu. For passive items the menu is not + * closed automatically after the user trigger the command through the UI. + * + * @param {object} commandDescriptor Selected menu item from the menu data source. + * @returns {boolean} + */ + + }, { + key: "isCommandPassive", + value: function isCommandPassive(commandDescriptor) { + var isCommand = commandDescriptor.isCommand, + commandName = commandDescriptor.name, + disabled = commandDescriptor.disabled, + submenu = commandDescriptor.submenu; + var isItemDisabled = disabled === true || typeof disabled === 'function' && disabled.call(this.hot) === true; + return isCommand === false || commandName === KEY || isItemDisabled === true || submenu; + } + /** + * Set menu position based on dom event or based on literal object. + * + * @param {Event|object} coords Event or literal Object with coordinates. + */ + + }, { + key: "setPosition", + value: function setPosition(coords) { + var cursor = new Cursor(coords, this.container.ownerDocument.defaultView); + + if (this.options.keepInViewport) { + if (cursor.fitsBelow(this.container)) { + this.setPositionBelowCursor(cursor); + } else if (cursor.fitsAbove(this.container)) { + this.setPositionAboveCursor(cursor); + } else { + this.setPositionBelowCursor(cursor); + } + + if (cursor.fitsOnRight(this.container)) { + this.setPositionOnRightOfCursor(cursor); + } else { + this.setPositionOnLeftOfCursor(cursor); + } + } else { + this.setPositionBelowCursor(cursor); + this.setPositionOnRightOfCursor(cursor); + } + } + /** + * Set menu position above cursor object. + * + * @param {Cursor} cursor `Cursor` object. + */ + + }, { + key: "setPositionAboveCursor", + value: function setPositionAboveCursor(cursor) { + var top = this.offset.above + cursor.top - this.container.offsetHeight; + + if (this.isSubMenu()) { + top = cursor.top + cursor.cellHeight - this.container.offsetHeight + 3; + } + + this.container.style.top = "".concat(top, "px"); + } + /** + * Set menu position below cursor object. + * + * @param {Cursor} cursor `Cursor` object. + */ + + }, { + key: "setPositionBelowCursor", + value: function setPositionBelowCursor(cursor) { + var top = this.offset.below + cursor.top + 1; + + if (this.isSubMenu()) { + top = cursor.top - 1; + } + + this.container.style.top = "".concat(top, "px"); + } + /** + * Set menu position on the right of cursor object. + * + * @param {Cursor} cursor `Cursor` object. + */ + + }, { + key: "setPositionOnRightOfCursor", + value: function setPositionOnRightOfCursor(cursor) { + var left; + + if (this.isSubMenu()) { + left = 1 + cursor.left + cursor.cellWidth; + } else { + left = this.offset.right + 1 + cursor.left; + } + + this.container.style.left = "".concat(left, "px"); + } + /** + * Set menu position on the left of cursor object. + * + * @param {Cursor} cursor `Cursor` object. + */ + + }, { + key: "setPositionOnLeftOfCursor", + value: function setPositionOnLeftOfCursor(cursor) { + var scrollbarWidth = getScrollbarWidth(this.hot.rootDocument); + var left = this.offset.left + cursor.left - this.container.offsetWidth + scrollbarWidth + 4; + this.container.style.left = "".concat(left, "px"); + } + /** + * Select first cell in opened menu. + */ + + }, { + key: "selectFirstCell", + value: function selectFirstCell() { + var cell = this.hotMenu.getCell(0, 0); + + if (isSeparator(cell) || isDisabled(cell) || isSelectionDisabled(cell)) { + this.selectNextCell(0, 0); + } else { + this.hotMenu.selectCell(0, 0); + } + } + /** + * Select last cell in opened menu. + */ + + }, { + key: "selectLastCell", + value: function selectLastCell() { + var lastRow = this.hotMenu.countRows() - 1; + var cell = this.hotMenu.getCell(lastRow, 0); + + if (isSeparator(cell) || isDisabled(cell) || isSelectionDisabled(cell)) { + this.selectPrevCell(lastRow, 0); + } else { + this.hotMenu.selectCell(lastRow, 0); + } + } + /** + * Select next cell in opened menu. + * + * @param {number} row Row index. + * @param {number} col Column index. + */ + + }, { + key: "selectNextCell", + value: function selectNextCell(row, col) { + var nextRow = row + 1; + var cell = nextRow < this.hotMenu.countRows() ? this.hotMenu.getCell(nextRow, col) : null; + + if (!cell) { + return; + } + + if (isSeparator(cell) || isDisabled(cell) || isSelectionDisabled(cell)) { + this.selectNextCell(nextRow, col); + } else { + this.hotMenu.selectCell(nextRow, col); + } + } + /** + * Select previous cell in opened menu. + * + * @param {number} row Row index. + * @param {number} col Column index. + */ + + }, { + key: "selectPrevCell", + value: function selectPrevCell(row, col) { + var prevRow = row - 1; + var cell = prevRow >= 0 ? this.hotMenu.getCell(prevRow, col) : null; + + if (!cell) { + return; + } + + if (isSeparator(cell) || isDisabled(cell) || isSelectionDisabled(cell)) { + this.selectPrevCell(prevRow, col); + } else { + this.hotMenu.selectCell(prevRow, col); + } + } + /** + * Menu item renderer. + * + * @private + * @param {Core} hot The Handsontable instance. + * @param {HTMLCellElement} TD The rendered cell element. + * @param {number} row The visual index. + * @param {number} col The visual index. + * @param {string} prop The column property if used. + * @param {string} value The cell value. + */ + + }, { + key: "menuItemRenderer", + value: function menuItemRenderer(hot, TD, row, col, prop, value) { + var _this4 = this; + + var item = hot.getSourceDataAtRow(row); + var wrapper = this.hot.rootDocument.createElement('div'); + + var isSubMenu = function isSubMenu(itemToTest) { + return hasOwnProperty$1(itemToTest, 'submenu'); + }; + + var itemIsSeparator = function itemIsSeparator(itemToTest) { + return new RegExp(KEY, 'i').test(itemToTest.name); + }; + + var itemIsDisabled = function itemIsDisabled(itemToTest) { + return itemToTest.disabled === true || typeof itemToTest.disabled === 'function' && itemToTest.disabled.call(_this4.hot) === true; + }; + + var itemIsSelectionDisabled = function itemIsSelectionDisabled(itemToTest) { + return itemToTest.disableSelection; + }; + + var itemValue = value; + + if (typeof itemValue === 'function') { + itemValue = itemValue.call(this.hot); + } + + empty(TD); + addClass(wrapper, 'htItemWrapper'); + TD.appendChild(wrapper); + + if (itemIsSeparator(item)) { + addClass(TD, 'htSeparator'); + } else if (typeof item.renderer === 'function') { + addClass(TD, 'htCustomMenuRenderer'); + TD.appendChild(item.renderer(hot, wrapper, row, col, prop, itemValue)); + } else { + fastInnerHTML(wrapper, itemValue); + } + + if (itemIsDisabled(item)) { + addClass(TD, 'htDisabled'); + this.eventManager.addEventListener(TD, 'mouseenter', function () { + return hot.deselectCell(); + }); + } else if (itemIsSelectionDisabled(item)) { + addClass(TD, 'htSelectionDisabled'); + this.eventManager.addEventListener(TD, 'mouseenter', function () { + return hot.deselectCell(); + }); + } else if (isSubMenu(item)) { + addClass(TD, 'htSubmenu'); + + if (itemIsSelectionDisabled(item)) { + this.eventManager.addEventListener(TD, 'mouseenter', function () { + return hot.deselectCell(); + }); + } else { + this.eventManager.addEventListener(TD, 'mouseenter', function () { + return hot.selectCell(row, col, void 0, void 0, false, false); + }); + } + } else { + removeClass(TD, ['htSubmenu', 'htDisabled']); + + if (itemIsSelectionDisabled(item)) { + this.eventManager.addEventListener(TD, 'mouseenter', function () { + return hot.deselectCell(); + }); + } else { + this.eventManager.addEventListener(TD, 'mouseenter', function () { + return hot.selectCell(row, col, void 0, void 0, false, false); + }); + } + } + } + /** + * Create container/wrapper for handsontable. + * + * @private + * @param {string} [name] Class name. + * @returns {HTMLElement} + */ + + }, { + key: "createContainer", + value: function createContainer() { + var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + var doc = this.options.container.ownerDocument; + var className = name; + var container; + + if (className) { + if (isFunction(className)) { + className = className.call(this.hot); + + if (className === null || isUndefined(className)) { + className = ''; + } else { + className = className.toString(); + } + } + + className = className.replace(/[^A-z0-9]/g, '_'); + className = "".concat(this.options.className, "Sub_").concat(className); + container = doc.querySelector(".".concat(this.options.className, ".").concat(className)); + } + + if (!container) { + container = doc.createElement('div'); + addClass(container, "htMenu ".concat(this.options.className)); + + if (className) { + addClass(container, className); + } + + this.options.container.appendChild(container); + } + + return container; + } + /** + * @private + */ + + }, { + key: "blockMainTableCallbacks", + value: function blockMainTableCallbacks() { + this._afterScrollCallback = function () {}; + + this.hot.addHook('afterScrollVertically', this._afterScrollCallback); + this.hot.addHook('afterScrollHorizontally', this._afterScrollCallback); + } + /** + * @private + */ + + }, { + key: "releaseMainTableCallbacks", + value: function releaseMainTableCallbacks() { + if (this._afterScrollCallback) { + this.hot.removeHook('afterScrollVertically', this._afterScrollCallback); + this.hot.removeHook('afterScrollHorizontally', this._afterScrollCallback); + this._afterScrollCallback = null; + } + } + /** + * On before key down listener. + * + * @private + * @param {Event} event The keyaboard event object. + */ + + }, { + key: "onBeforeKeyDown", + value: function onBeforeKeyDown(event) { + // For input elements, prevent event propagation. It allows entering text into an input + // element freely - without steeling the key events from the menu module (#6506, #6549). + if (isInput(event.target) && this.container.contains(event.target)) { + stopImmediatePropagation(event); + return; + } + + var selection = this.hotMenu.getSelectedLast(); + var stopEvent = false; + this.keyEvent = true; + + switch (event.keyCode) { + case KEY_CODES.ESCAPE: + this.close(); + stopEvent = true; + break; + + case KEY_CODES.ENTER: + if (selection) { + if (this.hotMenu.getSourceDataAtRow(selection[0]).submenu) { + stopEvent = true; + } else { + this.executeCommand(event); + this.close(true); + } + } + + break; + + case KEY_CODES.ARROW_DOWN: + if (selection) { + this.selectNextCell(selection[0], selection[1]); + } else { + this.selectFirstCell(); + } + + stopEvent = true; + break; + + case KEY_CODES.ARROW_UP: + if (selection) { + this.selectPrevCell(selection[0], selection[1]); + } else { + this.selectLastCell(); + } + + stopEvent = true; + break; + + case KEY_CODES.ARROW_RIGHT: + if (selection) { + var menu = this.openSubMenu(selection[0]); + + if (menu) { + menu.selectFirstCell(); + } + } + + stopEvent = true; + break; + + case KEY_CODES.ARROW_LEFT: + if (selection && this.isSubMenu()) { + this.close(); + + if (this.parentMenu) { + this.parentMenu.hotMenu.listen(); + } + + stopEvent = true; + } + + break; + } + + if (stopEvent) { + event.preventDefault(); + stopImmediatePropagation(event); + } + + this.keyEvent = false; + } + /** + * On after init listener. + * + * @private + */ + + }, { + key: "onAfterInit", + value: function onAfterInit() { + var wtTable = this.hotMenu.view.wt.wtTable; + var data = this.hotMenu.getSettings().data; + var hiderStyle = wtTable.hider.style; + var holderStyle = wtTable.holder.style; + var currentHiderWidth = parseInt(hiderStyle.width, 10); + var realHeight = arrayReduce(data, function (accumulator, value) { + return accumulator + (value.name === KEY ? 1 : 26); + }, 0); // Additional 3px to menu's size because of additional border around its `table.htCore`. + + holderStyle.width = "".concat(currentHiderWidth + 3, "px"); + holderStyle.height = "".concat(realHeight + 3, "px"); + hiderStyle.height = holderStyle.height; + } + /** + * On after selection listener. + * + * @param {number} r Selection start row index. + * @param {number} c Selection start column index. + * @param {number} r2 Selection end row index. + * @param {number} c2 Selection end column index. + * @param {object} preventScrolling Object with `value` property where its value change will be observed. + */ + + }, { + key: "onAfterSelection", + value: function onAfterSelection(r, c, r2, c2, preventScrolling) { + if (this.keyEvent === false) { + preventScrolling.value = true; + } + } + /** + * Document mouse down listener. + * + * @private + * @param {Event} event The mouse event object. + */ + + }, { + key: "onDocumentMouseDown", + value: function onDocumentMouseDown(event) { + if (!this.isOpened()) { + return; + } // Close menu when clicked element is not belongs to menu itself + + + if (this.options.standalone && this.hotMenu && !isChildOf(event.target, this.hotMenu.rootElement)) { + this.close(true); // Automatically close menu when clicked element is not belongs to menu or submenu (not necessarily to itself) + } else if ((this.isAllSubMenusClosed() || this.isSubMenu()) && !isChildOf(event.target, '.htMenu') && (isChildOf(event.target, this.container.ownerDocument) || isChildOf(event.target, this.hot.rootDocument))) { + this.close(true); + } + } + /** + * Document's contextmenu listener. + * + * @private + * @param {MouseEvent} event The mouse event object. + */ + + }, { + key: "onDocumentContextMenu", + value: function onDocumentContextMenu(event) { + if (!this.isOpened()) { + return; + } + + if (hasClass(event.target, 'htCore') && isChildOf(event.target, this.hotMenu.rootElement)) { + event.preventDefault(); + } + } + }]); + + return Menu; +}(); + +mixin(Menu, localHooks); + +function _typeof$Q(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$Q = function _typeof(obj) { return typeof obj; }; } else { _typeof$Q = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$Q(obj); } + +function _classCallCheck$1x(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1s(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); } } + +function _createClass$1s(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1s(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1s(Constructor, staticProps); return Constructor; } + +function _get$i(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$i = Reflect.get; } else { _get$i = function _get(target, property, receiver) { var base = _superPropBase$i(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$i(target, property, receiver || target); } + +function _superPropBase$i(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$F(object); if (object === null) break; } return object; } + +function _inherits$F(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$G(subClass, superClass); } + +function _setPrototypeOf$G(o, p) { _setPrototypeOf$G = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$G(o, p); } + +function _createSuper$F(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$G(); return function _createSuperInternal() { var Super = _getPrototypeOf$F(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$F(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$F(this, result); }; } + +function _possibleConstructorReturn$F(self, call) { if (call && (_typeof$Q(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$F(self); } + +function _assertThisInitialized$F(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$G() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$F(o) { _getPrototypeOf$F = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$F(o); } +var PLUGIN_KEY$8 = 'contextMenu'; +var PLUGIN_PRIORITY$7 = 70; +Hooks.getSingleton().register('afterContextMenuDefaultOptions'); +Hooks.getSingleton().register('beforeContextMenuShow'); +Hooks.getSingleton().register('afterContextMenuShow'); +Hooks.getSingleton().register('afterContextMenuHide'); +Hooks.getSingleton().register('afterContextMenuExecute'); +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @class ContextMenu + * @description + * This plugin creates the Handsontable Context Menu. It allows to create a new row or column at any place in the + * grid among [other features](https://handsontable.com/docs/demo-context-menu.html). + * Possible values: + * * `true` (to enable default options), + * * `false` (to disable completely) + * * `{ uiContainer: containerDomElement }` (to declare a container for all of the Context Menu's dom elements to be placed in). + * + * or array of any available strings: + * * `'row_above'` + * * `'row_below'` + * * `'col_left'` + * * `'col_right'` + * * `'remove_row'` + * * `'remove_col'` + * * `'undo'` + * * `'redo'` + * * `'make_read_only'` + * * `'alignment'` + * * `'---------'` (menu item separator) + * * `'borders'` (with {@link Options#customBorders} turned on) + * * `'commentsAddEdit'` (with {@link Options#comments} turned on) + * * `'commentsRemove'` (with {@link Options#comments} turned on). + * + * See [the context menu demo](https://handsontable.com/docs/demo-context-menu.html) for examples. + * + * @example + * ```js + * // as a boolean + * contextMenu: true + * // as a array + * contextMenu: ['row_above', 'row_below', '---------', 'undo', 'redo'] + * ``` + * + * @plugin ContextMenu + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var ContextMenu = /*#__PURE__*/function (_BasePlugin) { + _inherits$F(ContextMenu, _BasePlugin); + + var _super = _createSuper$F(ContextMenu); + + function ContextMenu(hotInstance) { + var _this; + + _classCallCheck$1x(this, ContextMenu); + + _this = _super.call(this, hotInstance); + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + _this.eventManager = new EventManager(_assertThisInitialized$F(_this)); + /** + * Instance of {@link CommandExecutor}. + * + * @private + * @type {CommandExecutor} + */ + + _this.commandExecutor = new CommandExecutor(_this.hot); + /** + * Instance of {@link ItemsFactory}. + * + * @private + * @type {ItemsFactory} + */ + + _this.itemsFactory = null; + /** + * Instance of {@link Menu}. + * + * @private + * @type {Menu} + */ + + _this.menu = null; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ContextMenu#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1s(ContextMenu, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$8]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var settings = this.hot.getSettings()[PLUGIN_KEY$8]; + + if (typeof settings.callback === 'function') { + this.commandExecutor.setCommonCallback(settings.callback); + } + + this.menu = new Menu(this.hot, { + className: 'htContextMenu', + keepInViewport: true, + container: settings.uiContainer || this.hot.rootDocument.body + }); + this.menu.addLocalHook('beforeOpen', function () { + return _this2.onMenuBeforeOpen(); + }); + this.menu.addLocalHook('afterOpen', function () { + return _this2.onMenuAfterOpen(); + }); + this.menu.addLocalHook('afterClose', function () { + return _this2.onMenuAfterClose(); + }); + this.menu.addLocalHook('executeCommand', function () { + var _this2$executeCommand; + + for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) { + params[_key] = arguments[_key]; + } + + return (_this2$executeCommand = _this2.executeCommand).call.apply(_this2$executeCommand, [_this2].concat(params)); + }); + this.addHook('afterOnCellContextMenu', function (event) { + return _this2.onAfterOnCellContextMenu(event); + }); + + _get$i(_getPrototypeOf$F(ContextMenu.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$i(_getPrototypeOf$F(ContextMenu.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.close(); + + if (this.menu) { + this.menu.destroy(); + this.menu = null; + } + + _get$i(_getPrototypeOf$F(ContextMenu.prototype), "disablePlugin", this).call(this); + } + /** + * Opens menu and re-position it based on the passed coordinates. + * + * @param {Event} event The mouse event object. + */ + + }, { + key: "open", + value: function open(event) { + if (!this.menu) { + return; + } + + this.prepareMenuItems(); + this.menu.open(); + + if (!this.menu.isOpened()) { + return; + } + + var offsetTop = 0; + var offsetLeft = 0; + + if (this.hot.rootDocument !== this.menu.container.ownerDocument) { + var frameElement = this.hot.rootWindow.frameElement; + + var _frameElement$getBoun = frameElement.getBoundingClientRect(), + top = _frameElement$getBoun.top, + left = _frameElement$getBoun.left; + + offsetTop = top - getWindowScrollTop(event.view); + offsetLeft = left - getWindowScrollLeft(event.view); + } else { + offsetTop = -1 * getWindowScrollTop(this.menu.hotMenu.rootWindow); + offsetLeft = -1 * getWindowScrollLeft(this.menu.hotMenu.rootWindow); + } + + this.menu.setPosition({ + top: parseInt(event.pageY, 10) + offsetTop, + left: parseInt(event.pageX, 10) + offsetLeft + }); + } + /** + * Closes the menu. + */ + + }, { + key: "close", + value: function close() { + if (!this.menu) { + return; + } + + this.menu.close(); + this.itemsFactory = null; + } + /** + * Execute context menu command. + * + * You can execute all predefined commands: + * * `'row_above'` - Insert row above + * * `'row_below'` - Insert row below + * * `'col_left'` - Insert column left + * * `'col_right'` - Insert column right + * * `'clear_column'` - Clear selected column + * * `'remove_row'` - Remove row + * * `'remove_col'` - Remove column + * * `'undo'` - Undo last action + * * `'redo'` - Redo last action + * * `'make_read_only'` - Make cell read only + * * `'alignment:left'` - Alignment to the left + * * `'alignment:top'` - Alignment to the top + * * `'alignment:right'` - Alignment to the right + * * `'alignment:bottom'` - Alignment to the bottom + * * `'alignment:middle'` - Alignment to the middle + * * `'alignment:center'` - Alignment to the center (justify). + * + * Or you can execute command registered in settings where `key` is your command name. + * + * @param {string} commandName The command name to be executed. + * @param {*} params Additional paramteres passed to command executor module. + */ + + }, { + key: "executeCommand", + value: function executeCommand(commandName) { + var _this$commandExecutor; + + if (this.itemsFactory === null) { + this.prepareMenuItems(); + } + + for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + params[_key2 - 1] = arguments[_key2]; + } + + (_this$commandExecutor = this.commandExecutor).execute.apply(_this$commandExecutor, [commandName].concat(params)); + } + /** + * Prepares available contextMenu's items list and registers them in commandExecutor. + * + * @private + * @fires Hooks#afterContextMenuDefaultOptions + * @fires Hooks#beforeContextMenuSetItems + */ + + }, { + key: "prepareMenuItems", + value: function prepareMenuItems() { + var _this3 = this; + + this.itemsFactory = new ItemsFactory(this.hot, ContextMenu.DEFAULT_ITEMS); + var settings = this.hot.getSettings()[PLUGIN_KEY$8]; + var predefinedItems = { + items: this.itemsFactory.getItems(settings) + }; + this.hot.runHooks('afterContextMenuDefaultOptions', predefinedItems); + this.itemsFactory.setPredefinedItems(predefinedItems.items); + var menuItems = this.itemsFactory.getItems(settings); + this.hot.runHooks('beforeContextMenuSetItems', menuItems); + this.menu.setMenuItems(menuItems); // Register all commands. Predefined and added by user or by plugins + + arrayEach(menuItems, function (command) { + return _this3.commandExecutor.registerCommand(command.key, command); + }); + } + /** + * On contextmenu listener. + * + * @private + * @param {Event} event The mouse event object. + */ + + }, { + key: "onAfterOnCellContextMenu", + value: function onAfterOnCellContextMenu(event) { + var settings = this.hot.getSettings(); + var showRowHeaders = settings.rowHeaders; + var showColHeaders = settings.colHeaders; + /** + * @param {HTMLElement} element The element to validate. + * @returns {boolean} + */ + + function isValidElement(element) { + return element.nodeName === 'TD' || element.parentNode.nodeName === 'TD'; + } + + var element = event.target; + this.close(); + + if (hasClass(element, 'handsontableInput')) { + return; + } + + event.preventDefault(); + event.stopPropagation(); + + if (!(showRowHeaders || showColHeaders)) { + if (!isValidElement(element) && !(hasClass(element, 'current') && hasClass(element, 'wtBorder'))) { + return; + } + } + + this.open(event); + } + /** + * On menu before open listener. + * + * @private + */ + + }, { + key: "onMenuBeforeOpen", + value: function onMenuBeforeOpen() { + this.hot.runHooks('beforeContextMenuShow', this); + } + /** + * On menu after open listener. + * + * @private + */ + + }, { + key: "onMenuAfterOpen", + value: function onMenuAfterOpen() { + this.hot.runHooks('afterContextMenuShow', this); + } + /** + * On menu after close listener. + * + * @private + */ + + }, { + key: "onMenuAfterClose", + value: function onMenuAfterClose() { + this.hot.listen(); + this.hot.runHooks('afterContextMenuHide', this); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.close(); + + if (this.menu) { + this.menu.destroy(); + } + + _get$i(_getPrototypeOf$F(ContextMenu.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$8; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$7; + } + }, { + key: "PLUGIN_DEPS", + get: function get() { + return ['plugin:AutoColumnSize']; + } + /** + * Context menu default items order when `contextMenu` options is set as `true`. + * + * @returns {string[]} + */ + + }, { + key: "DEFAULT_ITEMS", + get: function get() { + return [KEY$9, KEY$a, KEY, KEY$3, KEY$4, KEY, KEY$8, KEY$7, KEY, KEY$c, KEY$6, KEY, KEY$5, KEY, KEY$1]; + } + }]); + + return ContextMenu; +}(BasePlugin); +ContextMenu.SEPARATOR = { + name: KEY +}; + +/** + * @param {CopyPaste} copyPastePlugin The plugin instance. + * @returns {object} + */ + +function copyItem(copyPastePlugin) { + return { + key: 'copy', + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_COPY); + }, + callback: function callback() { + copyPastePlugin.copy(); + }, + disabled: function disabled() { + if (this.countRows() === 0 || this.countCols() === 0) { + return true; + } + + var selected = this.getSelected(); // Disable for no selection or for non-contiquous selection. + + if (!selected || selected.length > 1) { + return true; + } + + return false; + }, + hidden: false + }; +} + +/** + * @param {CopyPaste} copyPastePlugin The plugin instance. + * @returns {object} + */ + +function cutItem(copyPastePlugin) { + return { + key: 'cut', + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_CUT); + }, + callback: function callback() { + copyPastePlugin.cut(); + }, + disabled: function disabled() { + if (this.countRows() === 0 || this.countCols() === 0) { + return true; + } + + var selected = this.getSelected(); // Disable for no selection or for non-contiquous selection. + + if (!selected || selected.length > 1) { + return true; + } + + return false; + }, + hidden: false + }; +} + +function _classCallCheck$1y(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1t(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); } } + +function _createClass$1t(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1t(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1t(Constructor, staticProps); return Constructor; } + +var ClipboardData = /*#__PURE__*/function () { + function ClipboardData() { + _classCallCheck$1y(this, ClipboardData); + + this.data = {}; + } + + _createClass$1t(ClipboardData, [{ + key: "setData", + value: function setData(type, value) { + this.data[type] = value; + } + }, { + key: "getData", + value: function getData(type) { + return this.data[type] || void 0; + } + }]); + + return ClipboardData; +}(); + +function _classCallCheck$1z(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var PasteEvent = function PasteEvent() { + _classCallCheck$1z(this, PasteEvent); + + this.clipboardData = new ClipboardData(); +}; + +// `WeakSet` constructor +// https://tc39.es/ecma262/#sec-weakset-constructor +collection('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionWeak); + +function _classCallCheck$1A(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1u(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); } } + +function _createClass$1u(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1u(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1u(Constructor, staticProps); return Constructor; } +/** + * @class FocusableWrapper + * + * @plugin CopyPaste + */ + +var FocusableWrapper = /*#__PURE__*/function () { + function FocusableWrapper(container) { + _classCallCheck$1A(this, FocusableWrapper); + + this.rootDocument = container.defaultView ? container : container.ownerDocument; + /** + * The main/operational focusable element. + * + * @type {HTMLElement} + */ + + this.mainElement = null; + /** + * Instance of EventManager. + * + * @type {EventManager} + */ + + this.eventManager = new EventManager(this); + /** + * An object for tracking information about event listeners attached to the focusable element. + * + * @type {WeakSet} + */ + + this.listenersCount = new WeakSet(); + /** + * Parent for an focusable element. + * + * @type {HTMLElement} + */ + + this.container = container; + } + /** + * Switch to the secondary focusable element. Used when no any main focusable element is provided. + */ + + + _createClass$1u(FocusableWrapper, [{ + key: "useSecondaryElement", + value: function useSecondaryElement() { + var el = createOrGetSecondaryElement(this.container); + + if (!this.listenersCount.has(el)) { + this.listenersCount.add(el); + forwardEventsToLocalHooks(this.eventManager, el, this); + } + + this.mainElement = el; + } + /** + * Switch to the main focusable element. + * + * @param {HTMLElement} element The DOM element. + */ + + }, { + key: "setFocusableElement", + value: function setFocusableElement(element) { + if (!this.listenersCount.has(element)) { + this.listenersCount.add(element); + forwardEventsToLocalHooks(this.eventManager, element, this); + } + + this.mainElement = element; + } + /** + * Get currently set focusable element. + * + * @returns {HTMLElement} + */ + + }, { + key: "getFocusableElement", + value: function getFocusableElement() { + return this.mainElement; + } + /** + * Set focus to the focusable element. + */ + + }, { + key: "focus", + value: function focus() { + // Add an empty space to texarea. It is necessary for safari to enable "copy" command from menu bar. + this.mainElement.value = ' '; + + if (!isMobileBrowser()) { + selectElementIfAllowed(this.mainElement); + } + } + }]); + + return FocusableWrapper; +}(); + +mixin(FocusableWrapper, localHooks); +var refCounter = new WeakMap(); +/** + * Create and return the FocusableWrapper instance. + * + * @param {HTMLElement} container The container element, holder for focusable elements. + * @returns {FocusableWrapper} + */ + +function createElement(container) { + var focusableWrapper = new FocusableWrapper(container); + var counter = refCounter.get(container); + counter = isNaN(counter) ? 0 : counter; + refCounter.set(container, counter + 1); + return focusableWrapper; +} +/** + * Deactivate the FocusableWrapper instance. + * + * @param {FocusableWrapper} wrapper The instance of the FocusableWrapper class. + */ + + +function deactivateElement(wrapper) { + wrapper.eventManager.clear(); +} + +var runLocalHooks = function runLocalHooks(eventName, subject) { + return function (event) { + return subject.runLocalHooks(eventName, event); + }; +}; +/** + * Register copy/cut/paste events and forward their actions to the subject local hooks system. + * + * @param {EventManager} eventManager The instance of the EventManager class. + * @param {HTMLElement} element The element on which the listeners are mounted. + * @param {FocusableWrapper} subject The subject object for local hooks. + */ + + +function forwardEventsToLocalHooks(eventManager, element, subject) { + eventManager.addEventListener(element, 'copy', runLocalHooks('copy', subject)); + eventManager.addEventListener(element, 'cut', runLocalHooks('cut', subject)); + eventManager.addEventListener(element, 'paste', runLocalHooks('paste', subject)); +} + +var secondaryElements = new WeakMap(); +/** + * Create and attach newly created focusable element to the DOM. + * + * @param {HTMLElement} container The container element, holder for focusable elements. + * @returns {HTMLElement} + */ + +function createOrGetSecondaryElement(container) { + var secondaryElement = secondaryElements.get(container); + + if (secondaryElement) { + if (!secondaryElement.parentElement) { + container.appendChild(secondaryElement); + } + + return secondaryElement; + } + + var doc = container.defaultView ? container : container.ownerDocument; + var element = doc.createElement('textarea'); + secondaryElements.set(container, element); + element.setAttribute('data-hot-input', ''); // Makes the element recognizable by Hot as its own component's element. + + element.className = 'HandsontableCopyPaste'; + element.tabIndex = -1; + element.autocomplete = 'off'; + element.wrap = 'hard'; + element.value = ' '; + container.appendChild(element); + return element; +} +/** + * Destroy the FocusableWrapper instance. + * + * @param {FocusableWrapper} wrapper The instance of the FocusableWrapper class. + */ + + +function destroyElement(wrapper) { + if (!(wrapper instanceof FocusableWrapper)) { + return; + } + + var counter = refCounter.get(wrapper.container); + counter = isNaN(counter) ? 0 : counter; + + if (counter > 0) { + counter -= 1; + } + + deactivateElement(wrapper); + + if (counter <= 0) { + counter = 0; // Detach secondary element from the DOM. + + var secondaryElement = secondaryElements.get(wrapper.container); + + if (secondaryElement && secondaryElement.parentNode) { + secondaryElement.parentNode.removeChild(secondaryElement); + secondaryElements.delete(wrapper.container); + } + + wrapper.mainElement = null; + } + + refCounter.set(wrapper.container, counter); +} + +function _slicedToArray$k(arr, i) { return _arrayWithHoles$l(arr) || _iterableToArrayLimit$k(arr, i) || _unsupportedIterableToArray$w(arr, i) || _nonIterableRest$l(); } + +function _nonIterableRest$l() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$w(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$w(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$w(o, minLen); } + +function _arrayLikeToArray$w(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$k(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$l(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof$R(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$R = function _typeof(obj) { return typeof obj; }; } else { _typeof$R = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$R(obj); } + +function _classCallCheck$1B(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1v(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); } } + +function _createClass$1v(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1v(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1v(Constructor, staticProps); return Constructor; } + +function _get$j(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$j = Reflect.get; } else { _get$j = function _get(target, property, receiver) { var base = _superPropBase$j(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$j(target, property, receiver || target); } + +function _superPropBase$j(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$G(object); if (object === null) break; } return object; } + +function _inherits$G(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$H(subClass, superClass); } + +function _setPrototypeOf$H(o, p) { _setPrototypeOf$H = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$H(o, p); } + +function _createSuper$G(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$H(); return function _createSuperInternal() { var Super = _getPrototypeOf$G(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$G(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$G(this, result); }; } + +function _possibleConstructorReturn$G(self, call) { if (call && (_typeof$R(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$G(self); } + +function _assertThisInitialized$G(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$H() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$G(o) { _getPrototypeOf$G = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$G(o); } +Hooks.getSingleton().register('afterCopyLimit'); +Hooks.getSingleton().register('modifyCopyableRange'); +Hooks.getSingleton().register('beforeCut'); +Hooks.getSingleton().register('afterCut'); +Hooks.getSingleton().register('beforePaste'); +Hooks.getSingleton().register('afterPaste'); +Hooks.getSingleton().register('beforeCopy'); +Hooks.getSingleton().register('afterCopy'); +var PLUGIN_KEY$9 = 'copyPaste'; +var PLUGIN_PRIORITY$8 = 80; +var ROWS_LIMIT = 1000; +var COLUMNS_LIMIT = 1000; +var privatePool$9 = new WeakMap(); +var META_HEAD = ['', ''].join(''); +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @description + * This plugin enables the copy/paste functionality in the Handsontable. The functionality works for API, Context Menu, + * using keyboard shortcuts and menu bar from the browser. + * Possible values: + * * `true` (to enable default options), + * * `false` (to disable completely). + * + * or an object with values: + * * `'columnsLimit'` (see {@link CopyPaste#columnsLimit}) + * * `'rowsLimit'` (see {@link CopyPaste#rowsLimit}) + * * `'pasteMode'` (see {@link CopyPaste#pasteMode}) + * * `'uiContainer'` (see {@link CopyPaste#uiContainer}). + * + * See [the copy/paste demo](https://handsontable.com/docs/demo-copy-paste.html) for examples. + * + * @example + * ```js + * // Enables the plugin with default values + * copyPaste: true, + * // Enables the plugin with custom values + * copyPaste: { + * columnsLimit: 25, + * rowsLimit: 50, + * pasteMode: 'shift_down', + * uiContainer: document.body, + * }, + * ``` + * @class CopyPaste + * @plugin CopyPaste + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var CopyPaste = /*#__PURE__*/function (_BasePlugin) { + _inherits$G(CopyPaste, _BasePlugin); + + var _super = _createSuper$G(CopyPaste); + + function CopyPaste(hotInstance) { + var _this; + + _classCallCheck$1B(this, CopyPaste); + + _this = _super.call(this, hotInstance); + /** + * Maximum number of columns than can be copied to clipboard using CTRL + C. + * + * @type {number} + * @default 1000 + */ + + _this.columnsLimit = COLUMNS_LIMIT; + /** + * Ranges of the cells coordinates, which should be used to copy/cut/paste actions. + * + * @private + * @type {Array} + */ + + _this.copyableRanges = []; + /** + * Provides focusable element to support IME and copy/paste/cut actions. + * + * @type {FocusableWrapper} + */ + + _this.focusableElement = void 0; + /** + * Defines paste (CTRL + V) behavior. + * * Default value `"overwrite"` will paste clipboard value over current selection. + * * When set to `"shift_down"`, clipboard data will be pasted in place of current selection, while all selected cells are moved down. + * * When set to `"shift_right"`, clipboard data will be pasted in place of current selection, while all selected cells are moved right. + * + * @type {string} + * @default 'overwrite' + */ + + _this.pasteMode = 'overwrite'; + /** + * Maximum number of rows than can be copied to clipboard using CTRL + C. + * + * @type {number} + * @default 1000 + */ + + _this.rowsLimit = ROWS_LIMIT; + /** + * UI container for the secondary focusable element. + * + * @type {HTMLElement} + */ + + _this.uiContainer = _this.hot.rootDocument.body; + privatePool$9.set(_assertThisInitialized$G(_this), { + isTriggeredByCopy: false, + isTriggeredByCut: false, + isBeginEditing: false, + isFragmentSelectionEnabled: false + }); + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link CopyPaste#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1v(CopyPaste, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$9]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var _this$hot$getSettings = this.hot.getSettings(), + settings = _this$hot$getSettings[PLUGIN_KEY$9], + fragmentSelection = _this$hot$getSettings.fragmentSelection; + + var priv = privatePool$9.get(this); + priv.isFragmentSelectionEnabled = !!fragmentSelection; + + if (_typeof$R(settings) === 'object') { + this.pasteMode = settings.pasteMode || this.pasteMode; + this.rowsLimit = isNaN(settings.rowsLimit) ? this.rowsLimit : settings.rowsLimit; + this.columnsLimit = isNaN(settings.columnsLimit) ? this.columnsLimit : settings.columnsLimit; + this.uiContainer = settings.uiContainer || this.uiContainer; + } + + this.addHook('afterContextMenuDefaultOptions', function (options) { + return _this2.onAfterContextMenuDefaultOptions(options); + }); + this.addHook('afterOnCellMouseUp', function () { + return _this2.onAfterOnCellMouseUp(); + }); + this.addHook('afterSelectionEnd', function () { + return _this2.onAfterSelectionEnd(); + }); + this.addHook('beforeKeyDown', function () { + return _this2.onBeforeKeyDown(); + }); + this.focusableElement = createElement(this.uiContainer); + this.focusableElement.addLocalHook('copy', function (event) { + return _this2.onCopy(event); + }).addLocalHook('cut', function (event) { + return _this2.onCut(event); + }).addLocalHook('paste', function (event) { + return _this2.onPaste(event); + }); + + _get$j(_getPrototypeOf$G(CopyPaste.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + this.getOrCreateFocusableElement(); + + _get$j(_getPrototypeOf$G(CopyPaste.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + if (this.focusableElement) { + destroyElement(this.focusableElement); + } + + _get$j(_getPrototypeOf$G(CopyPaste.prototype), "disablePlugin", this).call(this); + } + /** + * Copies the selected cell into the clipboard. + */ + + }, { + key: "copy", + value: function copy() { + var priv = privatePool$9.get(this); + priv.isTriggeredByCopy = true; + this.getOrCreateFocusableElement(); + this.focusableElement.focus(); + this.hot.rootDocument.execCommand('copy'); + } + /** + * Cuts the selected cell into the clipboard. + */ + + }, { + key: "cut", + value: function cut() { + var priv = privatePool$9.get(this); + priv.isTriggeredByCut = true; + this.getOrCreateFocusableElement(); + this.focusableElement.focus(); + this.hot.rootDocument.execCommand('cut'); + } + /** + * Creates copyable text releated to range objects. + * + * @param {object[]} ranges Array of objects with properties `startRow`, `endRow`, `startCol` and `endCol`. + * @returns {string} Returns string which will be copied into clipboard. + */ + + }, { + key: "getRangedCopyableData", + value: function getRangedCopyableData(ranges) { + var _this3 = this; + + var dataSet = []; + var copyableRows = []; + var copyableColumns = []; // Count all copyable rows and columns + + arrayEach(ranges, function (range) { + rangeEach(range.startRow, range.endRow, function (row) { + if (copyableRows.indexOf(row) === -1) { + copyableRows.push(row); + } + }); + rangeEach(range.startCol, range.endCol, function (column) { + if (copyableColumns.indexOf(column) === -1) { + copyableColumns.push(column); + } + }); + }); // Concat all rows and columns data defined in ranges into one copyable string + + arrayEach(copyableRows, function (row) { + var rowSet = []; + arrayEach(copyableColumns, function (column) { + rowSet.push(_this3.hot.getCopyableData(row, column)); + }); + dataSet.push(rowSet); + }); + return stringify$1(dataSet); + } + /** + * Creates copyable text releated to range objects. + * + * @param {object[]} ranges Array of objects with properties `startRow`, `startCol`, `endRow` and `endCol`. + * @returns {Array[]} Returns array of arrays which will be copied into clipboard. + */ + + }, { + key: "getRangedData", + value: function getRangedData(ranges) { + var _this4 = this; + + var dataSet = []; + var copyableRows = []; + var copyableColumns = []; // Count all copyable rows and columns + + arrayEach(ranges, function (range) { + rangeEach(range.startRow, range.endRow, function (row) { + if (copyableRows.indexOf(row) === -1) { + copyableRows.push(row); + } + }); + rangeEach(range.startCol, range.endCol, function (column) { + if (copyableColumns.indexOf(column) === -1) { + copyableColumns.push(column); + } + }); + }); // Concat all rows and columns data defined in ranges into one copyable string + + arrayEach(copyableRows, function (row) { + var rowSet = []; + arrayEach(copyableColumns, function (column) { + rowSet.push(_this4.hot.getCopyableData(row, column)); + }); + dataSet.push(rowSet); + }); + return dataSet; + } + /** + * Simulates the paste action. + * + * @param {string} pastableText Value as raw string to paste. + * @param {string} [pastableHtml=''] Value as HTML to paste. + */ + + }, { + key: "paste", + value: function paste() { + var pastableText = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + var pastableHtml = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : pastableText; + + if (!pastableText && !pastableHtml) { + return; + } + + var pasteData = new PasteEvent(); + + if (pastableText) { + pasteData.clipboardData.setData('text/plain', pastableText); + } + + if (pastableHtml) { + pasteData.clipboardData.setData('text/html', pastableHtml); + } + + this.getOrCreateFocusableElement(); + this.onPaste(pasteData); + } + /** + * Prepares copyable text from the cells selection in the invisible textarea. + */ + + }, { + key: "setCopyableText", + value: function setCopyableText() { + var selRange = this.hot.getSelectedRangeLast(); + + if (!selRange) { + return; + } + + var topLeft = selRange.getTopLeftCorner(); + var bottomRight = selRange.getBottomRightCorner(); + var startRow = topLeft.row; + var startCol = topLeft.col; + var endRow = bottomRight.row; + var endCol = bottomRight.col; + var finalEndRow = Math.min(endRow, startRow + this.rowsLimit - 1); + var finalEndCol = Math.min(endCol, startCol + this.columnsLimit - 1); + this.copyableRanges.length = 0; + this.copyableRanges.push({ + startRow: startRow, + startCol: startCol, + endRow: finalEndRow, + endCol: finalEndCol + }); + this.copyableRanges = this.hot.runHooks('modifyCopyableRange', this.copyableRanges); + + if (endRow !== finalEndRow || endCol !== finalEndCol) { + this.hot.runHooks('afterCopyLimit', endRow - startRow + 1, endCol - startCol + 1, this.rowsLimit, this.columnsLimit); + } + } + /** + * Force focus on editable element. + * + * @private + */ + + }, { + key: "getOrCreateFocusableElement", + value: function getOrCreateFocusableElement() { + var editor = this.hot.getActiveEditor(); + var editableElement = editor ? editor.TEXTAREA : void 0; + + if (editableElement) { + this.focusableElement.setFocusableElement(editableElement); + } else { + this.focusableElement.useSecondaryElement(); + } + } + /** + * Verifies if editor exists and is open. + * + * @private + * @returns {boolean} + */ + + }, { + key: "isEditorOpened", + value: function isEditorOpened() { + var editor = this.hot.getActiveEditor(); + return editor && editor.isOpened(); + } + /** + * Prepares new values to populate them into datasource. + * + * @private + * @param {Array} inputArray An array of the data to populate. + * @param {Array} [selection] The selection which indicates from what position the data will be populated. + * @returns {Array} Range coordinates after populate data. + */ + + }, { + key: "populateValues", + value: function populateValues(inputArray) { + var selection = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.hot.getSelectedRangeLast(); + + if (!inputArray.length) { + return; + } + + var populatedRowsLength = inputArray.length; + var populatedColumnsLength = inputArray[0].length; + var newRows = []; + + var _selection$getTopLeft = selection.getTopLeftCorner(), + startRow = _selection$getTopLeft.row, + startColumn = _selection$getTopLeft.col; + + var _selection$getBottomR = selection.getBottomRightCorner(), + endRowFromSelection = _selection$getBottomR.row, + endColumnFromSelection = _selection$getBottomR.col; + + var visualRowForPopulatedData = startRow; + var visualColumnForPopulatedData = startColumn; + var lastVisualRow = startRow; + var lastVisualColumn = startColumn; // We try to populate just all copied data or repeat copied data within a selection. Please keep in mind that we + // don't know whether populated data is bigger than selection on start as there are some cells for which values + // should be not inserted (it's known right after getting cell meta). + + while (newRows.length < populatedRowsLength || visualRowForPopulatedData <= endRowFromSelection) { + var _this$hot$getCellMeta = this.hot.getCellMeta(visualRowForPopulatedData, startColumn), + skipRowOnPaste = _this$hot$getCellMeta.skipRowOnPaste, + visualRow = _this$hot$getCellMeta.visualRow; + + visualRowForPopulatedData = visualRow + 1; + + if (skipRowOnPaste === true) { + /* eslint-disable no-continue */ + continue; + } + + lastVisualRow = visualRow; + visualColumnForPopulatedData = startColumn; + var newRow = []; + var insertedRow = newRows.length % populatedRowsLength; + + while (newRow.length < populatedColumnsLength || visualColumnForPopulatedData <= endColumnFromSelection) { + var _this$hot$getCellMeta2 = this.hot.getCellMeta(startRow, visualColumnForPopulatedData), + skipColumnOnPaste = _this$hot$getCellMeta2.skipColumnOnPaste, + visualCol = _this$hot$getCellMeta2.visualCol; + + visualColumnForPopulatedData = visualCol + 1; + + if (skipColumnOnPaste === true) { + /* eslint-disable no-continue */ + continue; + } + + lastVisualColumn = visualCol; + var insertedColumn = newRow.length % populatedColumnsLength; + newRow.push(inputArray[insertedRow][insertedColumn]); + } + + newRows.push(newRow); + } + + this.hot.populateFromArray(startRow, startColumn, newRows, void 0, void 0, 'CopyPaste.paste', this.pasteMode); + return [startRow, startColumn, lastVisualRow, lastVisualColumn]; + } + /** + * `copy` event callback on textarea element. + * + * @param {Event} event ClipboardEvent. + * @private + */ + + }, { + key: "onCopy", + value: function onCopy(event) { + var priv = privatePool$9.get(this); + + if (!this.hot.isListening() && !priv.isTriggeredByCopy || this.isEditorOpened()) { + return; + } + + this.setCopyableText(); + priv.isTriggeredByCopy = false; + var rangedData = this.getRangedData(this.copyableRanges); + var allowCopying = !!this.hot.runHooks('beforeCopy', rangedData, this.copyableRanges); + + if (allowCopying) { + var textPlain = stringify$1(rangedData); + + if (event && event.clipboardData) { + var textHTML = _dataToHTML(rangedData, this.hot.rootDocument); + + event.clipboardData.setData('text/plain', textPlain); + event.clipboardData.setData('text/html', [META_HEAD, textHTML].join('')); + } else if (typeof ClipboardEvent === 'undefined') { + this.hot.rootWindow.clipboardData.setData('Text', textPlain); + } + + this.hot.runHooks('afterCopy', rangedData, this.copyableRanges); + } + + event.preventDefault(); + } + /** + * `cut` event callback on textarea element. + * + * @param {Event} event ClipboardEvent. + * @private + */ + + }, { + key: "onCut", + value: function onCut(event) { + var priv = privatePool$9.get(this); + + if (!this.hot.isListening() && !priv.isTriggeredByCut || this.isEditorOpened()) { + return; + } + + this.setCopyableText(); + priv.isTriggeredByCut = false; + var rangedData = this.getRangedData(this.copyableRanges); + var allowCuttingOut = !!this.hot.runHooks('beforeCut', rangedData, this.copyableRanges); + + if (allowCuttingOut) { + var textPlain = stringify$1(rangedData); + + if (event && event.clipboardData) { + var textHTML = _dataToHTML(rangedData, this.hot.rootDocument); + + event.clipboardData.setData('text/plain', textPlain); + event.clipboardData.setData('text/html', [META_HEAD, textHTML].join('')); + } else if (typeof ClipboardEvent === 'undefined') { + this.hot.rootWindow.clipboardData.setData('Text', textPlain); + } + + this.hot.emptySelectedCells('CopyPaste.cut'); + this.hot.runHooks('afterCut', rangedData, this.copyableRanges); + } + + event.preventDefault(); + } + /** + * `paste` event callback on textarea element. + * + * @param {Event} event ClipboardEvent or pseudo ClipboardEvent, if paste was called manually. + * @private + */ + + }, { + key: "onPaste", + value: function onPaste(event) { + if (!this.hot.isListening() || this.isEditorOpened()) { + return; + } + + if (event && event.preventDefault) { + event.preventDefault(); + } + + var pastedData; + + if (event && typeof event.clipboardData !== 'undefined') { + var textHTML = sanitize(event.clipboardData.getData('text/html'), { + ADD_TAGS: ['meta'], + ADD_ATTR: ['content'], + FORCE_BODY: true + }); + + if (textHTML && /(".concat(String.fromCharCode(10003), "").concat(label); // workaround for https://github.com/handsontable/handsontable/issues/1946 +} + +/** + * @param {CustomBorders} customBordersPlugin The plugin instance. + * @returns {object} + */ + +function bottom(customBordersPlugin) { + return { + key: 'borders:bottom', + name: function name() { + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_BORDERS_BOTTOM); + var hasBorder = checkSelectionBorders(this, 'bottom'); + + if (hasBorder) { + label = markSelected(label); + } + + return label; + }, + callback: function callback(key, selected) { + var hasBorder = checkSelectionBorders(this, 'bottom'); + customBordersPlugin.prepareBorder(selected, 'bottom', hasBorder); + } + }; +} + +/** + * @param {CustomBorders} customBordersPlugin The plugin instance. + * @returns {object} + */ + +function left(customBordersPlugin) { + return { + key: 'borders:left', + name: function name() { + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_BORDERS_LEFT); + var hasBorder = checkSelectionBorders(this, 'left'); + + if (hasBorder) { + label = markSelected(label); + } + + return label; + }, + callback: function callback(key, selected) { + var hasBorder = checkSelectionBorders(this, 'left'); + customBordersPlugin.prepareBorder(selected, 'left', hasBorder); + } + }; +} + +/** + * @param {CustomBorders} customBordersPlugin The plugin instance. + * @returns {object} + */ + +function noBorders(customBordersPlugin) { + return { + key: 'borders:no_borders', + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_REMOVE_BORDERS); + }, + callback: function callback(key, selected) { + customBordersPlugin.prepareBorder(selected, 'noBorders'); + }, + disabled: function disabled() { + return !checkSelectionBorders(this); + } + }; +} + +/** + * @param {CustomBorders} customBordersPlugin The plugin instance. + * @returns {object} + */ + +function right(customBordersPlugin) { + return { + key: 'borders:right', + name: function name() { + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_BORDERS_RIGHT); + var hasBorder = checkSelectionBorders(this, 'right'); + + if (hasBorder) { + label = markSelected(label); + } + + return label; + }, + callback: function callback(key, selected) { + var hasBorder = checkSelectionBorders(this, 'right'); + customBordersPlugin.prepareBorder(selected, 'right', hasBorder); + } + }; +} + +/** + * @param {CustomBorders} customBordersPlugin The plugin instance. + * @returns {object} + */ + +function top(customBordersPlugin) { + return { + key: 'borders:top', + name: function name() { + var label = this.getTranslatedPhrase(CONTEXTMENU_ITEMS_BORDERS_TOP); + var hasBorder = checkSelectionBorders(this, 'top'); + + if (hasBorder) { + label = markSelected(label); + } + + return label; + }, + callback: function callback(key, selected) { + var hasBorder = checkSelectionBorders(this, 'top'); + customBordersPlugin.prepareBorder(selected, 'top', hasBorder); + } + }; +} + +function _typeof$S(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$S = function _typeof(obj) { return typeof obj; }; } else { _typeof$S = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$S(obj); } + +function _slicedToArray$l(arr, i) { return _arrayWithHoles$m(arr) || _iterableToArrayLimit$l(arr, i) || _unsupportedIterableToArray$x(arr, i) || _nonIterableRest$m(); } + +function _nonIterableRest$m() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$x(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$x(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$x(o, minLen); } + +function _arrayLikeToArray$x(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$l(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$m(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$1C(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1w(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); } } + +function _createClass$1w(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1w(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1w(Constructor, staticProps); return Constructor; } + +function _get$k(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$k = Reflect.get; } else { _get$k = function _get(target, property, receiver) { var base = _superPropBase$k(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$k(target, property, receiver || target); } + +function _superPropBase$k(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$H(object); if (object === null) break; } return object; } + +function _inherits$H(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$I(subClass, superClass); } + +function _setPrototypeOf$I(o, p) { _setPrototypeOf$I = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$I(o, p); } + +function _createSuper$H(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$I(); return function _createSuperInternal() { var Super = _getPrototypeOf$H(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$H(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$H(this, result); }; } + +function _possibleConstructorReturn$H(self, call) { if (call && (_typeof$S(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$H(self); } + +function _assertThisInitialized$H(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$I() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$H(o) { _getPrototypeOf$H = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$H(o); } +var PLUGIN_KEY$a = 'customBorders'; +var PLUGIN_PRIORITY$9 = 90; +/** + * @class CustomBorders + * @plugin CustomBorders + * + * @description + * This plugin enables an option to apply custom borders through the context menu (configurable with context menu key + * `borders`). + * + * To initialize Handsontable with predefined custom borders, provide cell coordinates and border styles in a form + * of an array. + * + * See [Custom Borders](https://handsontable.com/docs/demo-customizing-borders.html) demo for more examples. + * + * @example + * ```js + * customBorders: [ + * { + * range: { + * from: { + * row: 1, + * col: 1 + * }, + * to: { + * row: 3, + * col: 4 + * }, + * }, + * left: {}, + * right: {}, + * top: {}, + * bottom: {}, + * }, + * ], + * + * // or + * customBorders: [ + * { row: 2, + * col: 2, + * left: { + * width: 2, + * color: 'red', + * }, + * right: { + * width: 1, + * color: 'green', + * }, + * top: '', + * bottom: '', + * } + * ], + * ``` + */ + +var CustomBorders = /*#__PURE__*/function (_BasePlugin) { + _inherits$H(CustomBorders, _BasePlugin); + + var _super = _createSuper$H(CustomBorders); + + function CustomBorders(hotInstance) { + var _this; + + _classCallCheck$1C(this, CustomBorders); + + _this = _super.call(this, hotInstance); + /** + * Saved borders. + * + * @private + * @type {Array} + */ + + _this.savedBorders = []; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link CustomBorders#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1w(CustomBorders, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$a]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.addHook('afterContextMenuDefaultOptions', function (options) { + return _this2.onAfterContextMenuDefaultOptions(options); + }); + this.addHook('init', function () { + return _this2.onAfterInit(); + }); + + _get$k(_getPrototypeOf$H(CustomBorders.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.hideBorders(); + + _get$k(_getPrototypeOf$H(CustomBorders.prototype), "disablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + this.changeBorderSettings(); + + _get$k(_getPrototypeOf$H(CustomBorders.prototype), "updatePlugin", this).call(this); + } + /** + * Set custom borders. + * + * @example + * ```js + * const customBordersPlugin = hot.getPlugin('customBorders'); + * + * // Using an array of arrays (produced by `.getSelected()` method). + * customBordersPlugin.setBorders([[1, 1, 2, 2], [6, 2, 0, 2]], {left: {width: 2, color: 'blue'}}); + * + * // Using an array of CellRange objects (produced by `.getSelectedRange()` method). + * // Selecting a cell range. + * hot.selectCell(0, 0, 2, 2); + * // Returning selected cells' range with the getSelectedRange method. + * customBordersPlugin.setBorders(hot.getSelectedRange(), {left: {hide: false, width: 2, color: 'blue'}}); + * ``` + * + * @param {Array[]|CellRange[]} selectionRanges Array of selection ranges. + * @param {object} borderObject Object with `top`, `right`, `bottom` and `left` properties. + */ + + }, { + key: "setBorders", + value: function setBorders(selectionRanges, borderObject) { + var _this3 = this; + + var defaultBorderKeys = ['top', 'right', 'bottom', 'left']; + var borderKeys = borderObject ? Object.keys(borderObject) : defaultBorderKeys; + var selectionType = detectSelectionType(selectionRanges); + var selectionSchemaNormalizer = normalizeSelectionFactory(selectionType); + arrayEach(selectionRanges, function (selection) { + var _selectionSchemaNorma = selectionSchemaNormalizer(selection), + _selectionSchemaNorma2 = _slicedToArray$l(_selectionSchemaNorma, 4), + rowStart = _selectionSchemaNorma2[0], + columnStart = _selectionSchemaNorma2[1], + rowEnd = _selectionSchemaNorma2[2], + columnEnd = _selectionSchemaNorma2[3]; + + var _loop = function _loop(row) { + var _loop2 = function _loop2(col) { + arrayEach(borderKeys, function (borderKey) { + _this3.prepareBorderFromCustomAdded(row, col, borderObject, borderKey); + }); + }; + + for (var col = columnStart; col <= columnEnd; col += 1) { + _loop2(col); + } + }; + + for (var row = rowStart; row <= rowEnd; row += 1) { + _loop(row); + } + }); + /* + The line below triggers a re-render of Handsontable. This will be a "fastDraw" + render, because that is the default for the TableView class. + The re-render is needed for borders on cells that did not have a border before. + The way this call works is that it calls Table.refreshSelections, which calls + Selection.getBorder, which creates a new instance of Border. + Seems wise to keep this single-direction flow of creating new Borders + */ + + this.hot.view.render(); + } + /** + * Get custom borders. + * + * @example + * ```js + * const customBordersPlugin = hot.getPlugin('customBorders'); + * + * // Using an array of arrays (produced by `.getSelected()` method). + * customBordersPlugin.getBorders([[1, 1, 2, 2], [6, 2, 0, 2]]); + * // Using an array of CellRange objects (produced by `.getSelectedRange()` method). + * customBordersPlugin.getBorders(hot.getSelectedRange()); + * // Using without param - return all customBorders. + * customBordersPlugin.getBorders(); + * ``` + * + * @param {Array[]|CellRange[]} selectionRanges Array of selection ranges. + * @returns {object[]} Returns array of border objects. + */ + + }, { + key: "getBorders", + value: function getBorders(selectionRanges) { + var _this4 = this; + + if (!Array.isArray(selectionRanges)) { + return this.savedBorders; + } + + var selectionType = detectSelectionType(selectionRanges); + var selectionSchemaNormalizer = normalizeSelectionFactory(selectionType); + var selectedBorders = []; + arrayEach(selectionRanges, function (selection) { + var _selectionSchemaNorma3 = selectionSchemaNormalizer(selection), + _selectionSchemaNorma4 = _slicedToArray$l(_selectionSchemaNorma3, 4), + rowStart = _selectionSchemaNorma4[0], + columnStart = _selectionSchemaNorma4[1], + rowEnd = _selectionSchemaNorma4[2], + columnEnd = _selectionSchemaNorma4[3]; + + var _loop3 = function _loop3(row) { + var _loop4 = function _loop4(col) { + arrayEach(_this4.savedBorders, function (border) { + if (border.row === row && border.col === col) { + selectedBorders.push(border); + } + }); + }; + + for (var col = columnStart; col <= columnEnd; col += 1) { + _loop4(col); + } + }; + + for (var row = rowStart; row <= rowEnd; row += 1) { + _loop3(row); + } + }); + return selectedBorders; + } + /** + * Clear custom borders. + * + * @example + * ```js + * const customBordersPlugin = hot.getPlugin('customBorders'); + * + * // Using an array of arrays (produced by `.getSelected()` method). + * customBordersPlugin.clearBorders([[1, 1, 2, 2], [6, 2, 0, 2]]); + * // Using an array of CellRange objects (produced by `.getSelectedRange()` method). + * customBordersPlugin.clearBorders(hot.getSelectedRange()); + * // Using without param - clear all customBorders. + * customBordersPlugin.clearBorders(); + * ``` + * + * @param {Array[]|CellRange[]} selectionRanges Array of selection ranges. + */ + + }, { + key: "clearBorders", + value: function clearBorders(selectionRanges) { + var _this5 = this; + + if (selectionRanges) { + this.setBorders(selectionRanges); + } else { + arrayEach(this.savedBorders, function (border) { + _this5.clearBordersFromSelectionSettings(border.id); + + _this5.clearNullCellRange(); + + _this5.hot.removeCellMeta(border.row, border.col, 'borders'); + }); + this.savedBorders.length = 0; + } + } + /** + * Insert WalkontableSelection instance into Walkontable settings. + * + * @private + * @param {object} border Object with `row` and `col`, `left`, `right`, `top` and `bottom`, `id` and `border` ({Object} with `color`, `width` and `cornerVisible` property) properties. + * @param {string} place Coordinate where add/remove border - `top`, `bottom`, `left`, `right`. + */ + + }, { + key: "insertBorderIntoSettings", + value: function insertBorderIntoSettings(border, place) { + var hasSavedBorders = this.checkSavedBorders(border); + + if (!hasSavedBorders) { + this.savedBorders.push(border); + } + + var visualCellRange = new CellRange(new CellCoords(border.row, border.col)); + var hasCustomSelections = this.checkCustomSelections(border, visualCellRange, place); + + if (!hasCustomSelections) { + this.hot.selection.highlight.addCustomSelection({ + border: border, + visualCellRange: visualCellRange + }); + } + } + /** + * Prepare borders from setting (single cell). + * + * @private + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {object} borderDescriptor Object with `row` and `col`, `left`, `right`, `top` and `bottom` properties. + * @param {string} place Coordinate where add/remove border - `top`, `bottom`, `left`, `right`. + */ + + }, { + key: "prepareBorderFromCustomAdded", + value: function prepareBorderFromCustomAdded(row, column, borderDescriptor, place) { + var nrOfRows = this.hot.countRows(); + var nrOfColumns = this.hot.countCols(); + + if (row >= nrOfRows || column >= nrOfColumns) { + return; + } + + var border = createEmptyBorders(row, column); + + if (borderDescriptor) { + border = extendDefaultBorder(border, borderDescriptor); + arrayEach(this.hot.selection.highlight.customSelections, function (customSelection) { + if (border.id === customSelection.settings.id) { + Object.assign(customSelection.settings, borderDescriptor); + border.id = customSelection.settings.id; + border.left = customSelection.settings.left; + border.right = customSelection.settings.right; + border.top = customSelection.settings.top; + border.bottom = customSelection.settings.bottom; + return false; // breaks forAll + } + }); + } + + this.hot.setCellMeta(row, column, 'borders', border); + this.insertBorderIntoSettings(border, place); + } + /** + * Prepare borders from setting (object). + * + * @private + * @param {object} rowDecriptor Object with `range`, `left`, `right`, `top` and `bottom` properties. + */ + + }, { + key: "prepareBorderFromCustomAddedRange", + value: function prepareBorderFromCustomAddedRange(rowDecriptor) { + var _this6 = this; + + var range = rowDecriptor.range; + var lastRowIndex = Math.min(range.to.row, this.hot.countRows() - 1); + var lastColumnIndex = Math.min(range.to.col, this.hot.countCols() - 1); + rangeEach(range.from.row, lastRowIndex, function (rowIndex) { + rangeEach(range.from.col, lastColumnIndex, function (colIndex) { + var border = createEmptyBorders(rowIndex, colIndex); + var add = 0; + + if (rowIndex === range.from.row) { + if (hasOwnProperty$1(rowDecriptor, 'top')) { + add += 1; + border.top = rowDecriptor.top; + } + } // Please keep in mind that `range.to.row` may be beyond the table boundaries. The border won't be rendered. + + + if (rowIndex === range.to.row) { + if (hasOwnProperty$1(rowDecriptor, 'bottom')) { + add += 1; + border.bottom = rowDecriptor.bottom; + } + } + + if (colIndex === range.from.col) { + if (hasOwnProperty$1(rowDecriptor, 'left')) { + add += 1; + border.left = rowDecriptor.left; + } + } // Please keep in mind that `range.to.col` may be beyond the table boundaries. The border won't be rendered. + + + if (colIndex === range.to.col) { + if (hasOwnProperty$1(rowDecriptor, 'right')) { + add += 1; + border.right = rowDecriptor.right; + } + } + + if (add > 0) { + _this6.hot.setCellMeta(rowIndex, colIndex, 'borders', border); + + _this6.insertBorderIntoSettings(border); + } + }); + }); + } + /** + * Remove border (triggered from context menu). + * + * @private + * @param {number} row Visual row index. + * @param {number} column Visual column index. + */ + + }, { + key: "removeAllBorders", + value: function removeAllBorders(row, column) { + var borderId = createId(row, column); + this.spliceBorder(borderId); + this.clearBordersFromSelectionSettings(borderId); + this.clearNullCellRange(); + this.hot.removeCellMeta(row, column, 'borders'); + } + /** + * Set borders for each cell re. To border position. + * + * @private + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {string} place Coordinate where add/remove border - `top`, `bottom`, `left`, `right` and `noBorders`. + * @param {boolean} remove True when remove borders, and false when add borders. + */ + + }, { + key: "setBorder", + value: function setBorder(row, column, place, remove) { + var bordersMeta = this.hot.getCellMeta(row, column).borders; + + if (!bordersMeta || bordersMeta.border === void 0) { + bordersMeta = createEmptyBorders(row, column); + } + + if (remove) { + bordersMeta[place] = createSingleEmptyBorder(); + var hideCount = this.countHide(bordersMeta); + + if (hideCount === 4) { + this.removeAllBorders(row, column); + } else { + var customSelectionsChecker = this.checkCustomSelectionsFromContextMenu(bordersMeta, place, remove); + + if (!customSelectionsChecker) { + this.insertBorderIntoSettings(bordersMeta); + } + + this.hot.setCellMeta(row, column, 'borders', bordersMeta); + } + } else { + bordersMeta[place] = createDefaultCustomBorder(); + + var _customSelectionsChecker = this.checkCustomSelectionsFromContextMenu(bordersMeta, place, remove); + + if (!_customSelectionsChecker) { + this.insertBorderIntoSettings(bordersMeta); + } + + this.hot.setCellMeta(row, column, 'borders', bordersMeta); + } + } + /** + * Prepare borders based on cell and border position. + * + * @private + * @param {CellRange[]} selected An array of CellRange objects. + * @param {string} place Coordinate where add/remove border - `top`, `bottom`, `left`, `right` and `noBorders`. + * @param {boolean} remove True when remove borders, and false when add borders. + */ + + }, { + key: "prepareBorder", + value: function prepareBorder(selected, place, remove) { + var _this7 = this; + + arrayEach(selected, function (_ref) { + var start = _ref.start, + end = _ref.end; + + if (start.row === end.row && start.col === end.col) { + if (place === 'noBorders') { + _this7.removeAllBorders(start.row, start.col); + } else { + _this7.setBorder(start.row, start.col, place, remove); + } + } else { + switch (place) { + case 'noBorders': + rangeEach(start.col, end.col, function (colIndex) { + rangeEach(start.row, end.row, function (rowIndex) { + _this7.removeAllBorders(rowIndex, colIndex); + }); + }); + break; + + case 'top': + rangeEach(start.col, end.col, function (topCol) { + _this7.setBorder(start.row, topCol, place, remove); + }); + break; + + case 'right': + rangeEach(start.row, end.row, function (rowRight) { + _this7.setBorder(rowRight, end.col, place, remove); + }); + break; + + case 'bottom': + rangeEach(start.col, end.col, function (bottomCol) { + _this7.setBorder(end.row, bottomCol, place, remove); + }); + break; + + case 'left': + rangeEach(start.row, end.row, function (rowLeft) { + _this7.setBorder(rowLeft, start.col, place, remove); + }); + break; + } + } + }); + } + /** + * Create borders from settings. + * + * @private + * @param {Array} customBorders Object with `row` and `col`, `left`, `right`, `top` and `bottom` properties. + */ + + }, { + key: "createCustomBorders", + value: function createCustomBorders(customBorders) { + var _this8 = this; + + arrayEach(customBorders, function (customBorder) { + if (customBorder.range) { + _this8.prepareBorderFromCustomAddedRange(customBorder); + } else { + _this8.prepareBorderFromCustomAdded(customBorder.row, customBorder.col, customBorder); + } + }); + } + /** + * Count hide property in border object. + * + * @private + * @param {object} border Object with `row` and `col`, `left`, `right`, `top` and `bottom`, `id` and `border` ({Object} with `color`, `width` and `cornerVisible` property) properties. + * @returns {Array} + */ + + }, { + key: "countHide", + value: function countHide(border) { + var values = Object.values(border); + return arrayReduce(values, function (accumulator, value) { + var result = accumulator; + + if (value.hide) { + result += 1; + } + + return result; + }, 0); + } + /** + * Clear borders settings from custom selections. + * + * @private + * @param {string} borderId Border id name as string. + */ + + }, { + key: "clearBordersFromSelectionSettings", + value: function clearBordersFromSelectionSettings(borderId) { + var index = arrayMap(this.hot.selection.highlight.customSelections, function (customSelection) { + return customSelection.settings.id; + }).indexOf(borderId); + + if (index > -1) { + this.hot.selection.highlight.customSelections[index].clear(); + } + } + /** + * Clear cellRange with null value. + * + * @private + */ + + }, { + key: "clearNullCellRange", + value: function clearNullCellRange() { + var _this9 = this; + + arrayEach(this.hot.selection.highlight.customSelections, function (customSelection, index) { + if (customSelection.cellRange === null) { + _this9.hot.selection.highlight.customSelections[index].destroy(); + + _this9.hot.selection.highlight.customSelections.splice(index, 1); + + return false; // breaks forAll + } + }); + } + /** + * Hide custom borders. + * + * @private + */ + + }, { + key: "hideBorders", + value: function hideBorders() { + var _this10 = this; + + arrayEach(this.savedBorders, function (border) { + _this10.clearBordersFromSelectionSettings(border.id); + + _this10.clearNullCellRange(); + }); + } + /** + * Splice border from savedBorders. + * + * @private + * @param {string} borderId Border id name as string. + */ + + }, { + key: "spliceBorder", + value: function spliceBorder(borderId) { + var index = arrayMap(this.savedBorders, function (border) { + return border.id; + }).indexOf(borderId); + + if (index > -1) { + this.savedBorders.splice(index, 1); + } + } + /** + * Check if an border already exists in the savedBorders array, and if true update border in savedBorders. + * + * @private + * @param {object} border Object with `row` and `col`, `left`, `right`, `top` and `bottom`, `id` and `border` ({Object} with `color`, `width` and `cornerVisible` property) properties. + * + * @returns {boolean} + */ + + }, { + key: "checkSavedBorders", + value: function checkSavedBorders(border) { + var _this11 = this; + + var check = false; + var hideCount = this.countHide(border); + + if (hideCount === 4) { + this.spliceBorder(border.id); + check = true; + } else { + arrayEach(this.savedBorders, function (savedBorder, index) { + if (border.id === savedBorder.id) { + _this11.savedBorders[index] = border; + check = true; + return false; // breaks forAll + } + }); + } + + return check; + } + /** + * Check if an border already exists in the customSelections, and if true call toggleHiddenClass method. + * + * @private + * @param {object} border Object with `row` and `col`, `left`, `right`, `top` and `bottom`, `id` and `border` ({Object} with `color`, `width` and `cornerVisible` property) properties. + * @param {string} place Coordinate where add/remove border - `top`, `bottom`, `left`, `right` and `noBorders`. + * @param {boolean} remove True when remove borders, and false when add borders. + * + * @returns {boolean} + */ + + }, { + key: "checkCustomSelectionsFromContextMenu", + value: function checkCustomSelectionsFromContextMenu(border, place, remove) { + var check = false; + arrayEach(this.hot.selection.highlight.customSelections, function (customSelection) { + if (border.id === customSelection.settings.id) { + objectEach(customSelection.instanceBorders, function (borderObject) { + borderObject.toggleHiddenClass(place, remove); // TODO this also bad? + }); + check = true; + return false; // breaks forAll + } + }); + return check; + } + /** + * Check if an border already exists in the customSelections, and if true reset cellRange. + * + * @private + * @param {object} border Object with `row` and `col`, `left`, `right`, `top` and `bottom`, `id` and `border` ({Object} with `color`, `width` and `cornerVisible` property) properties. + * @param {CellRange} cellRange The selection range to check. + * @param {string} place Coordinate where add/remove border - `top`, `bottom`, `left`, `right`. + * @returns {boolean} + */ + + }, { + key: "checkCustomSelections", + value: function checkCustomSelections(border, cellRange, place) { + var hideCount = this.countHide(border); + var check = false; + + if (hideCount === 4) { + this.removeAllBorders(border.row, border.col); + check = true; + } else { + arrayEach(this.hot.selection.highlight.customSelections, function (customSelection) { + if (border.id === customSelection.settings.id) { + customSelection.visualCellRange = cellRange; + customSelection.commit(); + + if (place) { + objectEach(customSelection.instanceBorders, function (borderObject) { + borderObject.changeBorderStyle(place, border); + }); + } + + check = true; + return false; // breaks forAll + } + }); + } + + return check; + } + /** + * Change borders from settings. + * + * @private + */ + + }, { + key: "changeBorderSettings", + value: function changeBorderSettings() { + var customBorders = this.hot.getSettings()[PLUGIN_KEY$a]; + + if (Array.isArray(customBorders)) { + if (!customBorders.length) { + this.savedBorders = customBorders; + } + + this.createCustomBorders(customBorders); + } else if (customBorders !== void 0) { + this.createCustomBorders(this.savedBorders); + } + } + /** + * Add border options to context menu. + * + * @private + * @param {object} defaultOptions Context menu items. + */ + + }, { + key: "onAfterContextMenuDefaultOptions", + value: function onAfterContextMenuDefaultOptions(defaultOptions) { + if (!this.hot.getSettings()[PLUGIN_KEY$a]) { + return; + } + + defaultOptions.items.push({ + name: '---------' + }, { + key: 'borders', + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_BORDERS); + }, + disabled: function disabled() { + return this.selection.isSelectedByCorner(); + }, + submenu: { + items: [top(this), right(this), bottom(this), left(this), noBorders(this)] + } + }); + } + /** + * `afterInit` hook callback. + * + * @private + */ + + }, { + key: "onAfterInit", + value: function onAfterInit() { + this.changeBorderSettings(); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + _get$k(_getPrototypeOf$H(CustomBorders.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$a; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$9; + } + }]); + + return CustomBorders; +}(BasePlugin); + +function _typeof$T(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$T = function _typeof(obj) { return typeof obj; }; } else { _typeof$T = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$T(obj); } + +function _classCallCheck$1D(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1x(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); } } + +function _createClass$1x(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1x(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1x(Constructor, staticProps); return Constructor; } + +function _get$l(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$l = Reflect.get; } else { _get$l = function _get(target, property, receiver) { var base = _superPropBase$l(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$l(target, property, receiver || target); } + +function _superPropBase$l(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$I(object); if (object === null) break; } return object; } + +function _inherits$I(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$J(subClass, superClass); } + +function _setPrototypeOf$J(o, p) { _setPrototypeOf$J = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$J(o, p); } + +function _createSuper$I(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$J(); return function _createSuperInternal() { var Super = _getPrototypeOf$I(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$I(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$I(this, result); }; } + +function _possibleConstructorReturn$I(self, call) { if (call && (_typeof$T(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$I(self); } + +function _assertThisInitialized$I(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$J() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$I(o) { _getPrototypeOf$I = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$I(o); } +var PLUGIN_KEY$b = 'dragToScroll'; +var PLUGIN_PRIORITY$a = 100; +/** + * @description + * Plugin used to scroll Handsontable by selecting a cell and dragging outside of the visible viewport. + * + * + * @class DragToScroll + * @plugin DragToScroll + */ + +var DragToScroll = /*#__PURE__*/function (_BasePlugin) { + _inherits$I(DragToScroll, _BasePlugin); + + var _super = _createSuper$I(DragToScroll); + + function DragToScroll(hotInstance) { + var _this; + + _classCallCheck$1D(this, DragToScroll); + + _this = _super.call(this, hotInstance); + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + _this.eventManager = new EventManager(_assertThisInitialized$I(_this)); + /** + * Size of an element and its position relative to the viewport, + * e.g. {bottom: 449, height: 441, left: 8, right: 814, top: 8, width: 806, x: 8, y:8}. + * + * @type {DOMRect} + */ + + _this.boundaries = null; + /** + * Callback function. + * + * @private + * @type {Function} + */ + + _this.callback = null; + /** + * Flag indicates mouseDown/mouseUp. + * + * @private + * @type {boolean} + */ + + _this.listening = false; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link DragToScroll#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1x(DragToScroll, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$b]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.addHook('afterOnCellMouseDown', function (event) { + return _this2.setupListening(event); + }); + this.addHook('afterOnCellCornerMouseDown', function (event) { + return _this2.setupListening(event); + }); + this.registerEvents(); + + _get$l(_getPrototypeOf$I(DragToScroll.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$l(_getPrototypeOf$I(DragToScroll.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.unregisterEvents(); + + _get$l(_getPrototypeOf$I(DragToScroll.prototype), "disablePlugin", this).call(this); + } + /** + * Sets the value of the visible element. + * + * @param {DOMRect} boundaries An object with coordinates compatible with DOMRect. + */ + + }, { + key: "setBoundaries", + value: function setBoundaries(boundaries) { + this.boundaries = boundaries; + } + /** + * Changes callback function. + * + * @param {Function} callback The callback function. + */ + + }, { + key: "setCallback", + value: function setCallback(callback) { + this.callback = callback; + } + /** + * Checks if the mouse position (X, Y) is outside of the viewport and fires a callback with calculated X an Y diffs + * between passed boundaries. + * + * @param {number} x Mouse X coordinate to check. + * @param {number} y Mouse Y coordinate to check. + */ + + }, { + key: "check", + value: function check(x, y) { + var diffX = 0; + var diffY = 0; + + if (y < this.boundaries.top) { + // y is less than top + diffY = y - this.boundaries.top; + } else if (y > this.boundaries.bottom) { + // y is more than bottom + diffY = y - this.boundaries.bottom; + } + + if (x < this.boundaries.left) { + // x is less than left + diffX = x - this.boundaries.left; + } else if (x > this.boundaries.right) { + // x is more than right + diffX = x - this.boundaries.right; + } + + this.callback(diffX, diffY); + } + /** + * Enables listening on `mousemove` event. + * + * @private + */ + + }, { + key: "listen", + value: function listen() { + this.listening = true; + } + /** + * Disables listening on `mousemove` event. + * + * @private + */ + + }, { + key: "unlisten", + value: function unlisten() { + this.listening = false; + } + /** + * Returns current state of listening. + * + * @private + * @returns {boolean} + */ + + }, { + key: "isListening", + value: function isListening() { + return this.listening; + } + /** + * Registers dom listeners. + * + * @private + */ + + }, { + key: "registerEvents", + value: function registerEvents() { + var _this3 = this; + + var rootWindow = this.hot.rootWindow; + var frame = rootWindow; + + while (frame) { + this.eventManager.addEventListener(frame.document, 'contextmenu', function () { + return _this3.unlisten(); + }); + this.eventManager.addEventListener(frame.document, 'mouseup', function () { + return _this3.unlisten(); + }); + this.eventManager.addEventListener(frame.document, 'mousemove', function (event) { + return _this3.onMouseMove(event); + }); + frame = getParentWindow(frame); + } + } + /** + * Unbinds the events used by the plugin. + * + * @private + */ + + }, { + key: "unregisterEvents", + value: function unregisterEvents() { + this.eventManager.clear(); + } + /** + * On after on cell/cellCorner mouse down listener. + * + * @private + * @param {MouseEvent} event The mouse event object. + */ + + }, { + key: "setupListening", + value: function setupListening(event) { + if (isRightClick(event)) { + return; + } + + var scrollHandler = this.hot.view.wt.wtTable.holder; // native scroll + + if (scrollHandler === this.hot.rootWindow) { + // not much we can do currently + return; + } + + this.setBoundaries(scrollHandler.getBoundingClientRect()); + this.setCallback(function (scrollX, scrollY) { + if (scrollX < 0) { + scrollHandler.scrollLeft -= 50; + } else if (scrollX > 0) { + scrollHandler.scrollLeft += 50; + } + + if (scrollY < 0) { + scrollHandler.scrollTop -= 20; + } else if (scrollY > 0) { + scrollHandler.scrollTop += 20; + } + }); + this.listen(); + } + /** + * 'mouseMove' event callback. + * + * @private + * @param {MouseEvent} event `mousemove` event properties. + */ + + }, { + key: "onMouseMove", + value: function onMouseMove(event) { + if (!this.isListening()) { + return; + } + + this.check(event.clientX, event.clientY); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + _get$l(_getPrototypeOf$I(DragToScroll.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$b; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$a; + } + }]); + + return DragToScroll; +}(BasePlugin); + +function _slicedToArray$m(arr, i) { return _arrayWithHoles$n(arr) || _iterableToArrayLimit$m(arr, i) || _unsupportedIterableToArray$y(arr, i) || _nonIterableRest$n(); } + +function _nonIterableRest$n() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$y(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$y(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$y(o, minLen); } + +function _arrayLikeToArray$y(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$m(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$n(arr) { if (Array.isArray(arr)) return arr; } +/** + * @param {ManualColumnFreeze} manualColumnFreezePlugin The plugin instance. + * @returns {object} + */ + +function freezeColumnItem(manualColumnFreezePlugin) { + return { + key: 'freeze_column', + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_FREEZE_COLUMN); + }, + callback: function callback(key, selected) { + var _selected = _slicedToArray$m(selected, 1), + selectedColumn = _selected[0].start.col; + + manualColumnFreezePlugin.freezeColumn(selectedColumn); + this.render(); + this.view.adjustElementsSize(true); + }, + hidden: function hidden() { + var selection = this.getSelectedRange(); + var hide = false; + + if (selection === void 0) { + hide = true; + } else if (selection.length > 1) { + hide = true; + } else if (selection[0].from.col !== selection[0].to.col || selection[0].from.col <= this.getSettings().fixedColumnsLeft - 1) { + hide = true; + } + + return hide; + } + }; +} + +function _slicedToArray$n(arr, i) { return _arrayWithHoles$o(arr) || _iterableToArrayLimit$n(arr, i) || _unsupportedIterableToArray$z(arr, i) || _nonIterableRest$o(); } + +function _nonIterableRest$o() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$z(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$z(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$z(o, minLen); } + +function _arrayLikeToArray$z(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$n(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$o(arr) { if (Array.isArray(arr)) return arr; } +/** + * @param {ManualColumnFreeze} manualColumnFreezePlugin The plugin instance. + * @returns {object} + */ + +function unfreezeColumnItem(manualColumnFreezePlugin) { + return { + key: 'unfreeze_column', + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_UNFREEZE_COLUMN); + }, + callback: function callback(key, selected) { + var _selected = _slicedToArray$n(selected, 1), + selectedColumn = _selected[0].start.col; + + manualColumnFreezePlugin.unfreezeColumn(selectedColumn); + this.render(); + this.view.adjustElementsSize(true); + }, + hidden: function hidden() { + var selection = this.getSelectedRange(); + var hide = false; + + if (selection === void 0) { + hide = true; + } else if (selection.length > 1) { + hide = true; + } else if (selection[0].from.col !== selection[0].to.col || selection[0].from.col >= this.getSettings().fixedColumnsLeft) { + hide = true; + } + + return hide; + } + }; +} + +function _typeof$U(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$U = function _typeof(obj) { return typeof obj; }; } else { _typeof$U = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$U(obj); } + +function _classCallCheck$1E(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1y(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); } } + +function _createClass$1y(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1y(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1y(Constructor, staticProps); return Constructor; } + +function _get$m(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$m = Reflect.get; } else { _get$m = function _get(target, property, receiver) { var base = _superPropBase$m(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$m(target, property, receiver || target); } + +function _superPropBase$m(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$J(object); if (object === null) break; } return object; } + +function _inherits$J(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$K(subClass, superClass); } + +function _setPrototypeOf$K(o, p) { _setPrototypeOf$K = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$K(o, p); } + +function _createSuper$J(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$K(); return function _createSuperInternal() { var Super = _getPrototypeOf$J(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$J(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$J(this, result); }; } + +function _possibleConstructorReturn$J(self, call) { if (call && (_typeof$U(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$J(self); } + +function _assertThisInitialized$J(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$K() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$J(o) { _getPrototypeOf$J = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$J(o); } +var PLUGIN_KEY$c = 'manualColumnFreeze'; +var PLUGIN_PRIORITY$b = 110; +var privatePool$a = new WeakMap(); +/** + * This plugin allows to manually "freeze" and "unfreeze" a column using an entry in the Context Menu or using API. + * You can turn it on by setting a {@link Options#manualColumnFreeze} property to `true`. + * + * @example + * ```js + * // Enables the plugin + * manualColumnFreeze: true, + * ``` + * + * @plugin ManualColumnFreeze + */ + +var ManualColumnFreeze = /*#__PURE__*/function (_BasePlugin) { + _inherits$J(ManualColumnFreeze, _BasePlugin); + + var _super = _createSuper$J(ManualColumnFreeze); + + function ManualColumnFreeze(hotInstance) { + var _this; + + _classCallCheck$1E(this, ManualColumnFreeze); + + _this = _super.call(this, hotInstance); + privatePool$a.set(_assertThisInitialized$J(_this), { + afterFirstUse: false + }); + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ManualColumnFreeze#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1y(ManualColumnFreeze, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$c]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.addHook('afterContextMenuDefaultOptions', function (options) { + return _this2.addContextMenuEntry(options); + }); + this.addHook('beforeColumnMove', function (columns, finalIndex) { + return _this2.onBeforeColumnMove(columns, finalIndex); + }); + + _get$m(_getPrototypeOf$J(ManualColumnFreeze.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + var priv = privatePool$a.get(this); + priv.afterFirstUse = false; + + _get$m(_getPrototypeOf$J(ManualColumnFreeze.prototype), "disablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$m(_getPrototypeOf$J(ManualColumnFreeze.prototype), "updatePlugin", this).call(this); + } + /** + * Freezes the given column (add it to fixed columns). + * + * @param {number} column Visual column index. + */ + + }, { + key: "freezeColumn", + value: function freezeColumn(column) { + var priv = privatePool$a.get(this); + var settings = this.hot.getSettings(); + + if (!priv.afterFirstUse) { + priv.afterFirstUse = true; + } + + if (settings.fixedColumnsLeft === this.hot.countCols() || column <= settings.fixedColumnsLeft - 1) { + return; // already fixed + } + + this.hot.columnIndexMapper.moveIndexes(column, settings.fixedColumnsLeft); + settings.fixedColumnsLeft += 1; + } + /** + * Unfreezes the given column (remove it from fixed columns and bring to it's previous position). + * + * @param {number} column Visual column index. + */ + + }, { + key: "unfreezeColumn", + value: function unfreezeColumn(column) { + var priv = privatePool$a.get(this); + var settings = this.hot.getSettings(); + + if (!priv.afterFirstUse) { + priv.afterFirstUse = true; + } + + if (settings.fixedColumnsLeft <= 0 || column > settings.fixedColumnsLeft - 1) { + return; // not fixed + } + + settings.fixedColumnsLeft -= 1; + this.hot.columnIndexMapper.moveIndexes(column, settings.fixedColumnsLeft); + } + /** + * Adds the manualColumnFreeze context menu entries. + * + * @private + * @param {object} options Context menu options. + */ + + }, { + key: "addContextMenuEntry", + value: function addContextMenuEntry(options) { + options.items.push({ + name: '---------' + }, freezeColumnItem(this), unfreezeColumnItem(this)); + } + /** + * Prevents moving the columns from/to fixed area. + * + * @private + * @param {Array} columns Array of visual column indexes to be moved. + * @param {number} finalIndex Visual column index, being a start index for the moved columns. Points to where the elements will be placed after the moving action. + * @returns {boolean|undefined} + */ + + }, { + key: "onBeforeColumnMove", + value: function onBeforeColumnMove(columns, finalIndex) { + var priv = privatePool$a.get(this); + + if (priv.afterFirstUse) { + var freezeLine = this.hot.getSettings().fixedColumnsLeft; // Moving any column before the "freeze line" isn't possible. + + if (finalIndex < freezeLine) { + return false; + } // Moving frozen column isn't possible. + + + if (columns.some(function (column) { + return column < freezeLine; + })) { + return false; + } + } + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$c; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$b; + } + }]); + + return ManualColumnFreeze; +}(BasePlugin); + +function _classCallCheck$1F(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1z(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); } } + +function _createClass$1z(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1z(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1z(Constructor, staticProps); return Constructor; } +var STATE_INITIALIZED = 0; +var STATE_BUILT = 1; +var STATE_APPENDED = 2; +var UNIT = 'px'; +/** + * @class + * @private + */ + +var BaseUI = /*#__PURE__*/function () { + function BaseUI(hotInstance) { + _classCallCheck$1F(this, BaseUI); + + /** + * Instance of Handsontable. + * + * @type {Core} + */ + this.hot = hotInstance; + /** + * DOM element representing the ui element. + * + * @type {HTMLElement} + * @private + */ + + this._element = null; + /** + * Flag which determines build state of element. + * + * @type {boolean} + */ + + this.state = STATE_INITIALIZED; + } + /** + * Add created UI elements to table. + * + * @param {HTMLElement} wrapper Element which are parent for our UI element. + */ + + + _createClass$1z(BaseUI, [{ + key: "appendTo", + value: function appendTo(wrapper) { + wrapper.appendChild(this._element); + this.state = STATE_APPENDED; + } + /** + * Method for create UI element. Only create, without append to table. + */ + + }, { + key: "build", + value: function build() { + if (this.state !== STATE_INITIALIZED) { + return; + } + + this._element = this.hot.rootDocument.createElement('div'); + this.state = STATE_BUILT; + } + /** + * Method for remove UI element. + */ + + }, { + key: "destroy", + value: function destroy() { + if (this.isAppended()) { + this._element.parentElement.removeChild(this._element); + } + + this._element = null; + this.state = STATE_INITIALIZED; + } + /** + * Check if UI element are appended. + * + * @returns {boolean} + */ + + }, { + key: "isAppended", + value: function isAppended() { + return this.state === STATE_APPENDED; + } + /** + * Check if UI element are built. + * + * @returns {boolean} + */ + + }, { + key: "isBuilt", + value: function isBuilt() { + return this.state >= STATE_BUILT; + } + /** + * Setter for position. + * + * @param {number} top New top position of the element. + * @param {number} left New left position of the element. + */ + + }, { + key: "setPosition", + value: function setPosition(top, left) { + if (isNumeric(top)) { + this._element.style.top = top + UNIT; + } + + if (isNumeric(left)) { + this._element.style.left = left + UNIT; + } + } + /** + * Getter for the element position. + * + * @returns {object} Object contains left and top position of the element. + */ + + }, { + key: "getPosition", + value: function getPosition() { + return { + top: this._element.style.top ? parseInt(this._element.style.top, 10) : 0, + left: this._element.style.left ? parseInt(this._element.style.left, 10) : 0 + }; + } + /** + * Setter for the element size. + * + * @param {number} width New width of the element. + * @param {number} height New height of the element. + */ + + }, { + key: "setSize", + value: function setSize(width, height) { + if (isNumeric(width)) { + this._element.style.width = width + UNIT; + } + + if (isNumeric(height)) { + this._element.style.height = height + UNIT; + } + } + /** + * Getter for the element position. + * + * @returns {object} Object contains height and width of the element. + */ + + }, { + key: "getSize", + value: function getSize() { + return { + width: this._element.style.width ? parseInt(this._element.style.width, 10) : 0, + height: this._element.style.height ? parseInt(this._element.style.height, 10) : 0 + }; + } + /** + * Setter for the element offset. Offset means marginTop and marginLeft of the element. + * + * @param {number} top New margin top of the element. + * @param {number} left New margin left of the element. + */ + + }, { + key: "setOffset", + value: function setOffset(top, left) { + if (isNumeric(top)) { + this._element.style.marginTop = top + UNIT; + } + + if (isNumeric(left)) { + this._element.style.marginLeft = left + UNIT; + } + } + /** + * Getter for the element offset. + * + * @returns {object} Object contains top and left offset of the element. + */ + + }, { + key: "getOffset", + value: function getOffset() { + return { + top: this._element.style.marginTop ? parseInt(this._element.style.marginTop, 10) : 0, + left: this._element.style.marginLeft ? parseInt(this._element.style.marginLeft, 10) : 0 + }; + } + }]); + + return BaseUI; +}(); + +function _typeof$V(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$V = function _typeof(obj) { return typeof obj; }; } else { _typeof$V = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$V(obj); } + +function _classCallCheck$1G(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1A(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); } } + +function _createClass$1A(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1A(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1A(Constructor, staticProps); return Constructor; } + +function _get$n(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$n = Reflect.get; } else { _get$n = function _get(target, property, receiver) { var base = _superPropBase$n(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$n(target, property, receiver || target); } + +function _superPropBase$n(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$K(object); if (object === null) break; } return object; } + +function _inherits$K(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$L(subClass, superClass); } + +function _setPrototypeOf$L(o, p) { _setPrototypeOf$L = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$L(o, p); } + +function _createSuper$K(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$L(); return function _createSuperInternal() { var Super = _getPrototypeOf$K(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$K(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$K(this, result); }; } + +function _possibleConstructorReturn$K(self, call) { if (call && (_typeof$V(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$K(self); } + +function _assertThisInitialized$K(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$L() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$K(o) { _getPrototypeOf$K = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$K(o); } +var CSS_CLASSNAME = 'ht__manualColumnMove--backlight'; +/** + * @class BacklightUI + * @util + */ + +var BacklightUI = /*#__PURE__*/function (_BaseUI) { + _inherits$K(BacklightUI, _BaseUI); + + var _super = _createSuper$K(BacklightUI); + + function BacklightUI() { + _classCallCheck$1G(this, BacklightUI); + + return _super.apply(this, arguments); + } + + _createClass$1A(BacklightUI, [{ + key: "build", + value: + /** + * Custom className on build process. + */ + function build() { + _get$n(_getPrototypeOf$K(BacklightUI.prototype), "build", this).call(this); + + addClass(this._element, CSS_CLASSNAME); + } + }]); + + return BacklightUI; +}(BaseUI); + +function _typeof$W(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$W = function _typeof(obj) { return typeof obj; }; } else { _typeof$W = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$W(obj); } + +function _classCallCheck$1H(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1B(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); } } + +function _createClass$1B(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1B(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1B(Constructor, staticProps); return Constructor; } + +function _get$o(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$o = Reflect.get; } else { _get$o = function _get(target, property, receiver) { var base = _superPropBase$o(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$o(target, property, receiver || target); } + +function _superPropBase$o(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$L(object); if (object === null) break; } return object; } + +function _inherits$L(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$M(subClass, superClass); } + +function _setPrototypeOf$M(o, p) { _setPrototypeOf$M = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$M(o, p); } + +function _createSuper$L(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$M(); return function _createSuperInternal() { var Super = _getPrototypeOf$L(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$L(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$L(this, result); }; } + +function _possibleConstructorReturn$L(self, call) { if (call && (_typeof$W(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$L(self); } + +function _assertThisInitialized$L(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$M() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$L(o) { _getPrototypeOf$L = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$L(o); } +var CSS_CLASSNAME$1 = 'ht__manualColumnMove--guideline'; +/** + * @class GuidelineUI + * @util + */ + +var GuidelineUI = /*#__PURE__*/function (_BaseUI) { + _inherits$L(GuidelineUI, _BaseUI); + + var _super = _createSuper$L(GuidelineUI); + + function GuidelineUI() { + _classCallCheck$1H(this, GuidelineUI); + + return _super.apply(this, arguments); + } + + _createClass$1B(GuidelineUI, [{ + key: "build", + value: + /** + * Custom className on build process. + */ + function build() { + _get$o(_getPrototypeOf$L(GuidelineUI.prototype), "build", this).call(this); + + addClass(this._element, CSS_CLASSNAME$1); + } + }]); + + return GuidelineUI; +}(BaseUI); + +function _typeof$X(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$X = function _typeof(obj) { return typeof obj; }; } else { _typeof$X = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$X(obj); } + +function _classCallCheck$1I(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1C(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); } } + +function _createClass$1C(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1C(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1C(Constructor, staticProps); return Constructor; } + +function _get$p(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$p = Reflect.get; } else { _get$p = function _get(target, property, receiver) { var base = _superPropBase$p(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$p(target, property, receiver || target); } + +function _superPropBase$p(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$M(object); if (object === null) break; } return object; } + +function _inherits$M(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$N(subClass, superClass); } + +function _setPrototypeOf$N(o, p) { _setPrototypeOf$N = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$N(o, p); } + +function _createSuper$M(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$N(); return function _createSuperInternal() { var Super = _getPrototypeOf$M(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$M(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$M(this, result); }; } + +function _possibleConstructorReturn$M(self, call) { if (call && (_typeof$X(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$M(self); } + +function _assertThisInitialized$M(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$N() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$M(o) { _getPrototypeOf$M = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$M(o); } +Hooks.getSingleton().register('beforeColumnMove'); +Hooks.getSingleton().register('afterColumnMove'); +var PLUGIN_KEY$d = 'manualColumnMove'; +var PLUGIN_PRIORITY$c = 120; +var privatePool$b = new WeakMap(); +var CSS_PLUGIN = 'ht__manualColumnMove'; +var CSS_SHOW_UI = 'show-ui'; +var CSS_ON_MOVING = 'on-moving--columns'; +var CSS_AFTER_SELECTION = 'after-selection--columns'; +/** + * @plugin ManualColumnMove + * + * @description + * This plugin allows to change columns order. To make columns order persistent the {@link Options#persistentState} + * plugin should be enabled. + * + * API: + * - `moveColumn` - move single column to the new position. + * - `moveColumns` - move many columns (as an array of indexes) to the new position. + * - `dragColumn` - drag single column to the new position. + * - `dragColumns` - drag many columns (as an array of indexes) to the new position. + * + * [Documentation](/demo-moving.html#manualColumnMove) explain differences between drag and move actions. Please keep in mind that if you want apply visual changes, + * you have to call manually the `render` method on the instance of Handsontable. + * + * The plugin creates additional components to make moving possibly using user interface: + * - backlight - highlight of selected columns. + * - guideline - line which shows where columns has been moved. + * + * @class ManualColumnMove + * @plugin ManualColumnMove + */ + +var ManualColumnMove = /*#__PURE__*/function (_BasePlugin) { + _inherits$M(ManualColumnMove, _BasePlugin); + + var _super = _createSuper$M(ManualColumnMove); + + function ManualColumnMove(hotInstance) { + var _this; + + _classCallCheck$1I(this, ManualColumnMove); + + _this = _super.call(this, hotInstance); + /** + * Set up WeakMap of plugin to sharing private parameters;. + */ + + privatePool$b.set(_assertThisInitialized$M(_this), { + columnsToMove: [], + countCols: 0, + fixedColumns: 0, + pressed: void 0, + target: { + eventPageX: void 0, + coords: void 0, + TD: void 0, + col: void 0 + }, + cachedDropIndex: void 0 + }); + /** + * Event Manager object. + * + * @private + * @type {object} + */ + + _this.eventManager = new EventManager(_assertThisInitialized$M(_this)); + /** + * Backlight UI object. + * + * @private + * @type {object} + */ + + _this.backlight = new BacklightUI(hotInstance); + /** + * Guideline UI object. + * + * @private + * @type {object} + */ + + _this.guideline = new GuidelineUI(hotInstance); + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ManualColumnMove#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1C(ManualColumnMove, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$d]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.addHook('beforeOnCellMouseDown', function (event, coords, TD, blockCalculations) { + return _this2.onBeforeOnCellMouseDown(event, coords, TD, blockCalculations); + }); + this.addHook('beforeOnCellMouseOver', function (event, coords, TD, blockCalculations) { + return _this2.onBeforeOnCellMouseOver(event, coords, TD, blockCalculations); + }); + this.addHook('afterScrollVertically', function () { + return _this2.onAfterScrollVertically(); + }); + this.addHook('afterLoadData', function () { + return _this2.onAfterLoadData(); + }); + this.buildPluginUI(); + this.registerEvents(); // TODO: move adding plugin classname to BasePlugin. + + addClass(this.hot.rootElement, CSS_PLUGIN); + + _get$p(_getPrototypeOf$M(ManualColumnMove.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + this.moveBySettingsOrLoad(); + + _get$p(_getPrototypeOf$M(ManualColumnMove.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + removeClass(this.hot.rootElement, CSS_PLUGIN); + this.unregisterEvents(); + this.backlight.destroy(); + this.guideline.destroy(); + + _get$p(_getPrototypeOf$M(ManualColumnMove.prototype), "disablePlugin", this).call(this); + } + /** + * Moves a single column. + * + * @param {number} column Visual column index to be moved. + * @param {number} finalIndex Visual column index, being a start index for the moved columns. Points to where the elements will be placed after the moving action. + * To check the visualization of the final index, please take a look at [documentation](/demo-moving.html#manualColumnMove). + * @fires Hooks#beforeColumnMove + * @fires Hooks#afterColumnMove + * @returns {boolean} + */ + + }, { + key: "moveColumn", + value: function moveColumn(column, finalIndex) { + return this.moveColumns([column], finalIndex); + } + /** + * Moves a multiple columns. + * + * @param {Array} columns Array of visual column indexes to be moved. + * @param {number} finalIndex Visual column index, being a start index for the moved columns. Points to where the elements will be placed after the moving action. + * To check the visualization of the final index, please take a look at [documentation](/demo-moving.html#manualColumnMove). + * @fires Hooks#beforeColumnMove + * @fires Hooks#afterColumnMove + * @returns {boolean} + */ + + }, { + key: "moveColumns", + value: function moveColumns(columns, finalIndex) { + var priv = privatePool$b.get(this); + var dropIndex = priv.cachedDropIndex; + var movePossible = this.isMovePossible(columns, finalIndex); + var beforeMoveHook = this.hot.runHooks('beforeColumnMove', columns, finalIndex, dropIndex, movePossible); + priv.cachedDropIndex = void 0; + + if (beforeMoveHook === false) { + return; + } + + if (movePossible) { + this.hot.columnIndexMapper.moveIndexes(columns, finalIndex); + } + + var movePerformed = movePossible && this.isColumnOrderChanged(columns, finalIndex); + this.hot.runHooks('afterColumnMove', columns, finalIndex, dropIndex, movePossible, movePerformed); + return movePerformed; + } + /** + * Drag a single column to drop index position. + * + * @param {number} column Visual column index to be dragged. + * @param {number} dropIndex Visual column index, being a drop index for the moved columns. Points to where we are going to drop the moved elements. + * To check visualization of drop index please take a look at [documentation](/demo-moving.html#manualColumnMove). + * @fires Hooks#beforeColumnMove + * @fires Hooks#afterColumnMove + * @returns {boolean} + */ + + }, { + key: "dragColumn", + value: function dragColumn(column, dropIndex) { + return this.dragColumns([column], dropIndex); + } + /** + * Drag multiple columns to drop index position. + * + * @param {Array} columns Array of visual column indexes to be dragged. + * @param {number} dropIndex Visual column index, being a drop index for the moved columns. Points to where we are going to drop the moved elements. + * To check visualization of drop index please take a look at [documentation](/demo-moving.html#manualColumnMove). + * @fires Hooks#beforeColumnMove + * @fires Hooks#afterColumnMove + * @returns {boolean} + */ + + }, { + key: "dragColumns", + value: function dragColumns(columns, dropIndex) { + var finalIndex = this.countFinalIndex(columns, dropIndex); + var priv = privatePool$b.get(this); + priv.cachedDropIndex = dropIndex; + return this.moveColumns(columns, finalIndex); + } + /** + * Indicates if it's possible to move columns to the desired position. Some of the actions aren't possible, i.e. You can’t move more than one element to the last position. + * + * @param {Array} movedColumns Array of visual column indexes to be moved. + * @param {number} finalIndex Visual column index, being a start index for the moved columns. Points to where the elements will be placed after the moving action. + * To check the visualization of the final index, please take a look at [documentation](/demo-moving.html#manualColumnMove). + * @returns {boolean} + */ + + }, { + key: "isMovePossible", + value: function isMovePossible(movedColumns, finalIndex) { + var length = this.hot.columnIndexMapper.getNotTrimmedIndexesLength(); // An attempt to transfer more columns to start destination than is possible (only when moving from the top to the bottom). + + var tooHighDestinationIndex = movedColumns.length + finalIndex > length; + var tooLowDestinationIndex = finalIndex < 0; + var tooLowMovedColumnIndex = movedColumns.some(function (movedColumn) { + return movedColumn < 0; + }); + var tooHighMovedColumnIndex = movedColumns.some(function (movedColumn) { + return movedColumn >= length; + }); + + if (tooHighDestinationIndex || tooLowDestinationIndex || tooLowMovedColumnIndex || tooHighMovedColumnIndex) { + return false; + } + + return true; + } + /** + * Indicates if order of columns was changed. + * + * @private + * @param {Array} movedColumns Array of visual column indexes to be moved. + * @param {number} finalIndex Visual column index, being a start index for the moved columns. Points to where the elements will be placed after the moving action. + * To check the visualization of the final index, please take a look at [documentation](/demo-moving.html#manualColumnMove). + * @returns {boolean} + */ + + }, { + key: "isColumnOrderChanged", + value: function isColumnOrderChanged(movedColumns, finalIndex) { + return movedColumns.some(function (column, nrOfMovedElement) { + return column - nrOfMovedElement !== finalIndex; + }); + } + /** + * Count the final column index from the drop index. + * + * @private + * @param {Array} movedColumns Array of visual column indexes to be moved. + * @param {number} dropIndex Visual column index, being a drop index for the moved columns. + * @returns {number} Visual column index, being a start index for the moved columns. + */ + + }, { + key: "countFinalIndex", + value: function countFinalIndex(movedColumns, dropIndex) { + var numberOfColumnsLowerThanDropIndex = arrayReduce(movedColumns, function (numberOfColumns, currentColumnIndex) { + if (currentColumnIndex < dropIndex) { + numberOfColumns += 1; + } + + return numberOfColumns; + }, 0); + return dropIndex - numberOfColumnsLowerThanDropIndex; + } + /** + * Gets the sum of the widths of columns in the provided range. + * + * @private + * @param {number} fromColumn Visual column index. + * @param {number} toColumn Visual column index. + * @returns {number} + */ + + }, { + key: "getColumnsWidth", + value: function getColumnsWidth(fromColumn, toColumn) { + var columnMapper = this.hot.columnIndexMapper; + var columnsWidth = 0; + + for (var visualColumnIndex = fromColumn; visualColumnIndex <= toColumn; visualColumnIndex += 1) { + // We can't use just `getColWidth` (even without indexes translation) as it doesn't return proper values + // when column is stretched. + var renderableIndex = columnMapper.getRenderableFromVisualIndex(visualColumnIndex); + + if (visualColumnIndex < 0) { + columnsWidth += this.hot.view.wt.wtViewport.getRowHeaderWidth() || 0; + } else if (renderableIndex !== null) { + columnsWidth += this.hot.view.wt.wtTable.getStretchedColumnWidth(renderableIndex) || 0; + } + } + + return columnsWidth; + } + /** + * Loads initial settings when persistent state is saved or when plugin was initialized as an array. + * + * @private + */ + + }, { + key: "moveBySettingsOrLoad", + value: function moveBySettingsOrLoad() { + var pluginSettings = this.hot.getSettings()[PLUGIN_KEY$d]; + + if (Array.isArray(pluginSettings)) { + this.moveColumns(pluginSettings, 0); + } else if (pluginSettings !== void 0) { + var persistentState = this.persistentStateLoad(); + + if (persistentState.length) { + this.moveColumns(persistentState, 0); + } + } + } + /** + * Checks if the provided column is in the fixedColumnsTop section. + * + * @private + * @param {number} column Visual column index to check. + * @returns {boolean} + */ + + }, { + key: "isFixedColumnsLeft", + value: function isFixedColumnsLeft(column) { + return column < this.hot.getSettings().fixedColumnsLeft; + } + /** + * Saves the manual column positions to the persistent state (the {@link Options#persistentState} option has to be enabled). + * + * @private + * @fires Hooks#persistentStateSave + */ + + }, { + key: "persistentStateSave", + value: function persistentStateSave() { + this.hot.runHooks('persistentStateSave', 'manualColumnMove', this.hot.columnIndexMapper.getIndexesSequence()); // The `PersistentState` plugin should be refactored. + } + /** + * Loads the manual column positions from the persistent state (the {@link Options#persistentState} option has to be enabled). + * + * @private + * @fires Hooks#persistentStateLoad + * @returns {Array} Stored state. + */ + + }, { + key: "persistentStateLoad", + value: function persistentStateLoad() { + var storedState = {}; + this.hot.runHooks('persistentStateLoad', 'manualColumnMove', storedState); + return storedState.value ? storedState.value : []; + } + /** + * Prepares an array of indexes based on actual selection. + * + * @private + * @param {number} start The start index. + * @param {number} end The end index. + * @returns {Array} + */ + + }, { + key: "prepareColumnsToMoving", + value: function prepareColumnsToMoving(start, end) { + var selectedColumns = []; + rangeEach(start, end, function (i) { + selectedColumns.push(i); + }); + return selectedColumns; + } + /** + * Update the UI visual position. + * + * @private + */ + + }, { + key: "refreshPositions", + value: function refreshPositions() { + var priv = privatePool$b.get(this); + var firstVisible = this.hot.view.wt.wtTable.getFirstVisibleColumn(); + var lastVisible = this.hot.view.wt.wtTable.getLastVisibleColumn(); + var wtTable = this.hot.view.wt.wtTable; + var scrollableElement = this.hot.view.wt.wtOverlays.scrollableElement; + var scrollLeft = typeof scrollableElement.scrollX === 'number' ? scrollableElement.scrollX : scrollableElement.scrollLeft; + var tdOffsetLeft = this.hot.view.THEAD.offsetLeft + this.getColumnsWidth(0, priv.coords - 1); + var mouseOffsetLeft = priv.target.eventPageX - (priv.rootElementOffset - (scrollableElement.scrollX === void 0 ? scrollLeft : 0)); // eslint-disable-line max-len + + var hiderWidth = wtTable.hider.offsetWidth; + var tbodyOffsetLeft = wtTable.TBODY.offsetLeft; + var backlightElemMarginLeft = this.backlight.getOffset().left; + var backlightElemWidth = this.backlight.getSize().width; + var rowHeaderWidth = 0; + + if (priv.rootElementOffset + wtTable.holder.offsetWidth + scrollLeft < priv.target.eventPageX) { + if (priv.coords < priv.countCols) { + priv.coords += 1; + } + } + + if (priv.hasRowHeaders) { + rowHeaderWidth = this.hot.view.wt.wtOverlays.leftOverlay.clone.wtTable.getColumnHeader(-1).offsetWidth; + } + + if (this.isFixedColumnsLeft(priv.coords)) { + tdOffsetLeft += scrollLeft; + } + + tdOffsetLeft += rowHeaderWidth; + + if (priv.coords < 0) { + // if hover on rowHeader + if (priv.fixedColumns > 0) { + priv.target.col = 0; + } else { + priv.target.col = firstVisible > 0 ? firstVisible - 1 : firstVisible; + } + } else if (priv.target.TD.offsetWidth / 2 + tdOffsetLeft <= mouseOffsetLeft) { + var newCoordsCol = priv.coords >= priv.countCols ? priv.countCols - 1 : priv.coords; // if hover on right part of TD + + priv.target.col = newCoordsCol + 1; // unfortunately first column is bigger than rest + + tdOffsetLeft += priv.target.TD.offsetWidth; + + if (priv.target.col > lastVisible && lastVisible < priv.countCols) { + this.hot.scrollViewportTo(void 0, lastVisible + 1, void 0, true); + } + } else { + // elsewhere on table + priv.target.col = priv.coords; + + if (priv.target.col <= firstVisible && priv.target.col >= priv.fixedColumns && firstVisible > 0) { + this.hot.scrollViewportTo(void 0, firstVisible - 1); + } + } + + if (priv.target.col <= firstVisible && priv.target.col >= priv.fixedColumns && firstVisible > 0) { + this.hot.scrollViewportTo(void 0, firstVisible - 1); + } + + var backlightLeft = mouseOffsetLeft; + var guidelineLeft = tdOffsetLeft; + + if (mouseOffsetLeft + backlightElemWidth + backlightElemMarginLeft >= hiderWidth) { + // prevent display backlight on the right side of the table + backlightLeft = hiderWidth - backlightElemWidth - backlightElemMarginLeft; + } else if (mouseOffsetLeft + backlightElemMarginLeft < tbodyOffsetLeft + rowHeaderWidth) { + // prevent display backlight on the left side of the table + backlightLeft = tbodyOffsetLeft + rowHeaderWidth + Math.abs(backlightElemMarginLeft); + } + + if (tdOffsetLeft >= hiderWidth - 1) { + // prevent display guideline outside the table + guidelineLeft = hiderWidth - 1; + } else if (guidelineLeft === 0) { + // guideline has got `margin-left: -1px` as default + guidelineLeft = 1; + } else if (scrollableElement.scrollX !== void 0 && priv.coords < priv.fixedColumns) { + guidelineLeft -= priv.rootElementOffset <= scrollableElement.scrollX ? priv.rootElementOffset : 0; + } + + this.backlight.setPosition(null, backlightLeft); + this.guideline.setPosition(null, guidelineLeft); + } + /** + * Binds the events used by the plugin. + * + * @private + */ + + }, { + key: "registerEvents", + value: function registerEvents() { + var _this3 = this; + + var documentElement = this.hot.rootDocument.documentElement; + this.eventManager.addEventListener(documentElement, 'mousemove', function (event) { + return _this3.onMouseMove(event); + }); + this.eventManager.addEventListener(documentElement, 'mouseup', function () { + return _this3.onMouseUp(); + }); + } + /** + * Unbinds the events used by the plugin. + * + * @private + */ + + }, { + key: "unregisterEvents", + value: function unregisterEvents() { + this.eventManager.clear(); + } + /** + * Change the behavior of selection / dragging. + * + * @private + * @param {MouseEvent} event `mousedown` event properties. + * @param {CellCoords} coords Visual cell coordinates where was fired event. + * @param {HTMLElement} TD Cell represented as HTMLElement. + * @param {object} blockCalculations Object which contains information about blockCalculation for row, column or cells. + */ + + }, { + key: "onBeforeOnCellMouseDown", + value: function onBeforeOnCellMouseDown(event, coords, TD, blockCalculations) { + var wtTable = this.hot.view.wt.wtTable; + var isHeaderSelection = this.hot.selection.isSelectedByColumnHeader(); + var selection = this.hot.getSelectedRangeLast(); + var priv = privatePool$b.get(this); // This block action shouldn't be handled below. + + var isSortingElement = hasClass(event.target, 'sortAction'); + + if (!selection || !isHeaderSelection || priv.pressed || event.button !== 0 || isSortingElement) { + priv.pressed = false; + priv.columnsToMove.length = 0; + removeClass(this.hot.rootElement, [CSS_ON_MOVING, CSS_SHOW_UI]); + return; + } + + var guidelineIsNotReady = this.guideline.isBuilt() && !this.guideline.isAppended(); + var backlightIsNotReady = this.backlight.isBuilt() && !this.backlight.isAppended(); + + if (guidelineIsNotReady && backlightIsNotReady) { + this.guideline.appendTo(wtTable.hider); + this.backlight.appendTo(wtTable.hider); + } + + var from = selection.from, + to = selection.to; + var start = Math.min(from.col, to.col); + var end = Math.max(from.col, to.col); + + if (coords.row < 0 && coords.col >= start && coords.col <= end) { + blockCalculations.column = true; + priv.pressed = true; + priv.target.eventPageX = event.pageX; + priv.coords = coords.col; + priv.target.TD = TD; + priv.target.col = coords.col; + priv.columnsToMove = this.prepareColumnsToMoving(start, end); + priv.hasRowHeaders = !!this.hot.getSettings().rowHeaders; + priv.countCols = this.hot.countCols(); + priv.fixedColumns = this.hot.getSettings().fixedColumnsLeft; + priv.rootElementOffset = offset(this.hot.rootElement).left; + var countColumnsFrom = priv.hasRowHeaders ? -1 : 0; + var topPos = wtTable.holder.scrollTop + wtTable.getColumnHeaderHeight(0) + 1; + var fixedColumns = coords.col < priv.fixedColumns; + var scrollableElement = this.hot.view.wt.wtOverlays.scrollableElement; + var wrapperIsWindow = scrollableElement.scrollX ? scrollableElement.scrollX - priv.rootElementOffset : 0; + var mouseOffset = event.offsetX - (fixedColumns ? wrapperIsWindow : 0); + var leftOffset = Math.abs(this.getColumnsWidth(start, coords.col - 1) + mouseOffset); + this.backlight.setPosition(topPos, this.getColumnsWidth(countColumnsFrom, start - 1) + leftOffset); + this.backlight.setSize(this.getColumnsWidth(start, end), wtTable.hider.offsetHeight - topPos); + this.backlight.setOffset(null, leftOffset * -1); + addClass(this.hot.rootElement, CSS_ON_MOVING); + } else { + removeClass(this.hot.rootElement, CSS_AFTER_SELECTION); + priv.pressed = false; + priv.columnsToMove.length = 0; + } + } + /** + * 'mouseMove' event callback. Fired when pointer move on document.documentElement. + * + * @private + * @param {MouseEvent} event `mousemove` event properties. + */ + + }, { + key: "onMouseMove", + value: function onMouseMove(event) { + var priv = privatePool$b.get(this); + + if (!priv.pressed) { + return; + } // callback for browser which doesn't supports CSS pointer-event: none + + + if (event.target === this.backlight.element) { + var width = this.backlight.getSize().width; + this.backlight.setSize(0); + setTimeout(function () { + this.backlight.setPosition(width); + }); + } + + priv.target.eventPageX = event.pageX; + this.refreshPositions(); + } + /** + * 'beforeOnCellMouseOver' hook callback. Fired when pointer was over cell. + * + * @private + * @param {MouseEvent} event `mouseover` event properties. + * @param {CellCoords} coords Visual cell coordinates where was fired event. + * @param {HTMLElement} TD Cell represented as HTMLElement. + * @param {object} blockCalculations Object which contains information about blockCalculation for column, column or cells. + */ + + }, { + key: "onBeforeOnCellMouseOver", + value: function onBeforeOnCellMouseOver(event, coords, TD, blockCalculations) { + var selectedRange = this.hot.getSelectedRangeLast(); + var priv = privatePool$b.get(this); + + if (!selectedRange || !priv.pressed) { + return; + } + + if (priv.columnsToMove.indexOf(coords.col) > -1) { + removeClass(this.hot.rootElement, CSS_SHOW_UI); + } else { + addClass(this.hot.rootElement, CSS_SHOW_UI); + } + + blockCalculations.row = true; + blockCalculations.column = true; + blockCalculations.cell = true; + priv.coords = coords.col; + priv.target.TD = TD; + } + /** + * `onMouseUp` hook callback. + * + * @private + */ + + }, { + key: "onMouseUp", + value: function onMouseUp() { + var priv = privatePool$b.get(this); + var target = priv.target.col; + var columnsLen = priv.columnsToMove.length; + priv.coords = void 0; + priv.pressed = false; + priv.backlightWidth = 0; + removeClass(this.hot.rootElement, [CSS_ON_MOVING, CSS_SHOW_UI, CSS_AFTER_SELECTION]); + + if (this.hot.selection.isSelectedByColumnHeader()) { + addClass(this.hot.rootElement, CSS_AFTER_SELECTION); + } + + if (columnsLen < 1 || target === void 0) { + return; + } + + var firstMovedVisualColumn = priv.columnsToMove[0]; + var firstMovedPhysicalColumn = this.hot.toPhysicalColumn(firstMovedVisualColumn); + var movePerformed = this.dragColumns(priv.columnsToMove, target); + priv.columnsToMove.length = 0; + + if (movePerformed === true) { + this.persistentStateSave(); + this.hot.render(); + this.hot.view.adjustElementsSize(true); + var selectionStart = this.hot.toVisualColumn(firstMovedPhysicalColumn); + var selectionEnd = selectionStart + columnsLen - 1; + this.hot.selectColumns(selectionStart, selectionEnd); + } + } + /** + * `afterScrollHorizontally` hook callback. Fired the table was scrolled horizontally. + * + * @private + */ + + }, { + key: "onAfterScrollVertically", + value: function onAfterScrollVertically() { + var wtTable = this.hot.view.wt.wtTable; + var headerHeight = wtTable.getColumnHeaderHeight(0) + 1; + var scrollTop = wtTable.holder.scrollTop; + var posTop = headerHeight + scrollTop; + this.backlight.setPosition(posTop); + this.backlight.setSize(null, wtTable.hider.offsetHeight - posTop); + } + /** + * Builds the plugin's UI. + * + * @private + */ + + }, { + key: "buildPluginUI", + value: function buildPluginUI() { + this.backlight.build(); + this.guideline.build(); + } + /** + * Callback for the `afterLoadData` hook. + * + * @private + */ + + }, { + key: "onAfterLoadData", + value: function onAfterLoadData() { + this.moveBySettingsOrLoad(); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.backlight.destroy(); + this.guideline.destroy(); + + _get$p(_getPrototypeOf$M(ManualColumnMove.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$d; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$c; + } + }]); + + return ManualColumnMove; +}(BasePlugin); + +function _typeof$Y(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$Y = function _typeof(obj) { return typeof obj; }; } else { _typeof$Y = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$Y(obj); } + +function _classCallCheck$1J(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1D(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); } } + +function _createClass$1D(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1D(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1D(Constructor, staticProps); return Constructor; } + +function _get$q(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$q = Reflect.get; } else { _get$q = function _get(target, property, receiver) { var base = _superPropBase$q(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$q(target, property, receiver || target); } + +function _superPropBase$q(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$N(object); if (object === null) break; } return object; } + +function _inherits$N(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$O(subClass, superClass); } + +function _setPrototypeOf$O(o, p) { _setPrototypeOf$O = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$O(o, p); } + +function _createSuper$N(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$O(); return function _createSuperInternal() { var Super = _getPrototypeOf$N(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$N(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$N(this, result); }; } + +function _possibleConstructorReturn$N(self, call) { if (call && (_typeof$Y(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$N(self); } + +function _assertThisInitialized$N(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$O() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$N(o) { _getPrototypeOf$N = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$N(o); } + +var PLUGIN_KEY$e = 'manualColumnResize'; +var PLUGIN_PRIORITY$d = 130; +var PERSISTENT_STATE_KEY$1 = 'manualColumnWidths'; +var privatePool$c = new WeakMap(); +/** + * @description + * This plugin allows to change columns width. To make columns width persistent the {@link Options#persistentState} + * plugin should be enabled. + * + * The plugin creates additional components to make resizing possibly using user interface: + * - handle - the draggable element that sets the desired width of the column. + * - guide - the helper guide that shows the desired width as a vertical guide. + * + * @plugin ManualColumnResize + */ + +var ManualColumnResize = /*#__PURE__*/function (_BasePlugin) { + _inherits$N(ManualColumnResize, _BasePlugin); + + var _super = _createSuper$N(ManualColumnResize); + + function ManualColumnResize(hotInstance) { + var _this; + + _classCallCheck$1J(this, ManualColumnResize); + + _this = _super.call(this, hotInstance); + var rootDocument = _this.hot.rootDocument; + _this.currentTH = null; + _this.currentCol = null; + _this.selectedCols = []; + _this.currentWidth = null; + _this.newSize = null; + _this.startY = null; + _this.startWidth = null; + _this.startOffset = null; + _this.handle = rootDocument.createElement('DIV'); + _this.guide = rootDocument.createElement('DIV'); + _this.eventManager = new EventManager(_assertThisInitialized$N(_this)); + _this.pressed = null; + _this.dblclick = 0; + _this.autoresizeTimeout = null; + /** + * PhysicalIndexToValueMap to keep and track widths for physical column indexes. + * + * @private + * @type {PhysicalIndexToValueMap} + */ + + _this.columnWidthsMap = void 0; + /** + * Private pool to save configuration from updateSettings. + */ + + privatePool$c.set(_assertThisInitialized$N(_this), { + config: void 0 + }); + addClass(_this.handle, 'manualColumnResizer'); + addClass(_this.guide, 'manualColumnResizerGuide'); + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ManualColumnResize#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1D(ManualColumnResize, [{ + key: "isEnabled", + value: function isEnabled() { + return this.hot.getSettings()[PLUGIN_KEY$e]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.columnWidthsMap = new PhysicalIndexToValueMap(); + this.columnWidthsMap.addLocalHook('init', function () { + return _this2.onMapInit(); + }); + this.hot.columnIndexMapper.registerMap(this.pluginName, this.columnWidthsMap); + this.addHook('modifyColWidth', function (width, col) { + return _this2.onModifyColWidth(width, col); + }); + this.addHook('beforeStretchingColumnWidth', function (stretchedWidth, column) { + return _this2.onBeforeStretchingColumnWidth(stretchedWidth, column); + }); + this.addHook('beforeColumnResize', function (newSize, column, isDoubleClick) { + return _this2.onBeforeColumnResize(newSize, column, isDoubleClick); + }); + this.bindEvents(); + + _get$q(_getPrototypeOf$N(ManualColumnResize.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$q(_getPrototypeOf$N(ManualColumnResize.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + var priv = privatePool$c.get(this); + priv.config = this.columnWidthsMap.getValues(); + this.hot.columnIndexMapper.unregisterMap(this.pluginName); + + _get$q(_getPrototypeOf$N(ManualColumnResize.prototype), "disablePlugin", this).call(this); + } + /** + * Saves the current sizes using the persistentState plugin (the {@link Options#persistentState} option has to be enabled). + * + * @fires Hooks#persistentStateSave + */ + + }, { + key: "saveManualColumnWidths", + value: function saveManualColumnWidths() { + this.hot.runHooks('persistentStateSave', PERSISTENT_STATE_KEY$1, this.columnWidthsMap.getValues()); + } + /** + * Loads the previously saved sizes using the persistentState plugin (the {@link Options#persistentState} option has to be enabled). + * + * @returns {Array} + * @fires Hooks#persistentStateLoad + */ + + }, { + key: "loadManualColumnWidths", + value: function loadManualColumnWidths() { + var storedState = {}; + this.hot.runHooks('persistentStateLoad', PERSISTENT_STATE_KEY$1, storedState); + return storedState.value; + } + /** + * Sets the new width for specified column index. + * + * @param {number} column Visual column index. + * @param {number} width Column width (no less than 20px). + * @returns {number} Returns new width. + */ + + }, { + key: "setManualSize", + value: function setManualSize(column, width) { + var newWidth = Math.max(width, 20); + var physicalColumn = this.hot.toPhysicalColumn(column); + this.columnWidthsMap.setValueAtIndex(physicalColumn, newWidth); + return newWidth; + } + /** + * Clears the cache for the specified column index. + * + * @param {number} column Visual column index. + */ + + }, { + key: "clearManualSize", + value: function clearManualSize(column) { + var physicalColumn = this.hot.toPhysicalColumn(column); + this.columnWidthsMap.setValueAtIndex(physicalColumn, null); + } + /** + * Callback to call on map's `init` local hook. + * + * @private + */ + + }, { + key: "onMapInit", + value: function onMapInit() { + var _this3 = this; + + var priv = privatePool$c.get(this); + var initialSetting = this.hot.getSettings()[PLUGIN_KEY$e]; + var loadedManualColumnWidths = this.loadManualColumnWidths(); + + if (typeof loadedManualColumnWidths !== 'undefined') { + this.hot.batchExecution(function () { + loadedManualColumnWidths.forEach(function (width, physicalIndex) { + _this3.columnWidthsMap.setValueAtIndex(physicalIndex, width); + }); + }, true); + } else if (Array.isArray(initialSetting)) { + this.hot.batchExecution(function () { + initialSetting.forEach(function (width, physicalIndex) { + _this3.columnWidthsMap.setValueAtIndex(physicalIndex, width); + }); + }, true); + priv.config = initialSetting; + } else if (initialSetting === true && Array.isArray(priv.config)) { + this.hot.batchExecution(function () { + priv.config.forEach(function (width, physicalIndex) { + _this3.columnWidthsMap.setValueAtIndex(physicalIndex, width); + }); + }, true); + } + } + /** + * Set the resize handle position. + * + * @private + * @param {HTMLCellElement} TH TH HTML element. + */ + + }, { + key: "setupHandlePosition", + value: function setupHandlePosition(TH) { + var _this4 = this; + + if (!TH.parentNode) { + return; + } + + this.currentTH = TH; + var wt = this.hot.view.wt; + var cellCoords = wt.wtTable.getCoords(this.currentTH); + var col = cellCoords.col; // Ignore column headers. + + if (col < 0) { + return; + } + + var headerHeight = outerHeight(this.currentTH); + var box = this.currentTH.getBoundingClientRect(); // Read "fixedColumnsLeft" through the Walkontable as in that context, the fixed columns + // are modified (reduced by the number of hidden columns) by TableView module. + + var fixedColumn = col < wt.getSetting('fixedColumnsLeft'); + var relativeHeaderPosition; + + if (fixedColumn) { + relativeHeaderPosition = wt.wtOverlays.topLeftCornerOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col); + } // If the TH is not a child of the top-left overlay, recalculate using + // the top overlay - as this overlay contains the rest of the headers. + + + if (!relativeHeaderPosition) { + relativeHeaderPosition = wt.wtOverlays.topOverlay.getRelativeCellPosition(this.currentTH, cellCoords.row, cellCoords.col); + } + + this.currentCol = this.hot.columnIndexMapper.getVisualFromRenderableIndex(col); + this.selectedCols = []; + var isFullColumnSelected = this.hot.selection.isSelectedByCorner() || this.hot.selection.isSelectedByColumnHeader(); + + if (this.hot.selection.isSelected() && isFullColumnSelected) { + var selectionRanges = this.hot.getSelectedRange(); + arrayEach(selectionRanges, function (selectionRange) { + var fromColumn = selectionRange.getTopLeftCorner().col; + var toColumn = selectionRange.getBottomRightCorner().col; // Add every selected column for resize action. + + rangeEach(fromColumn, toColumn, function (columnIndex) { + if (!_this4.selectedCols.includes(columnIndex)) { + _this4.selectedCols.push(columnIndex); + } + }); + }); + } // Resizing element beyond the current selection (also when there is no selection). + + + if (!this.selectedCols.includes(this.currentCol)) { + this.selectedCols = [this.currentCol]; + } + + this.startOffset = relativeHeaderPosition.left - 6; + this.startWidth = parseInt(box.width, 10); + this.handle.style.top = "".concat(relativeHeaderPosition.top, "px"); + this.handle.style.left = "".concat(this.startOffset + this.startWidth, "px"); + this.handle.style.height = "".concat(headerHeight, "px"); + this.hot.rootElement.appendChild(this.handle); + } + /** + * Refresh the resize handle position. + * + * @private + */ + + }, { + key: "refreshHandlePosition", + value: function refreshHandlePosition() { + this.handle.style.left = "".concat(this.startOffset + this.currentWidth, "px"); + } + /** + * Sets the resize guide position. + * + * @private + */ + + }, { + key: "setupGuidePosition", + value: function setupGuidePosition() { + var handleHeight = parseInt(outerHeight(this.handle), 10); + var handleBottomPosition = parseInt(this.handle.style.top, 10) + handleHeight; + var maximumVisibleElementHeight = parseInt(this.hot.view.maximumVisibleElementHeight(0), 10); + addClass(this.handle, 'active'); + addClass(this.guide, 'active'); + this.guide.style.top = "".concat(handleBottomPosition, "px"); + this.guide.style.left = this.handle.style.left; + this.guide.style.height = "".concat(maximumVisibleElementHeight - handleHeight, "px"); + this.hot.rootElement.appendChild(this.guide); + } + /** + * Refresh the resize guide position. + * + * @private + */ + + }, { + key: "refreshGuidePosition", + value: function refreshGuidePosition() { + this.guide.style.left = this.handle.style.left; + } + /** + * Hides both the resize handle and resize guide. + * + * @private + */ + + }, { + key: "hideHandleAndGuide", + value: function hideHandleAndGuide() { + removeClass(this.handle, 'active'); + removeClass(this.guide, 'active'); + } + /** + * Checks if provided element is considered a column header. + * + * @private + * @param {HTMLElement} element HTML element. + * @returns {boolean} + */ + + }, { + key: "checkIfColumnHeader", + value: function checkIfColumnHeader(element) { + return !!closest(element, ['THEAD'], this.hot.rootElement); + } + /** + * Gets the TH element from the provided element. + * + * @private + * @param {HTMLElement} element HTML element. + * @returns {HTMLElement} + */ + + }, { + key: "getClosestTHParent", + value: function getClosestTHParent(element) { + if (element.tagName !== 'TABLE') { + if (element.tagName === 'TH') { + return element; + } + + return this.getClosestTHParent(element.parentNode); + } + + return null; + } + /** + * 'mouseover' event callback - set the handle position. + * + * @private + * @param {MouseEvent} event The mouse event. + */ + + }, { + key: "onMouseOver", + value: function onMouseOver(event) { + // Workaround for #6926 - if the `event.target` is temporarily detached, we can skip this callback and wait for + // the next `onmouseover`. + if (isDetached(event.target)) { + return; + } + + if (this.checkIfColumnHeader(event.target)) { + var th = this.getClosestTHParent(event.target); + + if (!th) { + return; + } + + var colspan = th.getAttribute('colspan'); + + if (th && (colspan === null || colspan === 1)) { + if (!this.pressed) { + this.setupHandlePosition(th); + } + } + } + } + /** + * Auto-size row after doubleclick - callback. + * + * @private + * @fires Hooks#beforeColumnResize + * @fires Hooks#afterColumnResize + */ + + }, { + key: "afterMouseDownTimeout", + value: function afterMouseDownTimeout() { + var _this5 = this; + + var render = function render() { + _this5.hot.forceFullRender = true; + + _this5.hot.view.render(); // updates all + + + _this5.hot.view.adjustElementsSize(true); + }; + + var resize = function resize(column, forceRender) { + var hookNewSize = _this5.hot.runHooks('beforeColumnResize', _this5.newSize, column, true); + + if (hookNewSize !== void 0) { + _this5.newSize = hookNewSize; + } + + if (_this5.hot.getSettings().stretchH === 'all') { + _this5.clearManualSize(column); + } else { + _this5.setManualSize(column, _this5.newSize); // double click sets by auto row size plugin + + } + + _this5.saveManualColumnWidths(); + + _this5.hot.runHooks('afterColumnResize', _this5.newSize, column, true); + + if (forceRender) { + render(); + } + }; + + if (this.dblclick >= 2) { + var selectedColsLength = this.selectedCols.length; + + if (selectedColsLength > 1) { + arrayEach(this.selectedCols, function (selectedCol) { + resize(selectedCol); + }); + render(); + } else { + arrayEach(this.selectedCols, function (selectedCol) { + resize(selectedCol, true); + }); + } + } + + this.dblclick = 0; + this.autoresizeTimeout = null; + } + /** + * 'mousedown' event callback. + * + * @private + * @param {MouseEvent} event The mouse event. + */ + + }, { + key: "onMouseDown", + value: function onMouseDown(event) { + var _this6 = this; + + if (hasClass(event.target, 'manualColumnResizer')) { + this.setupHandlePosition(this.currentTH); + this.setupGuidePosition(); + this.pressed = true; + + if (this.autoresizeTimeout === null) { + this.autoresizeTimeout = setTimeout(function () { + return _this6.afterMouseDownTimeout(); + }, 500); + + this.hot._registerTimeout(this.autoresizeTimeout); + } + + this.dblclick += 1; + this.startX = event.pageX; + this.newSize = this.startWidth; + } + } + /** + * 'mousemove' event callback - refresh the handle and guide positions, cache the new column width. + * + * @private + * @param {MouseEvent} event The mouse event. + */ + + }, { + key: "onMouseMove", + value: function onMouseMove(event) { + var _this7 = this; + + if (this.pressed) { + this.currentWidth = this.startWidth + (event.pageX - this.startX); + arrayEach(this.selectedCols, function (selectedCol) { + _this7.newSize = _this7.setManualSize(selectedCol, _this7.currentWidth); + }); + this.refreshHandlePosition(); + this.refreshGuidePosition(); + } + } + /** + * 'mouseup' event callback - apply the column resizing. + * + * @private + * + * @fires Hooks#beforeColumnResize + * @fires Hooks#afterColumnResize + */ + + }, { + key: "onMouseUp", + value: function onMouseUp() { + var _this8 = this; + + var render = function render() { + _this8.hot.forceFullRender = true; + + _this8.hot.view.render(); // updates all + + + _this8.hot.view.adjustElementsSize(true); + }; + + var resize = function resize(column, forceRender) { + _this8.hot.runHooks('beforeColumnResize', _this8.newSize, column, false); + + if (forceRender) { + render(); + } + + _this8.saveManualColumnWidths(); + + _this8.hot.runHooks('afterColumnResize', _this8.newSize, column, false); + }; + + if (this.pressed) { + this.hideHandleAndGuide(); + this.pressed = false; + + if (this.newSize !== this.startWidth) { + var selectedColsLength = this.selectedCols.length; + + if (selectedColsLength > 1) { + arrayEach(this.selectedCols, function (selectedCol) { + resize(selectedCol); + }); + render(); + } else { + arrayEach(this.selectedCols, function (selectedCol) { + resize(selectedCol, true); + }); + } + } + + this.setupHandlePosition(this.currentTH); + } + } + /** + * Binds the mouse events. + * + * @private + */ + + }, { + key: "bindEvents", + value: function bindEvents() { + var _this9 = this; + + var _this$hot = this.hot, + rootWindow = _this$hot.rootWindow, + rootElement = _this$hot.rootElement; + this.eventManager.addEventListener(rootElement, 'mouseover', function (e) { + return _this9.onMouseOver(e); + }); + this.eventManager.addEventListener(rootElement, 'mousedown', function (e) { + return _this9.onMouseDown(e); + }); + this.eventManager.addEventListener(rootWindow, 'mousemove', function (e) { + return _this9.onMouseMove(e); + }); + this.eventManager.addEventListener(rootWindow, 'mouseup', function () { + return _this9.onMouseUp(); + }); + } + /** + * Modifies the provided column width, based on the plugin settings. + * + * @private + * @param {number} width Column width. + * @param {number} column Visual column index. + * @returns {number} + */ + + }, { + key: "onModifyColWidth", + value: function onModifyColWidth(width, column) { + var newWidth = width; + + if (this.enabled) { + var physicalColumn = this.hot.toPhysicalColumn(column); + var columnWidth = this.columnWidthsMap.getValueAtIndex(physicalColumn); + + if (this.hot.getSettings()[PLUGIN_KEY$e] && columnWidth) { + newWidth = columnWidth; + } + } + + return newWidth; + } + /** + * Modifies the provided column stretched width. This hook decides if specified column should be stretched or not. + * + * @private + * @param {number} stretchedWidth Stretched width. + * @param {number} column Visual column index. + * @returns {number} + */ + + }, { + key: "onBeforeStretchingColumnWidth", + value: function onBeforeStretchingColumnWidth(stretchedWidth, column) { + var width = this.columnWidthsMap.getValueAtIndex(column); + + if (width === null) { + width = stretchedWidth; + } + + return width; + } + /** + * `beforeColumnResize` hook callback. + * + * @private + */ + + }, { + key: "onBeforeColumnResize", + value: function onBeforeColumnResize() { + // clear the header height cache information + this.hot.view.wt.wtViewport.resetHasOversizedColumnHeadersMarked(); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.columnIndexMapper.unregisterMap(this.pluginName); + + _get$q(_getPrototypeOf$N(ManualColumnResize.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$e; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$d; + } + }]); + + return ManualColumnResize; +}(BasePlugin); + +function _classCallCheck$1K(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1E(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); } } + +function _createClass$1E(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1E(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1E(Constructor, staticProps); return Constructor; } + +var STATE_INITIALIZED$1 = 0; +var STATE_BUILT$1 = 1; +var STATE_APPENDED$1 = 2; +var UNIT$1 = 'px'; +/** + * @class + * @private + */ + +var BaseUI$1 = /*#__PURE__*/function () { + function BaseUI(hotInstance) { + _classCallCheck$1K(this, BaseUI); + + /** + * Instance of Handsontable. + * + * @type {Core} + */ + this.hot = hotInstance; + /** + * DOM element representing the ui element. + * + * @type {HTMLElement} + * @private + */ + + this._element = null; + /** + * Flag which determines build state of element. + * + * @type {boolean} + */ + + this.state = STATE_INITIALIZED$1; + } + /** + * Add created UI elements to table. + * + * @param {HTMLElement} wrapper Element which are parent for our UI element. + */ + + + _createClass$1E(BaseUI, [{ + key: "appendTo", + value: function appendTo(wrapper) { + wrapper.appendChild(this._element); + this.state = STATE_APPENDED$1; + } + /** + * Method for create UI element. Only create, without append to table. + */ + + }, { + key: "build", + value: function build() { + if (this.state !== STATE_INITIALIZED$1) { + return; + } + + this._element = this.hot.rootDocument.createElement('div'); + this.state = STATE_BUILT$1; + } + /** + * Method for remove UI element. + */ + + }, { + key: "destroy", + value: function destroy() { + if (this.isAppended()) { + this._element.parentElement.removeChild(this._element); + } + + this._element = null; + this.state = STATE_INITIALIZED$1; + } + /** + * Check if UI element are appended. + * + * @returns {boolean} + */ + + }, { + key: "isAppended", + value: function isAppended() { + return this.state === STATE_APPENDED$1; + } + /** + * Check if UI element are built. + * + * @returns {boolean} + */ + + }, { + key: "isBuilt", + value: function isBuilt() { + return this.state >= STATE_BUILT$1; + } + /** + * Setter for position. + * + * @param {number} top New top position of the element. + * @param {number} left New left position of the element. + */ + + }, { + key: "setPosition", + value: function setPosition(top, left) { + if (top !== void 0) { + this._element.style.top = top + UNIT$1; + } + + if (left !== void 0) { + this._element.style.left = left + UNIT$1; + } + } + /** + * Getter for the element position. + * + * @returns {object} Object contains left and top position of the element. + */ + + }, { + key: "getPosition", + value: function getPosition() { + return { + top: this._element.style.top ? parseInt(this._element.style.top, 10) : 0, + left: this._element.style.left ? parseInt(this._element.style.left, 10) : 0 + }; + } + /** + * Setter for the element size. + * + * @param {number} width New width of the element. + * @param {number} height New height of the element. + */ + + }, { + key: "setSize", + value: function setSize(width, height) { + if (width) { + this._element.style.width = width + UNIT$1; + } + + if (height) { + this._element.style.height = height + UNIT$1; + } + } + /** + * Getter for the element position. + * + * @returns {object} Object contains height and width of the element. + */ + + }, { + key: "getSize", + value: function getSize() { + return { + width: this._element.style.width ? parseInt(this._element.style.width, 10) : 0, + height: this._element.style.height ? parseInt(this._element.style.height, 10) : 0 + }; + } + /** + * Setter for the element offset. Offset means marginTop and marginLeft of the element. + * + * @param {number} top New margin top of the element. + * @param {number} left New margin left of the element. + */ + + }, { + key: "setOffset", + value: function setOffset(top, left) { + if (top) { + this._element.style.marginTop = top + UNIT$1; + } + + if (left) { + this._element.style.marginLeft = left + UNIT$1; + } + } + /** + * Getter for the element offset. + * + * @returns {object} Object contains top and left offset of the element. + */ + + }, { + key: "getOffset", + value: function getOffset() { + return { + top: this._element.style.marginTop ? parseInt(this._element.style.marginTop, 10) : 0, + left: this._element.style.marginLeft ? parseInt(this._element.style.marginLeft, 10) : 0 + }; + } + }]); + + return BaseUI; +}(); + +function _typeof$Z(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$Z = function _typeof(obj) { return typeof obj; }; } else { _typeof$Z = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$Z(obj); } + +function _classCallCheck$1L(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1F(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); } } + +function _createClass$1F(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1F(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1F(Constructor, staticProps); return Constructor; } + +function _get$r(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$r = Reflect.get; } else { _get$r = function _get(target, property, receiver) { var base = _superPropBase$r(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$r(target, property, receiver || target); } + +function _superPropBase$r(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$O(object); if (object === null) break; } return object; } + +function _inherits$O(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$P(subClass, superClass); } + +function _setPrototypeOf$P(o, p) { _setPrototypeOf$P = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$P(o, p); } + +function _createSuper$O(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$P(); return function _createSuperInternal() { var Super = _getPrototypeOf$O(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$O(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$O(this, result); }; } + +function _possibleConstructorReturn$O(self, call) { if (call && (_typeof$Z(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$O(self); } + +function _assertThisInitialized$O(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$P() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$O(o) { _getPrototypeOf$O = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$O(o); } +var CSS_CLASSNAME$2 = 'ht__manualRowMove--backlight'; +/** + * @class BacklightUI + * @util + */ + +var BacklightUI$1 = /*#__PURE__*/function (_BaseUI) { + _inherits$O(BacklightUI, _BaseUI); + + var _super = _createSuper$O(BacklightUI); + + function BacklightUI() { + _classCallCheck$1L(this, BacklightUI); + + return _super.apply(this, arguments); + } + + _createClass$1F(BacklightUI, [{ + key: "build", + value: + /** + * Custom className on build process. + */ + function build() { + _get$r(_getPrototypeOf$O(BacklightUI.prototype), "build", this).call(this); + + addClass(this._element, CSS_CLASSNAME$2); + } + }]); + + return BacklightUI; +}(BaseUI$1); + +function _typeof$_(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$_ = function _typeof(obj) { return typeof obj; }; } else { _typeof$_ = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$_(obj); } + +function _classCallCheck$1M(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1G(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); } } + +function _createClass$1G(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1G(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1G(Constructor, staticProps); return Constructor; } + +function _get$s(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$s = Reflect.get; } else { _get$s = function _get(target, property, receiver) { var base = _superPropBase$s(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$s(target, property, receiver || target); } + +function _superPropBase$s(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$P(object); if (object === null) break; } return object; } + +function _inherits$P(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$Q(subClass, superClass); } + +function _setPrototypeOf$Q(o, p) { _setPrototypeOf$Q = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$Q(o, p); } + +function _createSuper$P(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$Q(); return function _createSuperInternal() { var Super = _getPrototypeOf$P(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$P(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$P(this, result); }; } + +function _possibleConstructorReturn$P(self, call) { if (call && (_typeof$_(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$P(self); } + +function _assertThisInitialized$P(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$Q() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$P(o) { _getPrototypeOf$P = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$P(o); } +var CSS_CLASSNAME$3 = 'ht__manualRowMove--guideline'; +/** + * @class GuidelineUI + * @util + */ + +var GuidelineUI$1 = /*#__PURE__*/function (_BaseUI) { + _inherits$P(GuidelineUI, _BaseUI); + + var _super = _createSuper$P(GuidelineUI); + + function GuidelineUI() { + _classCallCheck$1M(this, GuidelineUI); + + return _super.apply(this, arguments); + } + + _createClass$1G(GuidelineUI, [{ + key: "build", + value: + /** + * Custom className on build process. + */ + function build() { + _get$s(_getPrototypeOf$P(GuidelineUI.prototype), "build", this).call(this); + + addClass(this._element, CSS_CLASSNAME$3); + } + }]); + + return GuidelineUI; +}(BaseUI$1); + +function _typeof$$(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$$ = function _typeof(obj) { return typeof obj; }; } else { _typeof$$ = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$$(obj); } + +function _classCallCheck$1N(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1H(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); } } + +function _createClass$1H(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1H(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1H(Constructor, staticProps); return Constructor; } + +function _get$t(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$t = Reflect.get; } else { _get$t = function _get(target, property, receiver) { var base = _superPropBase$t(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$t(target, property, receiver || target); } + +function _superPropBase$t(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$Q(object); if (object === null) break; } return object; } + +function _inherits$Q(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$R(subClass, superClass); } + +function _setPrototypeOf$R(o, p) { _setPrototypeOf$R = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$R(o, p); } + +function _createSuper$Q(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$R(); return function _createSuperInternal() { var Super = _getPrototypeOf$Q(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$Q(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$Q(this, result); }; } + +function _possibleConstructorReturn$Q(self, call) { if (call && (_typeof$$(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$Q(self); } + +function _assertThisInitialized$Q(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$R() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$Q(o) { _getPrototypeOf$Q = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$Q(o); } +Hooks.getSingleton().register('beforeRowMove'); +Hooks.getSingleton().register('afterRowMove'); +var PLUGIN_KEY$f = 'manualRowMove'; +var PLUGIN_PRIORITY$e = 140; +var privatePool$d = new WeakMap(); +var CSS_PLUGIN$1 = 'ht__manualRowMove'; +var CSS_SHOW_UI$1 = 'show-ui'; +var CSS_ON_MOVING$1 = 'on-moving--rows'; +var CSS_AFTER_SELECTION$1 = 'after-selection--rows'; +/** + * @plugin ManualRowMove + * + * @description + * This plugin allows to change rows order. To make rows order persistent the {@link Options#persistentState} + * plugin should be enabled. + * + * API: + * - `moveRow` - move single row to the new position. + * - `moveRows` - move many rows (as an array of indexes) to the new position. + * - `dragRow` - drag single row to the new position. + * - `dragRows` - drag many rows (as an array of indexes) to the new position. + * + * [Documentation](/docs/demo-moving.html) explain differences between drag and move actions. Please keep in mind that if you want apply visual changes, + * you have to call manually the `render` method on the instance of Handsontable. + * + * The plugin creates additional components to make moving possibly using user interface: + * - backlight - highlight of selected rows. + * - guideline - line which shows where rows has been moved. + * + * @class ManualRowMove + * @plugin ManualRowMove + */ + +var ManualRowMove = /*#__PURE__*/function (_BasePlugin) { + _inherits$Q(ManualRowMove, _BasePlugin); + + var _super = _createSuper$Q(ManualRowMove); + + function ManualRowMove(hotInstance) { + var _this; + + _classCallCheck$1N(this, ManualRowMove); + + _this = _super.call(this, hotInstance); + /** + * Set up WeakMap of plugin to sharing private parameters;. + */ + + privatePool$d.set(_assertThisInitialized$Q(_this), { + rowsToMove: [], + pressed: void 0, + target: { + eventPageY: void 0, + coords: void 0, + TD: void 0, + row: void 0 + }, + cachedDropIndex: void 0 + }); + /** + * Event Manager object. + * + * @private + * @type {object} + */ + + _this.eventManager = new EventManager(_assertThisInitialized$Q(_this)); + /** + * Backlight UI object. + * + * @private + * @type {object} + */ + + _this.backlight = new BacklightUI$1(hotInstance); + /** + * Guideline UI object. + * + * @private + * @type {object} + */ + + _this.guideline = new GuidelineUI$1(hotInstance); + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ManualRowMove#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1H(ManualRowMove, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$f]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.addHook('beforeOnCellMouseDown', function (event, coords, TD, blockCalculations) { + return _this2.onBeforeOnCellMouseDown(event, coords, TD, blockCalculations); + }); + this.addHook('beforeOnCellMouseOver', function (event, coords, TD, blockCalculations) { + return _this2.onBeforeOnCellMouseOver(event, coords, TD, blockCalculations); + }); + this.addHook('afterScrollHorizontally', function () { + return _this2.onAfterScrollHorizontally(); + }); + this.addHook('afterLoadData', function () { + return _this2.onAfterLoadData(); + }); + this.buildPluginUI(); + this.registerEvents(); // TODO: move adding plugin classname to BasePlugin. + + addClass(this.hot.rootElement, CSS_PLUGIN$1); + + _get$t(_getPrototypeOf$Q(ManualRowMove.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + this.moveBySettingsOrLoad(); + + _get$t(_getPrototypeOf$Q(ManualRowMove.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + removeClass(this.hot.rootElement, CSS_PLUGIN$1); + this.unregisterEvents(); + this.backlight.destroy(); + this.guideline.destroy(); + + _get$t(_getPrototypeOf$Q(ManualRowMove.prototype), "disablePlugin", this).call(this); + } + /** + * Moves a single row. + * + * @param {number} row Visual row index to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements will be placed after the moving action. + * To check the visualization of the final index, please take a look at [documentation](/docs/demo-moving.html). + * @fires Hooks#beforeRowMove + * @fires Hooks#afterRowMove + * @returns {boolean} + */ + + }, { + key: "moveRow", + value: function moveRow(row, finalIndex) { + return this.moveRows([row], finalIndex); + } + /** + * Moves a multiple rows. + * + * @param {Array} rows Array of visual row indexes to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements will be placed after the moving action. + * To check the visualization of the final index, please take a look at [documentation](/docs/demo-moving.html). + * @fires Hooks#beforeRowMove + * @fires Hooks#afterRowMove + * @returns {boolean} + */ + + }, { + key: "moveRows", + value: function moveRows(rows, finalIndex) { + var priv = privatePool$d.get(this); + var dropIndex = priv.cachedDropIndex; + var movePossible = this.isMovePossible(rows, finalIndex); + var beforeMoveHook = this.hot.runHooks('beforeRowMove', rows, finalIndex, dropIndex, movePossible); + priv.cachedDropIndex = void 0; + + if (beforeMoveHook === false) { + return; + } + + if (movePossible) { + this.hot.rowIndexMapper.moveIndexes(rows, finalIndex); + } + + var movePerformed = movePossible && this.isRowOrderChanged(rows, finalIndex); + this.hot.runHooks('afterRowMove', rows, finalIndex, dropIndex, movePossible, movePerformed); + return movePerformed; + } + /** + * Drag a single row to drop index position. + * + * @param {number} row Visual row index to be dragged. + * @param {number} dropIndex Visual row index, being a drop index for the moved rows. Points to where we are going to drop the moved elements. + * To check visualization of drop index please take a look at [documentation](/docs/demo-moving.html). + * @fires Hooks#beforeRowMove + * @fires Hooks#afterRowMove + * @returns {boolean} + */ + + }, { + key: "dragRow", + value: function dragRow(row, dropIndex) { + return this.dragRows([row], dropIndex); + } + /** + * Drag multiple rows to drop index position. + * + * @param {Array} rows Array of visual row indexes to be dragged. + * @param {number} dropIndex Visual row index, being a drop index for the moved rows. Points to where we are going to drop the moved elements. + * To check visualization of drop index please take a look at [documentation](/docs/demo-moving.html). + * @fires Hooks#beforeRowMove + * @fires Hooks#afterRowMove + * @returns {boolean} + */ + + }, { + key: "dragRows", + value: function dragRows(rows, dropIndex) { + var finalIndex = this.countFinalIndex(rows, dropIndex); + var priv = privatePool$d.get(this); + priv.cachedDropIndex = dropIndex; + return this.moveRows(rows, finalIndex); + } + /** + * Indicates if it's possible to move rows to the desired position. Some of the actions aren't possible, i.e. You can’t move more than one element to the last position. + * + * @param {Array} movedRows Array of visual row indexes to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements will be placed after the moving action. + * To check the visualization of the final index, please take a look at [documentation](/docs/demo-moving.html). + * @returns {boolean} + */ + + }, { + key: "isMovePossible", + value: function isMovePossible(movedRows, finalIndex) { + var length = this.hot.rowIndexMapper.getNotTrimmedIndexesLength(); // An attempt to transfer more rows to start destination than is possible (only when moving from the top to the bottom). + + var tooHighDestinationIndex = movedRows.length + finalIndex > length; + var tooLowDestinationIndex = finalIndex < 0; + var tooLowMovedRowIndex = movedRows.some(function (movedRow) { + return movedRow < 0; + }); + var tooHighMovedRowIndex = movedRows.some(function (movedRow) { + return movedRow >= length; + }); + + if (tooHighDestinationIndex || tooLowDestinationIndex || tooLowMovedRowIndex || tooHighMovedRowIndex) { + return false; + } + + return true; + } + /** + * Indicates if order of rows was changed. + * + * @private + * @param {Array} movedRows Array of visual row indexes to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements will be placed after the moving action. + * To check the visualization of the final index, please take a look at [documentation](/docs/demo-moving.html). + * @returns {boolean} + */ + + }, { + key: "isRowOrderChanged", + value: function isRowOrderChanged(movedRows, finalIndex) { + return movedRows.some(function (row, nrOfMovedElement) { + return row - nrOfMovedElement !== finalIndex; + }); + } + /** + * Count the final row index from the drop index. + * + * @private + * @param {Array} movedRows Array of visual row indexes to be moved. + * @param {number} dropIndex Visual row index, being a drop index for the moved rows. + * @returns {number} Visual row index, being a start index for the moved rows. + */ + + }, { + key: "countFinalIndex", + value: function countFinalIndex(movedRows, dropIndex) { + var numberOfRowsLowerThanDropIndex = arrayReduce(movedRows, function (numberOfRows, currentRowIndex) { + if (currentRowIndex < dropIndex) { + numberOfRows += 1; + } + + return numberOfRows; + }, 0); + return dropIndex - numberOfRowsLowerThanDropIndex; + } + /** + * Gets the sum of the heights of rows in the provided range. + * + * @private + * @param {number} fromRow Visual row index. + * @param {number} toRow Visual row index. + * @returns {number} + */ + + }, { + key: "getRowsHeight", + value: function getRowsHeight(fromRow, toRow) { + var rowMapper = this.hot.rowIndexMapper; + var rowsHeight = 0; + + for (var visualRowIndex = fromRow; visualRowIndex <= toRow; visualRowIndex++) { + var renderableIndex = rowMapper.getRenderableFromVisualIndex(visualRowIndex); + + if (renderableIndex !== null) { + rowsHeight += this.hot.view.wt.wtTable.getRowHeight(renderableIndex) || 23; + } + } + + return rowsHeight; + } + /** + * Loads initial settings when persistent state is saved or when plugin was initialized as an array. + * + * @private + */ + + }, { + key: "moveBySettingsOrLoad", + value: function moveBySettingsOrLoad() { + var pluginSettings = this.hot.getSettings()[PLUGIN_KEY$f]; + + if (Array.isArray(pluginSettings)) { + this.moveRows(pluginSettings, 0); + } else if (pluginSettings !== void 0) { + var persistentState = this.persistentStateLoad(); + + if (persistentState.length) { + this.moveRows(persistentState, 0); + } + } + } + /** + * Checks if the provided row is in the fixedRowsTop section. + * + * @private + * @param {number} row Visual row index to check. + * @returns {boolean} + */ + + }, { + key: "isFixedRowTop", + value: function isFixedRowTop(row) { + return row < this.hot.getSettings().fixedRowsTop; + } + /** + * Checks if the provided row is in the fixedRowsBottom section. + * + * @private + * @param {number} row Visual row index to check. + * @returns {boolean} + */ + + }, { + key: "isFixedRowBottom", + value: function isFixedRowBottom(row) { + return row > this.hot.getSettings().fixedRowsBottom; + } + /** + * Saves the manual row positions to the persistent state (the {@link Options#persistentState} option has to be enabled). + * + * @private + * @fires Hooks#persistentStateSave + */ + + }, { + key: "persistentStateSave", + value: function persistentStateSave() { + // The `PersistentState` plugin should be refactored. + this.hot.runHooks('persistentStateSave', 'manualRowMove', this.hot.rowIndexMapper.getIndexesSequence()); + } + /** + * Loads the manual row positions from the persistent state (the {@link Options#persistentState} option has to be enabled). + * + * @private + * @fires Hooks#persistentStateLoad + * @returns {Array} Stored state. + */ + + }, { + key: "persistentStateLoad", + value: function persistentStateLoad() { + var storedState = {}; + this.hot.runHooks('persistentStateLoad', 'manualRowMove', storedState); + return storedState.value ? storedState.value : []; + } + /** + * Prepares an array of indexes based on actual selection. + * + * @private + * @returns {Array} + */ + + }, { + key: "prepareRowsToMoving", + value: function prepareRowsToMoving() { + var selection = this.hot.getSelectedRangeLast(); + var selectedRows = []; + + if (!selection) { + return selectedRows; + } + + var from = selection.from, + to = selection.to; + var start = Math.min(from.row, to.row); + var end = Math.max(from.row, to.row); + rangeEach(start, end, function (i) { + selectedRows.push(i); + }); + return selectedRows; + } + /** + * Update the UI visual position. + * + * @private + */ + + }, { + key: "refreshPositions", + value: function refreshPositions() { + var priv = privatePool$d.get(this); + var coords = priv.target.coords; + var firstVisible = this.hot.view.wt.wtTable.getFirstVisibleRow(); + var lastVisible = this.hot.view.wt.wtTable.getLastVisibleRow(); + var fixedRows = this.hot.getSettings().fixedRowsTop; + var countRows = this.hot.countRows(); + + if (coords.row < fixedRows && firstVisible > 0) { + this.hot.scrollViewportTo(firstVisible - 1); + } + + if (coords.row >= lastVisible && lastVisible < countRows) { + this.hot.scrollViewportTo(lastVisible + 1, undefined, true); + } + + var wtTable = this.hot.view.wt.wtTable; + var TD = priv.target.TD; + var rootElementOffset = offset(this.hot.rootElement); + var tdOffsetTop = this.hot.view.THEAD.offsetHeight + this.getRowsHeight(0, coords.row - 1); + var mouseOffsetTop = priv.target.eventPageY - rootElementOffset.top + wtTable.holder.scrollTop; + var hiderHeight = wtTable.hider.offsetHeight; + var tbodyOffsetTop = wtTable.TBODY.offsetTop; + var backlightElemMarginTop = this.backlight.getOffset().top; + var backlightElemHeight = this.backlight.getSize().height; + + if (this.isFixedRowTop(coords.row)) { + tdOffsetTop += wtTable.holder.scrollTop; + } // todo: fixedRowsBottom + // if (this.isFixedRowBottom(coords.row)) { + // + // } + + + if (coords.row < 0) { + // if hover on colHeader + priv.target.row = firstVisible > 0 ? firstVisible - 1 : firstVisible; + } else if (TD.offsetHeight / 2 + tdOffsetTop <= mouseOffsetTop) { + // if hover on lower part of TD + priv.target.row = coords.row + 1; // unfortunately first row is bigger than rest + + tdOffsetTop += coords.row === 0 ? TD.offsetHeight - 1 : TD.offsetHeight; + } else { + // elsewhere on table + priv.target.row = coords.row; + } + + var backlightTop = mouseOffsetTop; + var guidelineTop = tdOffsetTop; + + if (mouseOffsetTop + backlightElemHeight + backlightElemMarginTop >= hiderHeight) { + // prevent display backlight below table + backlightTop = hiderHeight - backlightElemHeight - backlightElemMarginTop; + } else if (mouseOffsetTop + backlightElemMarginTop < tbodyOffsetTop) { + // prevent display above below table + backlightTop = tbodyOffsetTop + Math.abs(backlightElemMarginTop); + } + + if (tdOffsetTop >= hiderHeight - 1) { + // prevent display guideline below table + guidelineTop = hiderHeight - 1; + } + + var topOverlayHeight = 0; + + if (this.hot.view.wt.wtOverlays.topOverlay) { + topOverlayHeight = this.hot.view.wt.wtOverlays.topOverlay.clone.wtTable.TABLE.offsetHeight; + } + + if (coords.row >= fixedRows && guidelineTop - wtTable.holder.scrollTop < topOverlayHeight) { + this.hot.scrollViewportTo(coords.row); + } + + this.backlight.setPosition(backlightTop); + this.guideline.setPosition(guidelineTop); + } + /** + * Binds the events used by the plugin. + * + * @private + */ + + }, { + key: "registerEvents", + value: function registerEvents() { + var _this3 = this; + + var documentElement = this.hot.rootDocument.documentElement; + this.eventManager.addEventListener(documentElement, 'mousemove', function (event) { + return _this3.onMouseMove(event); + }); + this.eventManager.addEventListener(documentElement, 'mouseup', function () { + return _this3.onMouseUp(); + }); + } + /** + * Unbinds the events used by the plugin. + * + * @private + */ + + }, { + key: "unregisterEvents", + value: function unregisterEvents() { + this.eventManager.clear(); + } + /** + * Change the behavior of selection / dragging. + * + * @private + * @param {MouseEvent} event `mousedown` event properties. + * @param {CellCoords} coords Visual cell coordinates where was fired event. + * @param {HTMLElement} TD Cell represented as HTMLElement. + * @param {object} blockCalculations Object which contains information about blockCalculation for row, column or cells. + */ + + }, { + key: "onBeforeOnCellMouseDown", + value: function onBeforeOnCellMouseDown(event, coords, TD, blockCalculations) { + var _this$hot$view$wt = this.hot.view.wt, + wtTable = _this$hot$view$wt.wtTable, + wtViewport = _this$hot$view$wt.wtViewport; + var isHeaderSelection = this.hot.selection.isSelectedByRowHeader(); + var selection = this.hot.getSelectedRangeLast(); + var priv = privatePool$d.get(this); + + if (!selection || !isHeaderSelection || priv.pressed || event.button !== 0) { + priv.pressed = false; + priv.rowsToMove.length = 0; + removeClass(this.hot.rootElement, [CSS_ON_MOVING$1, CSS_SHOW_UI$1]); + return; + } + + var guidelineIsNotReady = this.guideline.isBuilt() && !this.guideline.isAppended(); + var backlightIsNotReady = this.backlight.isBuilt() && !this.backlight.isAppended(); + + if (guidelineIsNotReady && backlightIsNotReady) { + this.guideline.appendTo(wtTable.hider); + this.backlight.appendTo(wtTable.hider); + } + + var from = selection.from, + to = selection.to; + var start = Math.min(from.row, to.row); + var end = Math.max(from.row, to.row); + + if (coords.col < 0 && coords.row >= start && coords.row <= end) { + blockCalculations.row = true; + priv.pressed = true; + priv.target.eventPageY = event.pageY; + priv.target.coords = coords; + priv.target.TD = TD; + priv.rowsToMove = this.prepareRowsToMoving(); + var leftPos = wtTable.holder.scrollLeft + wtViewport.getRowHeaderWidth(); + this.backlight.setPosition(null, leftPos); + this.backlight.setSize(wtTable.hider.offsetWidth - leftPos, this.getRowsHeight(start, end)); + this.backlight.setOffset((this.getRowsHeight(start, coords.row - 1) + event.offsetY) * -1, null); + addClass(this.hot.rootElement, CSS_ON_MOVING$1); + this.refreshPositions(); + } else { + removeClass(this.hot.rootElement, CSS_AFTER_SELECTION$1); + priv.pressed = false; + priv.rowsToMove.length = 0; + } + } + /** + * 'mouseMove' event callback. Fired when pointer move on document.documentElement. + * + * @private + * @param {MouseEvent} event `mousemove` event properties. + */ + + }, { + key: "onMouseMove", + value: function onMouseMove(event) { + var priv = privatePool$d.get(this); + + if (!priv.pressed) { + return; + } // callback for browser which doesn't supports CSS pointer-event: none + + + if (event.target === this.backlight.element) { + var height = this.backlight.getSize().height; + this.backlight.setSize(null, 0); + setTimeout(function () { + this.backlight.setPosition(null, height); + }); + } + + priv.target.eventPageY = event.pageY; + this.refreshPositions(); + } + /** + * 'beforeOnCellMouseOver' hook callback. Fired when pointer was over cell. + * + * @private + * @param {MouseEvent} event `mouseover` event properties. + * @param {CellCoords} coords Visual cell coordinates where was fired event. + * @param {HTMLElement} TD Cell represented as HTMLElement. + * @param {object} blockCalculations Object which contains information about blockCalculation for row, column or cells. + */ + + }, { + key: "onBeforeOnCellMouseOver", + value: function onBeforeOnCellMouseOver(event, coords, TD, blockCalculations) { + var selectedRange = this.hot.getSelectedRangeLast(); + var priv = privatePool$d.get(this); + + if (!selectedRange || !priv.pressed) { + return; + } + + if (priv.rowsToMove.indexOf(coords.row) > -1) { + removeClass(this.hot.rootElement, CSS_SHOW_UI$1); + } else { + addClass(this.hot.rootElement, CSS_SHOW_UI$1); + } + + blockCalculations.row = true; + blockCalculations.column = true; + blockCalculations.cell = true; + priv.target.coords = coords; + priv.target.TD = TD; + } + /** + * `onMouseUp` hook callback. + * + * @private + */ + + }, { + key: "onMouseUp", + value: function onMouseUp() { + var priv = privatePool$d.get(this); + var target = priv.target.row; + var rowsLen = priv.rowsToMove.length; + priv.pressed = false; + priv.backlightHeight = 0; + removeClass(this.hot.rootElement, [CSS_ON_MOVING$1, CSS_SHOW_UI$1, CSS_AFTER_SELECTION$1]); + + if (this.hot.selection.isSelectedByRowHeader()) { + addClass(this.hot.rootElement, CSS_AFTER_SELECTION$1); + } + + if (rowsLen < 1 || target === void 0) { + return; + } + + var firstMovedVisualRow = priv.rowsToMove[0]; + var firstMovedPhysicalRow = this.hot.toPhysicalRow(firstMovedVisualRow); + var movePerformed = this.dragRows(priv.rowsToMove, target); + priv.rowsToMove.length = 0; + + if (movePerformed === true) { + this.persistentStateSave(); + this.hot.render(); + this.hot.view.adjustElementsSize(true); + var selectionStart = this.hot.toVisualRow(firstMovedPhysicalRow); + var selectionEnd = selectionStart + rowsLen - 1; + this.hot.selectRows(selectionStart, selectionEnd); + } + } + /** + * `afterScrollHorizontally` hook callback. Fired the table was scrolled horizontally. + * + * @private + */ + + }, { + key: "onAfterScrollHorizontally", + value: function onAfterScrollHorizontally() { + var wtTable = this.hot.view.wt.wtTable; + var headerWidth = this.hot.view.wt.wtViewport.getRowHeaderWidth(); + var scrollLeft = wtTable.holder.scrollLeft; + var posLeft = headerWidth + scrollLeft; + this.backlight.setPosition(null, posLeft); + this.backlight.setSize(wtTable.hider.offsetWidth - posLeft); + } + /** + * Builds the plugin's UI. + * + * @private + */ + + }, { + key: "buildPluginUI", + value: function buildPluginUI() { + this.backlight.build(); + this.guideline.build(); + } + /** + * Callback for the `afterLoadData` hook. + * + * @private + */ + + }, { + key: "onAfterLoadData", + value: function onAfterLoadData() { + this.moveBySettingsOrLoad(); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.backlight.destroy(); + this.guideline.destroy(); + + _get$t(_getPrototypeOf$Q(ManualRowMove.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$f; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$e; + } + }]); + + return ManualRowMove; +}(BasePlugin); + +var _templateObject$5, _templateObject2$1, _templateObject3$1, _templateObject4$1; + +function _taggedTemplateLiteral$5(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _classCallCheck$1O(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1I(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); } } + +function _createClass$1I(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1I(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1I(Constructor, staticProps); return Constructor; } +/** + * The `MergedCellCoords` class represents a single merged cell. + * + * @class MergedCellCoords + * @plugin MergeCells + */ + +var MergedCellCoords = /*#__PURE__*/function () { + function MergedCellCoords(row, column, rowspan, colspan) { + _classCallCheck$1O(this, MergedCellCoords); + + /** + * The index of the topmost merged cell row. + * + * @type {number} + */ + this.row = row; + /** + * The index of the leftmost column. + * + * @type {number} + */ + + this.col = column; + /** + * The `rowspan` value of the merged cell. + * + * @type {number} + */ + + this.rowspan = rowspan; + /** + * The `colspan` value of the merged cell. + * + * @type {number} + */ + + this.colspan = colspan; + /** + * `true` only if the merged cell is bound to be removed. + * + * @type {boolean} + */ + + this.removed = false; + } + /** + * Get a warning message for when the declared merged cell data contains negative values. + * + * @param {object} newMergedCell Object containg information about the merged cells that was about to be added. + * @returns {string} + */ + + + _createClass$1I(MergedCellCoords, [{ + key: "normalize", + value: + /** + * Sanitize (prevent from going outside the boundaries) the merged cell. + * + * @param {Core} hotInstance The Handsontable instance. + */ + function normalize(hotInstance) { + var totalRows = hotInstance.countRows(); + var totalColumns = hotInstance.countCols(); + + if (this.row < 0) { + this.row = 0; + } else if (this.row > totalRows - 1) { + this.row = totalRows - 1; + } + + if (this.col < 0) { + this.col = 0; + } else if (this.col > totalColumns - 1) { + this.col = totalColumns - 1; + } + + if (this.row + this.rowspan > totalRows - 1) { + this.rowspan = totalRows - this.row; + } + + if (this.col + this.colspan > totalColumns - 1) { + this.colspan = totalColumns - this.col; + } + } + /** + * Returns `true` if the provided coordinates are inside the merged cell. + * + * @param {number} row The row index. + * @param {number} column The column index. + * @returns {boolean} + */ + + }, { + key: "includes", + value: function includes(row, column) { + return this.row <= row && this.col <= column && this.row + this.rowspan - 1 >= row && this.col + this.colspan - 1 >= column; + } + /** + * Returns `true` if the provided `column` property is within the column span of the merged cell. + * + * @param {number} column The column index. + * @returns {boolean} + */ + + }, { + key: "includesHorizontally", + value: function includesHorizontally(column) { + return this.col <= column && this.col + this.colspan - 1 >= column; + } + /** + * Returns `true` if the provided `row` property is within the row span of the merged cell. + * + * @param {number} row Row index. + * @returns {boolean} + */ + + }, { + key: "includesVertically", + value: function includesVertically(row) { + return this.row <= row && this.row + this.rowspan - 1 >= row; + } + /** + * Shift (and possibly resize, if needed) the merged cell. + * + * @param {Array} shiftVector 2-element array containing the information on the shifting in the `x` and `y` axis. + * @param {number} indexOfChange Index of the preceding change. + * @returns {boolean} Returns `false` if the whole merged cell was removed. + */ + + }, { + key: "shift", + value: function shift(shiftVector, indexOfChange) { + var shiftValue = shiftVector[0] || shiftVector[1]; + var shiftedIndex = indexOfChange + Math.abs(shiftVector[0] || shiftVector[1]) - 1; + var span = shiftVector[0] ? 'colspan' : 'rowspan'; + var index = shiftVector[0] ? 'col' : 'row'; + var changeStart = Math.min(indexOfChange, shiftedIndex); + var changeEnd = Math.max(indexOfChange, shiftedIndex); + var mergeStart = this[index]; + var mergeEnd = this[index] + this[span] - 1; + + if (mergeStart >= indexOfChange) { + this[index] += shiftValue; + } // adding rows/columns + + + if (shiftValue > 0) { + if (indexOfChange <= mergeEnd && indexOfChange > mergeStart) { + this[span] += shiftValue; + } // removing rows/columns + + } else if (shiftValue < 0) { + // removing the whole merge + if (changeStart <= mergeStart && changeEnd >= mergeEnd) { + this.removed = true; + return false; // removing the merge partially, including the beginning + } else if (mergeStart >= changeStart && mergeStart <= changeEnd) { + var removedOffset = changeEnd - mergeStart + 1; + var preRemovedOffset = Math.abs(shiftValue) - removedOffset; + this[index] -= preRemovedOffset + shiftValue; + this[span] -= removedOffset; // removing the middle part of the merge + } else if (mergeStart <= changeStart && mergeEnd >= changeEnd) { + this[span] += shiftValue; // removing the end part of the merge + } else if (mergeStart <= changeStart && mergeEnd >= changeStart && mergeEnd < changeEnd) { + var removedPart = mergeEnd - changeStart + 1; + this[span] -= removedPart; + } + } + + return true; + } + /** + * Check if the second provided merged cell is "farther" in the provided direction. + * + * @param {MergedCellCoords} mergedCell The merged cell to check. + * @param {string} direction Drag direction. + * @returns {boolean|null} `true` if the second provided merged cell is "farther". + */ + + }, { + key: "isFarther", + value: function isFarther(mergedCell, direction) { + if (!mergedCell) { + return true; + } + + if (direction === 'down') { + return mergedCell.row + mergedCell.rowspan - 1 < this.row + this.rowspan - 1; + } else if (direction === 'up') { + return mergedCell.row > this.row; + } else if (direction === 'right') { + return mergedCell.col + mergedCell.colspan - 1 < this.col + this.colspan - 1; + } else if (direction === 'left') { + return mergedCell.col > this.col; + } + + return null; + } + /** + * Get the bottom row index of the merged cell. + * + * @returns {number} + */ + + }, { + key: "getLastRow", + value: function getLastRow() { + return this.row + this.rowspan - 1; + } + /** + * Get the rightmost column index of the merged cell. + * + * @returns {number} + */ + + }, { + key: "getLastColumn", + value: function getLastColumn() { + return this.col + this.colspan - 1; + } + /** + * Get the range coordinates of the merged cell. + * + * @returns {CellRange} + */ + + }, { + key: "getRange", + value: function getRange() { + return new CellRange(new CellCoords(this.row, this.col), new CellCoords(this.row, this.col), new CellCoords(this.getLastRow(), this.getLastColumn())); + } + }], [{ + key: "NEGATIVE_VALUES_WARNING", + value: function NEGATIVE_VALUES_WARNING(newMergedCell) { + return toSingleLine(_templateObject$5 || (_templateObject$5 = _taggedTemplateLiteral$5(["The merged cell declared with {row: ", ", col: ", ", \n rowspan: ", ", colspan: ", "} contains negative values, which is \n not supported. It will not be added to the collection."], ["The merged cell declared with {row: ", ", col: ", ",\\x20\n rowspan: ", ", colspan: ", "} contains negative values, which is\\x20\n not supported. It will not be added to the collection."])), newMergedCell.row, newMergedCell.col, newMergedCell.rowspan, newMergedCell.colspan); + } + /** + * Get a warning message for when the declared merged cell data contains values exceeding the table limits. + * + * @param {object} newMergedCell Object containg information about the merged cells that was about to be added. + * @returns {string} + */ + + }, { + key: "IS_OUT_OF_BOUNDS_WARNING", + value: function IS_OUT_OF_BOUNDS_WARNING(newMergedCell) { + return toSingleLine(_templateObject2$1 || (_templateObject2$1 = _taggedTemplateLiteral$5(["The merged cell declared at [", ", ", "] is positioned \n (or positioned partially) outside of the table range. It was not added to the table, please fix your setup."], ["The merged cell declared at [", ", ", "] is positioned\\x20\n (or positioned partially) outside of the table range. It was not added to the table, please fix your setup."])), newMergedCell.row, newMergedCell.col); + } + /** + * Get a warning message for when the declared merged cell data represents a single cell. + * + * @param {object} newMergedCell Object containg information about the merged cells that was about to be added. + * @returns {string} + */ + + }, { + key: "IS_SINGLE_CELL", + value: function IS_SINGLE_CELL(newMergedCell) { + return toSingleLine(_templateObject3$1 || (_templateObject3$1 = _taggedTemplateLiteral$5(["The merged cell declared at [", ", ", "] has both \"rowspan\" \n and \"colspan\" declared as \"1\", which makes it a single cell. It cannot be added to the collection."], ["The merged cell declared at [", ", ", "] has both \"rowspan\"\\x20\n and \"colspan\" declared as \"1\", which makes it a single cell. It cannot be added to the collection."])), newMergedCell.row, newMergedCell.col); + } + /** + * Get a warning message for when the declared merged cell data contains "colspan" or "rowspan", that equals 0. + * + * @param {object} newMergedCell Object containg information about the merged cells that was about to be added. + * @returns {string} + */ + + }, { + key: "ZERO_SPAN_WARNING", + value: function ZERO_SPAN_WARNING(newMergedCell) { + return toSingleLine(_templateObject4$1 || (_templateObject4$1 = _taggedTemplateLiteral$5(["The merged cell declared at [", ", ", "] has \"rowspan\" \n or \"colspan\" declared as \"0\", which is not supported. It cannot be added to the collection."], ["The merged cell declared at [", ", ", "] has \"rowspan\"\\x20\n or \"colspan\" declared as \"0\", which is not supported. It cannot be added to the collection."])), newMergedCell.row, newMergedCell.col); + } + /** + * Check whether the values provided for a merged cell contain any negative values. + * + * @param {object} mergedCellInfo Object containing the `row`, `col`, `rowspan` and `colspan` properties. + * @returns {boolean} + */ + + }, { + key: "containsNegativeValues", + value: function containsNegativeValues(mergedCellInfo) { + return mergedCellInfo.row < 0 || mergedCellInfo.col < 0 || mergedCellInfo.rowspan < 0 || mergedCellInfo.colspan < 0; + } + /** + * Check whether the provided merged cell information object represents a single cell. + * + * @private + * @param {object} mergedCellInfo An object with `row`, `col`, `rowspan` and `colspan` properties. + * @returns {boolean} + */ + + }, { + key: "isSingleCell", + value: function isSingleCell(mergedCellInfo) { + return mergedCellInfo.colspan === 1 && mergedCellInfo.rowspan === 1; + } + /** + * Check whether the provided merged cell information object contains a rowspan or colspan of 0. + * + * @private + * @param {object} mergedCellInfo An object with `row`, `col`, `rowspan` and `colspan` properties. + * @returns {boolean} + */ + + }, { + key: "containsZeroSpan", + value: function containsZeroSpan(mergedCellInfo) { + return mergedCellInfo.colspan === 0 || mergedCellInfo.rowspan === 0; + } + /** + * Check whether the provided merged cell object is to be declared out of bounds of the table. + * + * @param {object} mergeCell Object containing the `row`, `col`, `rowspan` and `colspan` properties. + * @param {number} rowCount Number of rows in the table. + * @param {number} columnCount Number of rows in the table. + * @returns {boolean} + */ + + }, { + key: "isOutOfBounds", + value: function isOutOfBounds(mergeCell, rowCount, columnCount) { + return mergeCell.row < 0 || mergeCell.col < 0 || mergeCell.row >= rowCount || mergeCell.row + mergeCell.rowspan - 1 >= rowCount || mergeCell.col >= columnCount || mergeCell.col + mergeCell.colspan - 1 >= columnCount; + } + }]); + + return MergedCellCoords; +}(); + +/** + * Apply the `colspan`/`rowspan` properties. + * + * @param {HTMLElement} TD The soon-to-be-modified cell. + * @param {MergedCellCoords} mergedCellInfo The merged cell in question. + * @param {number} row Row index. + * @param {number} col Column index. + */ +function applySpanProperties(TD, mergedCellInfo, row, col) { + if (mergedCellInfo) { + if (mergedCellInfo.row === row && mergedCellInfo.col === col) { + TD.setAttribute('rowspan', mergedCellInfo.rowspan.toString()); + TD.setAttribute('colspan', mergedCellInfo.colspan.toString()); + } else { + TD.removeAttribute('rowspan'); + TD.removeAttribute('colspan'); + TD.style.display = 'none'; + } + } else { + TD.removeAttribute('rowspan'); + TD.removeAttribute('colspan'); + TD.style.display = ''; + } +} + +var _templateObject$6; + +function _taggedTemplateLiteral$6(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _toConsumableArray$k(arr) { return _arrayWithoutHoles$i(arr) || _iterableToArray$j(arr) || _unsupportedIterableToArray$A(arr) || _nonIterableSpread$i(); } + +function _nonIterableSpread$i() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$A(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$A(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$A(o, minLen); } + +function _iterableToArray$j(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$i(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$A(arr); } + +function _arrayLikeToArray$A(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$1P(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1J(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); } } + +function _createClass$1J(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1J(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1J(Constructor, staticProps); return Constructor; } +/** + * Defines a container object for the merged cells. + * + * @class MergedCellsCollection + * @plugin MergeCells + */ + +var MergedCellsCollection = /*#__PURE__*/function () { + function MergedCellsCollection(plugin) { + _classCallCheck$1P(this, MergedCellsCollection); + + /** + * Reference to the Merge Cells plugin. + * + * @type {MergeCells} + */ + this.plugin = plugin; + /** + * Array of merged cells. + * + * @type {Array} + */ + + this.mergedCells = []; + /** + * The Handsontable instance. + * + * @type {Handsontable} + */ + + this.hot = plugin.hot; + } + /** + * Get a warning message for when the declared merged cell data overlaps already existing merged cells. + * + * @param {object} newMergedCell Object containg information about the merged cells that was about to be added. + * @returns {string} + */ + + + _createClass$1J(MergedCellsCollection, [{ + key: "get", + value: + /** + * Get a merged cell from the container, based on the provided arguments. You can provide either the "starting coordinates" + * of a merged cell, or any coordinates from the body of the merged cell. + * + * @param {number} row Row index. + * @param {number} column Column index. + * @returns {MergedCellCoords|boolean} Returns a wanted merged cell on success and `false` on failure. + */ + function get(row, column) { + var mergedCells = this.mergedCells; + var result = false; + arrayEach(mergedCells, function (mergedCell) { + if (mergedCell.row <= row && mergedCell.row + mergedCell.rowspan - 1 >= row && mergedCell.col <= column && mergedCell.col + mergedCell.colspan - 1 >= column) { + result = mergedCell; + return false; + } + + return true; + }); + return result; + } + /** + * Get a merged cell containing the provided range. + * + * @param {CellRange|object} range The range to search merged cells for. + * @returns {MergedCellCoords|boolean} + */ + + }, { + key: "getByRange", + value: function getByRange(range) { + var mergedCells = this.mergedCells; + var result = false; + arrayEach(mergedCells, function (mergedCell) { + if (mergedCell.row <= range.from.row && mergedCell.row + mergedCell.rowspan - 1 >= range.to.row && mergedCell.col <= range.from.col && mergedCell.col + mergedCell.colspan - 1 >= range.to.col) { + result = mergedCell; + return result; + } + + return true; + }); + return result; + } + /** + * Get a merged cell contained in the provided range. + * + * @param {CellRange|object} range The range to search merged cells in. + * @param {boolean} [countPartials=false] If set to `true`, all the merged cells overlapping the range will be taken into calculation. + * @returns {Array|boolean} Array of found merged cells of `false` if none were found. + */ + + }, { + key: "getWithinRange", + value: function getWithinRange(range) { + var countPartials = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var mergedCells = this.mergedCells; + var foundMergedCells = []; + var testedRange = range; + + if (!testedRange.includesRange) { + var from = new CellCoords(testedRange.from.row, testedRange.from.col); + var to = new CellCoords(testedRange.to.row, testedRange.to.col); + testedRange = new CellRange(from, from, to); + } + + arrayEach(mergedCells, function (mergedCell) { + var mergedCellTopLeft = new CellCoords(mergedCell.row, mergedCell.col); + var mergedCellBottomRight = new CellCoords(mergedCell.row + mergedCell.rowspan - 1, mergedCell.col + mergedCell.colspan - 1); + var mergedCellRange = new CellRange(mergedCellTopLeft, mergedCellTopLeft, mergedCellBottomRight); + + if (countPartials) { + if (testedRange.overlaps(mergedCellRange)) { + foundMergedCells.push(mergedCell); + } + } else if (testedRange.includesRange(mergedCellRange)) { + foundMergedCells.push(mergedCell); + } + }); + return foundMergedCells.length ? foundMergedCells : false; + } + /** + * Add a merged cell to the container. + * + * @param {object} mergedCellInfo The merged cell information object. Has to contain `row`, `col`, `colspan` and `rowspan` properties. + * @returns {MergedCellCoords|boolean} Returns the new merged cell on success and `false` on failure. + */ + + }, { + key: "add", + value: function add(mergedCellInfo) { + var mergedCells = this.mergedCells; + var row = mergedCellInfo.row; + var column = mergedCellInfo.col; + var rowspan = mergedCellInfo.rowspan; + var colspan = mergedCellInfo.colspan; + var newMergedCell = new MergedCellCoords(row, column, rowspan, colspan); + var alreadyExists = this.get(row, column); + var isOverlapping = this.isOverlapping(newMergedCell); + + if (!alreadyExists && !isOverlapping) { + if (this.hot) { + newMergedCell.normalize(this.hot); + } + + mergedCells.push(newMergedCell); + return newMergedCell; + } + + warn(MergedCellsCollection.IS_OVERLAPPING_WARNING(newMergedCell)); + return false; + } + /** + * Remove a merged cell from the container. You can provide either the "starting coordinates" + * of a merged cell, or any coordinates from the body of the merged cell. + * + * @param {number} row Row index. + * @param {number} column Column index. + * @returns {MergedCellCoords|boolean} Returns the removed merged cell on success and `false` on failure. + */ + + }, { + key: "remove", + value: function remove(row, column) { + var mergedCells = this.mergedCells; + var wantedCollection = this.get(row, column); + var wantedCollectionIndex = wantedCollection ? this.mergedCells.indexOf(wantedCollection) : null; + + if (wantedCollection && wantedCollectionIndex !== false) { + mergedCells.splice(wantedCollectionIndex, 1); + return wantedCollection; + } + + return false; + } + /** + * Clear all the merged cells. + */ + + }, { + key: "clear", + value: function clear() { + var _this = this; + + var mergedCells = this.mergedCells; + var mergedCellParentsToClear = []; + var hiddenCollectionElements = []; + arrayEach(mergedCells, function (mergedCell) { + var TD = _this.hot.getCell(mergedCell.row, mergedCell.col); + + if (TD) { + mergedCellParentsToClear.push([TD, _this.get(mergedCell.row, mergedCell.col), mergedCell.row, mergedCell.col]); + } + }); + this.mergedCells.length = 0; + arrayEach(mergedCellParentsToClear, function (mergedCell, i) { + rangeEach(0, mergedCell.rowspan - 1, function (j) { + rangeEach(0, mergedCell.colspan - 1, function (k) { + if (k !== 0 || j !== 0) { + var TD = _this.hot.getCell(mergedCell.row + j, mergedCell.col + k); + + if (TD) { + hiddenCollectionElements.push([TD, null, null, null]); + } + } + }); + }); + mergedCellParentsToClear[i][1] = null; + }); + arrayEach(mergedCellParentsToClear, function (mergedCellParents) { + applySpanProperties.apply(void 0, _toConsumableArray$k(mergedCellParents)); + }); + arrayEach(hiddenCollectionElements, function (hiddenCollectionElement) { + applySpanProperties.apply(void 0, _toConsumableArray$k(hiddenCollectionElement)); + }); + } + /** + * Check if the provided merged cell overlaps with the others in the container. + * + * @param {MergedCellCoords} mergedCell The merged cell to check against all others in the container. + * @returns {boolean} `true` if the provided merged cell overlaps with the others, `false` otherwise. + */ + + }, { + key: "isOverlapping", + value: function isOverlapping(mergedCell) { + var mergedCellRange = new CellRange(new CellCoords(0, 0), new CellCoords(mergedCell.row, mergedCell.col), new CellCoords(mergedCell.row + mergedCell.rowspan - 1, mergedCell.col + mergedCell.colspan - 1)); + var result = false; + arrayEach(this.mergedCells, function (col) { + var currentRange = new CellRange(new CellCoords(0, 0), new CellCoords(col.row, col.col), new CellCoords(col.row + col.rowspan - 1, col.col + col.colspan - 1)); + + if (currentRange.overlaps(mergedCellRange)) { + result = true; + return false; + } + + return true; + }); + return result; + } + /** + * Check whether the provided row/col coordinates direct to a first not hidden cell within merge area. + * + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @returns {boolean} + */ + + }, { + key: "isFirstRenderableMergedCell", + value: function isFirstRenderableMergedCell(row, column) { + var mergeParent = this.get(row, column); // Return if row and column indexes are within merge area and if they are first rendered indexes within the area. + + return mergeParent && this.hot.rowIndexMapper.getFirstNotHiddenIndex(mergeParent.row, 1) === row && this.hot.columnIndexMapper.getFirstNotHiddenIndex(mergeParent.col, 1) === column; + } + /** + * Get the first renderable coords of the merged cell at the provided coordinates. + * + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @returns {CellCoords} A `CellCoords` object with the coordinates to the first renderable cell within the + * merged cell. + */ + + }, { + key: "getFirstRenderableCoords", + value: function getFirstRenderableCoords(row, column) { + var mergeParent = this.get(row, column); + + if (!mergeParent || this.isFirstRenderableMergedCell(row, column)) { + return new CellCoords(row, column); + } + + var firstRenderableRow = this.hot.rowIndexMapper.getFirstNotHiddenIndex(mergeParent.row, 1); + var firstRenderableColumn = this.hot.columnIndexMapper.getFirstNotHiddenIndex(mergeParent.col, 1); + return new CellCoords(firstRenderableRow, firstRenderableColumn); + } + /** + * Shift the merged cell in the direction and by an offset defined in the arguments. + * + * @param {string} direction `right`, `left`, `up` or `down`. + * @param {number} index Index where the change, which caused the shifting took place. + * @param {number} count Number of rows/columns added/removed in the preceding action. + */ + + }, { + key: "shiftCollections", + value: function shiftCollections(direction, index, count) { + var _this2 = this; + + var shiftVector = [0, 0]; + + switch (direction) { + case 'right': + shiftVector[0] += count; + break; + + case 'left': + shiftVector[0] -= count; + break; + + case 'down': + shiftVector[1] += count; + break; + + case 'up': + shiftVector[1] -= count; + break; + } + + arrayEach(this.mergedCells, function (currentMerge) { + currentMerge.shift(shiftVector, index); + }); + rangeEachReverse(this.mergedCells.length - 1, 0, function (i) { + var currentMerge = _this2.mergedCells[i]; + + if (currentMerge && currentMerge.removed) { + _this2.mergedCells.splice(_this2.mergedCells.indexOf(currentMerge), 1); + } + }); + } + }], [{ + key: "IS_OVERLAPPING_WARNING", + value: function IS_OVERLAPPING_WARNING(newMergedCell) { + return toSingleLine(_templateObject$6 || (_templateObject$6 = _taggedTemplateLiteral$6(["The merged cell declared at [", ", ", "], overlaps \n with the other declared merged cell. The overlapping merged cell was not added to the table, please \n fix your setup."], ["The merged cell declared at [", ", ", "], overlaps\\x20\n with the other declared merged cell. The overlapping merged cell was not added to the table, please\\x20\n fix your setup."])), newMergedCell.row, newMergedCell.col); + } + }]); + + return MergedCellsCollection; +}(); + +function _slicedToArray$o(arr, i) { return _arrayWithHoles$p(arr) || _iterableToArrayLimit$o(arr, i) || _unsupportedIterableToArray$B(arr, i) || _nonIterableRest$p(); } + +function _nonIterableRest$p() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$B(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$B(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$B(o, minLen); } + +function _arrayLikeToArray$B(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$o(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$p(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$1Q(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1K(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); } } + +function _createClass$1K(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1K(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1K(Constructor, staticProps); return Constructor; } +/** + * Class responsible for all of the Autofill-related operations on merged cells. + * + * @class AutofillCalculations + * @plugin MergeCells + * @util + */ + +var AutofillCalculations = /*#__PURE__*/function () { + function AutofillCalculations(plugin) { + _classCallCheck$1Q(this, AutofillCalculations); + + /** + * Reference to the Merge Cells plugin. + * + * @type {MergeCells} + */ + this.plugin = plugin; + /** + * Reference to the MergedCellsCollection class instance. + * + * @type {MergedCellsCollection} + */ + + this.mergedCellsCollection = this.plugin.mergedCellsCollection; + /** + * Cache of the currently processed autofill data. + * + * @private + * @type {object} + */ + + this.currentFillData = null; + } + /** + * Correct the provided selection area, so it's not selecting only a part of a merged cell. + * + * @param {Array} selectionArea The selection to correct. + */ + + + _createClass$1K(AutofillCalculations, [{ + key: "correctSelectionAreaSize", + value: function correctSelectionAreaSize(selectionArea) { + if (selectionArea[0] === selectionArea[2] && selectionArea[1] === selectionArea[3]) { + var mergedCell = this.mergedCellsCollection.get(selectionArea[0], selectionArea[1]); + + if (mergedCell) { + selectionArea[2] = selectionArea[0] + mergedCell.rowspan - 1; + selectionArea[3] = selectionArea[1] + mergedCell.colspan - 1; + } + } + } + /** + * Get the direction of the autofill process. + * + * @param {Array} selectionArea The selection area. + * @param {Array} finalArea The final area (base + drag). + * @returns {string} `up`, `down`, `left` or `right`. + */ + + }, { + key: "getDirection", + value: function getDirection(selectionArea, finalArea) { + var direction = null; + + if (finalArea[0] === selectionArea[0] && finalArea[1] === selectionArea[1] && finalArea[3] === selectionArea[3]) { + direction = 'down'; + } else if (finalArea[2] === selectionArea[2] && finalArea[1] === selectionArea[1] && finalArea[3] === selectionArea[3]) { + direction = 'up'; + } else if (finalArea[1] === selectionArea[1] && finalArea[2] === selectionArea[2]) { + direction = 'right'; + } else { + direction = 'left'; + } + + return direction; + } + /** + * Snap the drag area to the farthest merged cell, so it won't clip any of the merged cells. + * + * @param {Array} baseArea The base selected area. + * @param {Array} dragArea The drag area. + * @param {string} dragDirection The autofill drag direction. + * @param {Array} foundMergedCells MergeCellCoords found in the base selection area. + * @returns {Array} The new drag area. + */ + + }, { + key: "snapDragArea", + value: function snapDragArea(baseArea, dragArea, dragDirection, foundMergedCells) { + var newDragArea = dragArea.slice(0); + var fillSize = this.getAutofillSize(baseArea, dragArea, dragDirection); + + var _baseArea = _slicedToArray$o(baseArea, 4), + baseAreaStartRow = _baseArea[0], + baseAreaStartColumn = _baseArea[1], + baseAreaEndRow = _baseArea[2], + baseAreaEndColumn = _baseArea[3]; + + var verticalDirection = ['up', 'down'].indexOf(dragDirection) > -1; + var fullCycle = verticalDirection ? baseAreaEndRow - baseAreaStartRow + 1 : baseAreaEndColumn - baseAreaStartColumn + 1; + var fulls = Math.floor(fillSize / fullCycle) * fullCycle; + var partials = fillSize - fulls; + var farthestCollection = this.getFarthestCollection(baseArea, dragArea, dragDirection, foundMergedCells); + + if (farthestCollection) { + if (dragDirection === 'down') { + var fill = farthestCollection.row + farthestCollection.rowspan - baseAreaStartRow - partials; + var newLimit = newDragArea[2] + fill; + + if (newLimit >= this.plugin.hot.countRows()) { + newDragArea[2] -= partials; + } else { + newDragArea[2] += partials ? fill : 0; + } + } else if (dragDirection === 'right') { + var _fill = farthestCollection.col + farthestCollection.colspan - baseAreaStartColumn - partials; + + var _newLimit = newDragArea[3] + _fill; + + if (_newLimit >= this.plugin.hot.countCols()) { + newDragArea[3] -= partials; + } else { + newDragArea[3] += partials ? _fill : 0; + } + } else if (dragDirection === 'up') { + var _fill2 = baseAreaEndRow - partials - farthestCollection.row + 1; + + var _newLimit2 = newDragArea[0] + _fill2; + + if (_newLimit2 < 0) { + newDragArea[0] += partials; + } else { + newDragArea[0] -= partials ? _fill2 : 0; + } + } else if (dragDirection === 'left') { + var _fill3 = baseAreaEndColumn - partials - farthestCollection.col + 1; + + var _newLimit3 = newDragArea[1] + _fill3; + + if (_newLimit3 < 0) { + newDragArea[1] += partials; + } else { + newDragArea[1] -= partials ? _fill3 : 0; + } + } + } + + this.updateCurrentFillCache({ + baseArea: baseArea, + dragDirection: dragDirection, + foundMergedCells: foundMergedCells, + fillSize: fillSize, + dragArea: newDragArea, + cycleLength: fullCycle + }); + return newDragArea; + } + /** + * Update the current fill cache with the provided object. + * + * @private + * @param {object} updateObject The current filled object cache. + */ + + }, { + key: "updateCurrentFillCache", + value: function updateCurrentFillCache(updateObject) { + if (!this.currentFillData) { + this.currentFillData = {}; + } + + extend(this.currentFillData, updateObject); + } + /** + * Get the "length" of the drag area. + * + * @private + * @param {Array} baseArea The base selection area. + * @param {Array} dragArea The drag area (containing the base area). + * @param {string} direction The drag direction. + * @returns {number|null} The "length" (height or width, depending on the direction) of the drag. + */ + + }, { + key: "getAutofillSize", + value: function getAutofillSize(baseArea, dragArea, direction) { + var _baseArea2 = _slicedToArray$o(baseArea, 4), + baseAreaStartRow = _baseArea2[0], + baseAreaStartColumn = _baseArea2[1], + baseAreaEndRow = _baseArea2[2], + baseAreaEndColumn = _baseArea2[3]; + + var _dragArea = _slicedToArray$o(dragArea, 4), + dragAreaStartRow = _dragArea[0], + dragAreaStartColumn = _dragArea[1], + dragAreaEndRow = _dragArea[2], + dragAreaEndColumn = _dragArea[3]; + + switch (direction) { + case 'up': + return baseAreaStartRow - dragAreaStartRow; + + case 'down': + return dragAreaEndRow - baseAreaEndRow; + + case 'left': + return baseAreaStartColumn - dragAreaStartColumn; + + case 'right': + return dragAreaEndColumn - baseAreaEndColumn; + + default: + return null; + } + } + /** + * Trim the default drag area (containing the selection area) to the drag-only area. + * + * @private + * @param {Array} baseArea The base selection area. + * @param {Array} dragArea The base selection area extended by the drag area. + * @param {string} direction Drag direction. + * @returns {Array|null} Array representing the drag area coordinates. + */ + + }, { + key: "getDragArea", + value: function getDragArea(baseArea, dragArea, direction) { + var _baseArea3 = _slicedToArray$o(baseArea, 4), + baseAreaStartRow = _baseArea3[0], + baseAreaStartColumn = _baseArea3[1], + baseAreaEndRow = _baseArea3[2], + baseAreaEndColumn = _baseArea3[3]; + + var _dragArea2 = _slicedToArray$o(dragArea, 4), + dragAreaStartRow = _dragArea2[0], + dragAreaStartColumn = _dragArea2[1], + dragAreaEndRow = _dragArea2[2], + dragAreaEndColumn = _dragArea2[3]; + + switch (direction) { + case 'up': + return [dragAreaStartRow, dragAreaStartColumn, baseAreaStartRow - 1, baseAreaEndColumn]; + + case 'down': + return [baseAreaEndRow + 1, baseAreaStartColumn, dragAreaEndRow, baseAreaEndColumn]; + + case 'left': + return [dragAreaStartRow, dragAreaStartColumn, baseAreaEndRow, baseAreaStartColumn - 1]; + + case 'right': + return [baseAreaStartRow, baseAreaEndColumn + 1, dragAreaEndRow, dragAreaEndColumn]; + + default: + return null; + } + } + /** + * Get the to-be-farthest merged cell in the newly filled area. + * + * @private + * @param {Array} baseArea The base selection area. + * @param {Array} dragArea The drag area (containing the base area). + * @param {string} direction The drag direction. + * @param {Array} mergedCellArray Array of the merged cells found in the base area. + * @returns {MergedCellCoords|null} + */ + + }, { + key: "getFarthestCollection", + value: function getFarthestCollection(baseArea, dragArea, direction, mergedCellArray) { + var _baseArea4 = _slicedToArray$o(baseArea, 4), + baseAreaStartRow = _baseArea4[0], + baseAreaStartColumn = _baseArea4[1], + baseAreaEndRow = _baseArea4[2], + baseAreaEndColumn = _baseArea4[3]; + + var verticalDirection = ['up', 'down'].indexOf(direction) > -1; + var baseEnd = verticalDirection ? baseAreaEndRow : baseAreaEndColumn; + var baseStart = verticalDirection ? baseAreaStartRow : baseAreaStartColumn; + var fillSize = this.getAutofillSize(baseArea, dragArea, direction); + var fullCycle = verticalDirection ? baseAreaEndRow - baseAreaStartRow + 1 : baseAreaEndColumn - baseAreaStartColumn + 1; + var fulls = Math.floor(fillSize / fullCycle) * fullCycle; + var partials = fillSize - fulls; + var inclusionFunctionName = null; + var farthestCollection = null; + var endOfDragRecreationIndex = null; + + switch (direction) { + case 'up': + inclusionFunctionName = 'includesVertically'; + endOfDragRecreationIndex = baseEnd - partials + 1; + break; + + case 'left': + inclusionFunctionName = 'includesHorizontally'; + endOfDragRecreationIndex = baseEnd - partials + 1; + break; + + case 'down': + inclusionFunctionName = 'includesVertically'; + endOfDragRecreationIndex = baseStart + partials - 1; + break; + + case 'right': + inclusionFunctionName = 'includesHorizontally'; + endOfDragRecreationIndex = baseStart + partials - 1; + break; + } + + arrayEach(mergedCellArray, function (currentCollection) { + if (currentCollection[inclusionFunctionName](endOfDragRecreationIndex) && currentCollection.isFarther(farthestCollection, direction)) { + farthestCollection = currentCollection; + } + }); + return farthestCollection; + } + /** + * Recreate the merged cells after the autofill process. + * + * @param {Array} changes Changes made. + */ + + }, { + key: "recreateAfterDataPopulation", + value: function recreateAfterDataPopulation(changes) { + if (!this.currentFillData) { + return; + } + + var fillRange = this.getRangeFromChanges(changes); + var foundMergedCells = this.currentFillData.foundMergedCells; + var dragDirection = this.currentFillData.dragDirection; + + var inBounds = function inBounds(current, offset) { + switch (dragDirection) { + case 'up': + return current.row - offset >= fillRange.from.row; + + case 'down': + return current.row + current.rowspan - 1 + offset <= fillRange.to.row; + + case 'left': + return current.col - offset >= fillRange.from.column; + + case 'right': + return current.col + current.colspan - 1 + offset <= fillRange.to.column; + + default: + return null; + } + }; + + var fillOffset = 0; + var current = null; + var multiplier = 1; + + do { + for (var j = 0; j < foundMergedCells.length; j += 1) { + current = foundMergedCells[j]; + fillOffset = multiplier * this.currentFillData.cycleLength; + + if (inBounds(current, fillOffset)) { + switch (dragDirection) { + case 'up': + this.plugin.mergedCellsCollection.add({ + row: current.row - fillOffset, + rowspan: current.rowspan, + col: current.col, + colspan: current.colspan + }); + break; + + case 'down': + this.plugin.mergedCellsCollection.add({ + row: current.row + fillOffset, + rowspan: current.rowspan, + col: current.col, + colspan: current.colspan + }); + break; + + case 'left': + this.plugin.mergedCellsCollection.add({ + row: current.row, + rowspan: current.rowspan, + col: current.col - fillOffset, + colspan: current.colspan + }); + break; + + case 'right': + this.plugin.mergedCellsCollection.add({ + row: current.row, + rowspan: current.rowspan, + col: current.col + fillOffset, + colspan: current.colspan + }); + break; + } + } + + if (j === foundMergedCells.length - 1) { + multiplier += 1; + } + } + } while (inBounds(current, fillOffset)); + + this.currentFillData = null; + this.plugin.hot.render(); + } + /** + * Get the drag range from the changes made. + * + * @private + * @param {Array} changes The changes made. + * @returns {object} Object with `from` and `to` properties, both containing `row` and `column` keys. + */ + + }, { + key: "getRangeFromChanges", + value: function getRangeFromChanges(changes) { + var _this = this; + + var rows = { + min: null, + max: null + }; + var columns = { + min: null, + max: null + }; + arrayEach(changes, function (change) { + var rowIndex = change[0]; + + var columnIndex = _this.plugin.hot.propToCol(change[1]); + + if (rows.min === null || rowIndex < rows.min) { + rows.min = rowIndex; + } + + if (rows.max === null || rowIndex > rows.max) { + rows.max = rowIndex; + } + + if (columns.min === null || columnIndex < columns.min) { + columns.min = columnIndex; + } + + if (columns.max === null || columnIndex > columns.max) { + columns.max = columnIndex; + } + }); + return { + from: { + row: rows.min, + column: columns.min + }, + to: { + row: rows.max, + column: columns.max + } + }; + } + /** + * Check if the drag area contains any merged cells. + * + * @param {Array} baseArea The base selection area. + * @param {Array} fullArea The base area extended by the drag area. + * @param {string} direction Drag direction. + * @returns {boolean} + */ + + }, { + key: "dragAreaOverlapsCollections", + value: function dragAreaOverlapsCollections(baseArea, fullArea, direction) { + var dragArea = this.getDragArea(baseArea, fullArea, direction); + + var _dragArea3 = _slicedToArray$o(dragArea, 4), + dragAreaStartRow = _dragArea3[0], + dragAreaStartColumn = _dragArea3[1], + dragAreaEndRow = _dragArea3[2], + dragAreaEndColumn = _dragArea3[3]; + + var topLeft = new CellCoords(dragAreaStartRow, dragAreaStartColumn); + var bottomRight = new CellCoords(dragAreaEndRow, dragAreaEndColumn); + var dragRange = new CellRange(topLeft, topLeft, bottomRight); + return !!this.mergedCellsCollection.getWithinRange(dragRange, true); + } + }]); + + return AutofillCalculations; +}(); + +function _classCallCheck$1R(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1L(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); } } + +function _createClass$1L(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1L(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1L(Constructor, staticProps); return Constructor; } +/** + * Class responsible for all of the Selection-related operations on merged cells. + * + * @class SelectionCalculations + * @plugin MergeCells + * @util + */ + +var SelectionCalculations = /*#__PURE__*/function () { + function SelectionCalculations(plugin) { + _classCallCheck$1R(this, SelectionCalculations); + + /** + * Reference to the Merge Cells plugin. + * + * @type {MergeCells} + */ + this.plugin = plugin; + /** + * Class name used for fully selected merged cells. + * + * @type {string} + */ + + this.fullySelectedMergedCellClassName = 'fullySelectedMergedCell'; + } + /** + * "Snap" the delta value according to defined merged cells. (In other words, compensate the rowspan - + * e.g. Going up with `delta.row = -1` over a merged cell with `rowspan = 3`, `delta.row` should change to `-3`.). + * + * @param {object} delta The delta object containing `row` and `col` properties. + * @param {CellRange} selectionRange The selection range. + * @param {object} mergedCell A merged cell object. + */ + + + _createClass$1L(SelectionCalculations, [{ + key: "snapDelta", + value: function snapDelta(delta, selectionRange, mergedCell) { + var cellCoords = selectionRange.to; + var newRow = cellCoords.row + delta.row; + var newColumn = cellCoords.col + delta.col; + + if (delta.row) { + this.jumpOverMergedCell(delta, mergedCell, newRow); + } else if (delta.col) { + this.jumpOverMergedCell(delta, mergedCell, newColumn); + } + } + /** + * "Jump" over the merged cell (compensate for the indexes within the merged cell to get past it). + * + * @private + * @param {object} delta The delta object. + * @param {MergedCellCoords} mergedCell The merge cell object. + * @param {number} newIndex New row/column index, created with the delta. + */ + + }, { + key: "jumpOverMergedCell", + value: function jumpOverMergedCell(delta, mergedCell, newIndex) { + var flatDelta = delta.row || delta.col; + var includesIndex = null; + var firstIndex = null; + var lastIndex = null; + + if (delta.row) { + includesIndex = mergedCell.includesVertically(newIndex); + firstIndex = mergedCell.row; + lastIndex = mergedCell.getLastRow(); + } else if (delta.col) { + includesIndex = mergedCell.includesHorizontally(newIndex); + firstIndex = mergedCell.col; + lastIndex = mergedCell.getLastColumn(); + } + + if (flatDelta === 0) { + return; + } else if (flatDelta > 0) { + if (includesIndex && newIndex !== firstIndex) { + flatDelta += lastIndex - newIndex + 1; + } + } else if (includesIndex && newIndex !== lastIndex) { + flatDelta -= newIndex - firstIndex + 1; + } + + if (delta.row) { + delta.row = flatDelta; + } else if (delta.col) { + delta.col = flatDelta; + } + } + /** + * Get a selection range with `to` property incremented by the provided delta. + * + * @param {CellRange} oldSelectionRange The base selection range. + * @param {object} delta The delta object with `row` and `col` properties. + * @returns {CellRange} A new `CellRange` object. + */ + + }, { + key: "getUpdatedSelectionRange", + value: function getUpdatedSelectionRange(oldSelectionRange, delta) { + return new CellRange(oldSelectionRange.highlight, oldSelectionRange.from, new CellCoords(oldSelectionRange.to.row + delta.row, oldSelectionRange.to.col + delta.col)); + } + /** + * Generate an additional class name for the entirely-selected merged cells. + * + * @param {number} currentRow Visual row index of the currently processed cell. + * @param {number} currentColumn Visual column index of the currently cell. + * @param {Array} cornersOfSelection Array of the current selection in a form of `[startRow, startColumn, endRow, endColumn]`. + * @param {number|undefined} layerLevel Number indicating which layer of selection is currently processed. + * @returns {string|undefined} A `String`, which will act as an additional `className` to be added to the currently processed cell. + */ + + }, { + key: "getSelectedMergedCellClassName", + value: function getSelectedMergedCellClassName(currentRow, currentColumn, cornersOfSelection, layerLevel) { + var startRow = Math.min(cornersOfSelection[0], cornersOfSelection[2]); + var startColumn = Math.min(cornersOfSelection[1], cornersOfSelection[3]); + var endRow = Math.max(cornersOfSelection[0], cornersOfSelection[2]); + var endColumn = Math.max(cornersOfSelection[1], cornersOfSelection[3]); + + if (layerLevel === void 0) { + return; + } + + var isFirstRenderableMergedCell = this.plugin.mergedCellsCollection.isFirstRenderableMergedCell(currentRow, currentColumn); // We add extra classes just to the first renderable merged cell. + + if (!isFirstRenderableMergedCell) { + return; + } + + var mergedCell = this.plugin.mergedCellsCollection.get(currentRow, currentColumn); + + if (!mergedCell) { + return; + } + + var mergeRowEnd = mergedCell.getLastRow(); + var mergeColumnEnd = mergedCell.getLastColumn(); + var fullMergeAreaWithinSelection = startRow <= mergedCell.row && startColumn <= mergedCell.col && endRow >= mergeRowEnd && endColumn >= mergeColumnEnd; + + if (fullMergeAreaWithinSelection) { + return "".concat(this.fullySelectedMergedCellClassName, "-").concat(layerLevel); + } else if (this.plugin.selectionCalculations.isMergeCellFullySelected(mergedCell, this.plugin.hot.getSelectedRange())) { + // eslint-disable-line max-len + return "".concat(this.fullySelectedMergedCellClassName, "-multiple"); + } + } + /** + * Check if the provided merged cell is fully selected (by one or many layers of selection). + * + * @param {MergedCellCoords} mergedCell The merged cell to be processed. + * @param {CellRange[]} selectionRangesArray Array of selection ranges. + * @returns {boolean} + */ + + }, { + key: "isMergeCellFullySelected", + value: function isMergeCellFullySelected(mergedCell, selectionRangesArray) { + var mergedCellIndividualCoords = []; + + if (!selectionRangesArray || !mergedCell) { + return false; + } + + for (var r = 0; r < mergedCell.rowspan; r += 1) { + for (var c = 0; c < mergedCell.colspan; c += 1) { + mergedCellIndividualCoords.push(new CellCoords(mergedCell.row + r, mergedCell.col + c)); + } + } + + for (var i = 0; i < mergedCellIndividualCoords.length; i += 1) { + var insideSelections = []; + + for (var s = 0; s < selectionRangesArray.length; s += 1) { + insideSelections[s] = selectionRangesArray[s].includes(mergedCellIndividualCoords[i]); + } + + if (!insideSelections.includes(true)) { + return false; + } + } + + return true; + } + /** + * Generate an array of the entirely-selected merged cells' class names. + * + * @returns {string[]} An `Array` of `String`s. Each of these strings will act like class names to be removed from all the cells in the table. + */ + + }, { + key: "getSelectedMergedCellClassNameToRemove", + value: function getSelectedMergedCellClassNameToRemove() { + var classNames = []; + + for (var i = 0; i <= 7; i += 1) { + classNames.push("".concat(this.fullySelectedMergedCellClassName, "-").concat(i)); + } + + classNames.push("".concat(this.fullySelectedMergedCellClassName, "-multiple")); + return classNames; + } + }]); + + return SelectionCalculations; +}(); + +/** + * @param {*} plugin The plugin instance. + * @returns {object} + */ + +function toggleMergeItem(plugin) { + return { + key: 'mergeCells', + name: function name() { + var sel = this.getSelectedLast(); + + if (sel) { + var info = plugin.mergedCellsCollection.get(sel[0], sel[1]); + + if (info.row === sel[0] && info.col === sel[1] && info.row + info.rowspan - 1 === sel[2] && info.col + info.colspan - 1 === sel[3]) { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_UNMERGE_CELLS); + } + } + + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_MERGE_CELLS); + }, + callback: function callback() { + plugin.toggleMergeOnSelection(); + }, + disabled: function disabled() { + var sel = this.getSelectedLast(); + + if (!sel) { + return true; + } + + var isSingleCell = MergedCellCoords.isSingleCell({ + row: sel[0], + col: sel[1], + rowspan: sel[2] - sel[0] + 1, + colspan: sel[3] - sel[1] + 1 + }); + return isSingleCell || this.selection.isSelectedByCorner(); + }, + hidden: false + }; +} + +function _typeof$10(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$10 = function _typeof(obj) { return typeof obj; }; } else { _typeof$10 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$10(obj); } + +function _slicedToArray$p(arr, i) { return _arrayWithHoles$q(arr) || _iterableToArrayLimit$p(arr, i) || _unsupportedIterableToArray$C(arr, i) || _nonIterableRest$q(); } + +function _nonIterableRest$q() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArrayLimit$p(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$q(arr) { if (Array.isArray(arr)) return arr; } + +function _toConsumableArray$l(arr) { return _arrayWithoutHoles$j(arr) || _iterableToArray$k(arr) || _unsupportedIterableToArray$C(arr) || _nonIterableSpread$j(); } + +function _nonIterableSpread$j() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$C(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$C(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$C(o, minLen); } + +function _iterableToArray$k(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$j(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$C(arr); } + +function _arrayLikeToArray$C(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$1S(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1M(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); } } + +function _createClass$1M(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1M(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1M(Constructor, staticProps); return Constructor; } + +function _get$u(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$u = Reflect.get; } else { _get$u = function _get(target, property, receiver) { var base = _superPropBase$u(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$u(target, property, receiver || target); } + +function _superPropBase$u(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$R(object); if (object === null) break; } return object; } + +function _inherits$R(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$S(subClass, superClass); } + +function _setPrototypeOf$S(o, p) { _setPrototypeOf$S = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$S(o, p); } + +function _createSuper$R(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$S(); return function _createSuperInternal() { var Super = _getPrototypeOf$R(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$R(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$R(this, result); }; } + +function _possibleConstructorReturn$R(self, call) { if (call && (_typeof$10(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$R(self); } + +function _assertThisInitialized$R(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$S() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$R(o) { _getPrototypeOf$R = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$R(o); } +Hooks.getSingleton().register('beforeMergeCells'); +Hooks.getSingleton().register('afterMergeCells'); +Hooks.getSingleton().register('beforeUnmergeCells'); +Hooks.getSingleton().register('afterUnmergeCells'); +var PLUGIN_KEY$g = 'mergeCells'; +var PLUGIN_PRIORITY$f = 150; +var privatePool$e = new WeakMap(); +/** + * @plugin MergeCells + * + * @description + * Plugin, which allows merging cells in the table (using the initial configuration, API or context menu). + * + * @example + * + * ```js + * const hot = new Handsontable(document.getElementById('example'), { + * data: getData(), + * mergeCells: [ + * {row: 0, col: 3, rowspan: 3, colspan: 3}, + * {row: 2, col: 6, rowspan: 2, colspan: 2}, + * {row: 4, col: 8, rowspan: 3, colspan: 3} + * ], + * ``` + */ + +var MergeCells = /*#__PURE__*/function (_BasePlugin) { + _inherits$R(MergeCells, _BasePlugin); + + var _super = _createSuper$R(MergeCells); + + function MergeCells(hotInstance) { + var _this; + + _classCallCheck$1S(this, MergeCells); + + _this = _super.call(this, hotInstance); + privatePool$e.set(_assertThisInitialized$R(_this), { + lastDesiredCoords: null + }); + /** + * A container for all the merged cells. + * + * @private + * @type {MergedCellsCollection} + */ + + _this.mergedCellsCollection = null; + /** + * Instance of the class responsible for all the autofill-related calculations. + * + * @private + * @type {AutofillCalculations} + */ + + _this.autofillCalculations = null; + /** + * Instance of the class responsible for the selection-related calculations. + * + * @private + * @type {SelectionCalculations} + */ + + _this.selectionCalculations = null; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link MergeCells#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1M(MergeCells, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$g]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.mergedCellsCollection = new MergedCellsCollection(this); + this.autofillCalculations = new AutofillCalculations(this); + this.selectionCalculations = new SelectionCalculations(this); + this.addHook('afterInit', function () { + return _this2.onAfterInit.apply(_this2, arguments); + }); + this.addHook('beforeKeyDown', function () { + return _this2.onBeforeKeyDown.apply(_this2, arguments); + }); + this.addHook('modifyTransformStart', function () { + return _this2.onModifyTransformStart.apply(_this2, arguments); + }); + this.addHook('afterModifyTransformStart', function () { + return _this2.onAfterModifyTransformStart.apply(_this2, arguments); + }); + this.addHook('modifyTransformEnd', function () { + return _this2.onModifyTransformEnd.apply(_this2, arguments); + }); + this.addHook('modifyGetCellCoords', function () { + return _this2.onModifyGetCellCoords.apply(_this2, arguments); + }); + this.addHook('beforeSetRangeStart', function () { + return _this2.onBeforeSetRangeStart.apply(_this2, arguments); + }); + this.addHook('beforeSetRangeStartOnly', function () { + return _this2.onBeforeSetRangeStart.apply(_this2, arguments); + }); + this.addHook('beforeSetRangeEnd', function () { + return _this2.onBeforeSetRangeEnd.apply(_this2, arguments); + }); + this.addHook('afterIsMultipleSelection', function () { + return _this2.onAfterIsMultipleSelection.apply(_this2, arguments); + }); + this.addHook('afterRenderer', function () { + return _this2.onAfterRenderer.apply(_this2, arguments); + }); + this.addHook('afterContextMenuDefaultOptions', function () { + return _this2.addMergeActionsToContextMenu.apply(_this2, arguments); + }); + this.addHook('afterGetCellMeta', function () { + return _this2.onAfterGetCellMeta.apply(_this2, arguments); + }); + this.addHook('afterViewportRowCalculatorOverride', function () { + return _this2.onAfterViewportRowCalculatorOverride.apply(_this2, arguments); + }); + this.addHook('afterViewportColumnCalculatorOverride', function () { + return _this2.onAfterViewportColumnCalculatorOverride.apply(_this2, arguments); + }); + this.addHook('modifyAutofillRange', function () { + return _this2.onModifyAutofillRange.apply(_this2, arguments); + }); + this.addHook('afterCreateCol', function () { + return _this2.onAfterCreateCol.apply(_this2, arguments); + }); + this.addHook('afterRemoveCol', function () { + return _this2.onAfterRemoveCol.apply(_this2, arguments); + }); + this.addHook('afterCreateRow', function () { + return _this2.onAfterCreateRow.apply(_this2, arguments); + }); + this.addHook('afterRemoveRow', function () { + return _this2.onAfterRemoveRow.apply(_this2, arguments); + }); + this.addHook('afterChange', function () { + return _this2.onAfterChange.apply(_this2, arguments); + }); + this.addHook('beforeDrawBorders', function () { + return _this2.onBeforeDrawAreaBorders.apply(_this2, arguments); + }); + this.addHook('afterDrawSelection', function () { + return _this2.onAfterDrawSelection.apply(_this2, arguments); + }); + this.addHook('beforeRemoveCellClassNames', function () { + return _this2.onBeforeRemoveCellClassNames.apply(_this2, arguments); + }); + + _get$u(_getPrototypeOf$R(MergeCells.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.clearCollections(); + this.hot.render(); + + _get$u(_getPrototypeOf$R(MergeCells.prototype), "disablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + var settings = this.hot.getSettings()[PLUGIN_KEY$g]; + this.disablePlugin(); + this.enablePlugin(); + this.generateFromSettings(settings); + + _get$u(_getPrototypeOf$R(MergeCells.prototype), "updatePlugin", this).call(this); + } + /** + * Validates a single setting object, represented by a single merged cell information object. + * + * @private + * @param {object} setting An object with `row`, `col`, `rowspan` and `colspan` properties. + * @returns {boolean} + */ + + }, { + key: "validateSetting", + value: function validateSetting(setting) { + var valid = true; + + if (!setting) { + return false; + } + + if (MergedCellCoords.containsNegativeValues(setting)) { + warn(MergedCellCoords.NEGATIVE_VALUES_WARNING(setting)); + valid = false; + } else if (MergedCellCoords.isOutOfBounds(setting, this.hot.countRows(), this.hot.countCols())) { + warn(MergedCellCoords.IS_OUT_OF_BOUNDS_WARNING(setting)); + valid = false; + } else if (MergedCellCoords.isSingleCell(setting)) { + warn(MergedCellCoords.IS_SINGLE_CELL(setting)); + valid = false; + } else if (MergedCellCoords.containsZeroSpan(setting)) { + warn(MergedCellCoords.ZERO_SPAN_WARNING(setting)); + valid = false; + } + + return valid; + } + /** + * Generates the merged cells from the settings provided to the plugin. + * + * @private + * @param {Array|boolean} settings The settings provided to the plugin. + */ + + }, { + key: "generateFromSettings", + value: function generateFromSettings(settings) { + var _this3 = this; + + if (Array.isArray(settings)) { + var _this$hot; + + var populationArgumentsList = []; + arrayEach(settings, function (setting) { + if (!_this3.validateSetting(setting)) { + return; + } + + var highlight = new CellCoords(setting.row, setting.col); + var rangeEnd = new CellCoords(setting.row + setting.rowspan - 1, setting.col + setting.colspan - 1); + var mergeRange = new CellRange(highlight, highlight, rangeEnd); + populationArgumentsList.push(_this3.mergeRange(mergeRange, true, true)); + }); // remove 'empty' setting objects, caused by improper merge range declarations + + populationArgumentsList = populationArgumentsList.filter(function (value) { + return value !== true; + }); + var bulkPopulationData = this.getBulkCollectionData(populationArgumentsList); + + (_this$hot = this.hot).populateFromArray.apply(_this$hot, _toConsumableArray$l(bulkPopulationData)); + } + } + /** + * Generates a bulk set of all the data to be populated to fill the data "under" the added merged cells. + * + * @private + * @param {Array} populationArgumentsList Array in a form of `[row, column, dataUnderCollection]`. + * @returns {Array} Array in a form of `[row, column, dataOfAllCollections]`. + */ + + }, { + key: "getBulkCollectionData", + value: function getBulkCollectionData(populationArgumentsList) { + var _this$hot2; + + var populationDataRange = this.getBulkCollectionDataRange(populationArgumentsList); + + var dataAtRange = (_this$hot2 = this.hot).getData.apply(_this$hot2, _toConsumableArray$l(populationDataRange)); + + var newDataAtRange = dataAtRange.splice(0); + arrayEach(populationArgumentsList, function (mergedCellArguments) { + var _mergedCellArguments = _slicedToArray$p(mergedCellArguments, 3), + mergedCellRowIndex = _mergedCellArguments[0], + mergedCellColumnIndex = _mergedCellArguments[1], + mergedCellData = _mergedCellArguments[2]; + + arrayEach(mergedCellData, function (mergedCellRow, rowIndex) { + arrayEach(mergedCellRow, function (mergedCellElement, columnIndex) { + newDataAtRange[mergedCellRowIndex - populationDataRange[0] + rowIndex][mergedCellColumnIndex - populationDataRange[1] + columnIndex] = mergedCellElement; // eslint-disable-line max-len + }); + }); + }); + return [populationDataRange[0], populationDataRange[1], newDataAtRange]; + } + /** + * Gets the range of combined data ranges provided in a form of an array of arrays ([row, column, dataUnderCollection]). + * + * @private + * @param {Array} populationArgumentsList Array containing argument lists for the `populateFromArray` method - row, column and data for population. + * @returns {Array[]} Start and end coordinates of the merged cell range. (in a form of [rowIndex, columnIndex]). + */ + + }, { + key: "getBulkCollectionDataRange", + value: function getBulkCollectionDataRange(populationArgumentsList) { + var start = [0, 0]; + var end = [0, 0]; + var mergedCellRow = null; + var mergedCellColumn = null; + var mergedCellData = null; + arrayEach(populationArgumentsList, function (mergedCellArguments) { + mergedCellRow = mergedCellArguments[0]; + mergedCellColumn = mergedCellArguments[1]; + mergedCellData = mergedCellArguments[2]; + start[0] = Math.min(mergedCellRow, start[0]); + start[1] = Math.min(mergedCellColumn, start[1]); + end[0] = Math.max(mergedCellRow + mergedCellData.length - 1, end[0]); + end[1] = Math.max(mergedCellColumn + mergedCellData[0].length - 1, end[1]); + }); + return [].concat(start, end); + } + /** + * Clears the merged cells from the merged cell container. + */ + + }, { + key: "clearCollections", + value: function clearCollections() { + this.mergedCellsCollection.clear(); + } + /** + * Returns `true` if a range is mergeable. + * + * @private + * @param {object} newMergedCellInfo Merged cell information object to test. + * @param {boolean} [auto=false] `true` if triggered at initialization. + * @returns {boolean} + */ + + }, { + key: "canMergeRange", + value: function canMergeRange(newMergedCellInfo) { + var auto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + return auto ? true : this.validateSetting(newMergedCellInfo); + } + /** + * Merge or unmerge, based on last selected range. + * + * @private + */ + + }, { + key: "toggleMergeOnSelection", + value: function toggleMergeOnSelection() { + var currentRange = this.hot.getSelectedRangeLast(); + + if (!currentRange) { + return; + } + + currentRange.setDirection('NW-SE'); + var from = currentRange.from, + to = currentRange.to; + this.toggleMerge(currentRange); + this.hot.selectCell(from.row, from.col, to.row, to.col, false); + } + /** + * Merges the selection provided as a cell range. + * + * @param {CellRange} [cellRange] Selection cell range. + */ + + }, { + key: "mergeSelection", + value: function mergeSelection() { + var cellRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.hot.getSelectedRangeLast(); + + if (!cellRange) { + return; + } + + cellRange.setDirection('NW-SE'); + var from = cellRange.from, + to = cellRange.to; + this.unmergeRange(cellRange, true); + this.mergeRange(cellRange); + this.hot.selectCell(from.row, from.col, to.row, to.col, false); + } + /** + * Unmerges the selection provided as a cell range. + * + * @param {CellRange} [cellRange] Selection cell range. + */ + + }, { + key: "unmergeSelection", + value: function unmergeSelection() { + var cellRange = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.hot.getSelectedRangeLast(); + + if (!cellRange) { + return; + } + + var from = cellRange.from, + to = cellRange.to; + this.unmergeRange(cellRange, true); + this.hot.selectCell(from.row, from.col, to.row, to.col, false); + } + /** + * Merges cells in the provided cell range. + * + * @private + * @param {CellRange} cellRange Cell range to merge. + * @param {boolean} [auto=false] `true` if is called automatically, e.g. At initialization. + * @param {boolean} [preventPopulation=false] `true`, if the method should not run `populateFromArray` at the end, but rather return its arguments. + * @returns {Array|boolean} Returns an array of [row, column, dataUnderCollection] if preventPopulation is set to true. If the the merging process went successful, it returns `true`, otherwise - `false`. + * @fires Hooks#beforeMergeCells + * @fires Hooks#afterMergeCells + */ + + }, { + key: "mergeRange", + value: function mergeRange(cellRange) { + var _this4 = this; + + var auto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var preventPopulation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var topLeft = cellRange.getTopLeftCorner(); + var bottomRight = cellRange.getBottomRightCorner(); + var mergeParent = { + row: topLeft.row, + col: topLeft.col, + rowspan: bottomRight.row - topLeft.row + 1, + colspan: bottomRight.col - topLeft.col + 1 + }; + var clearedData = []; + var populationInfo = null; + + if (!this.canMergeRange(mergeParent, auto)) { + return false; + } + + this.hot.runHooks('beforeMergeCells', cellRange, auto); + rangeEach(0, mergeParent.rowspan - 1, function (i) { + rangeEach(0, mergeParent.colspan - 1, function (j) { + var clearedValue = null; + + if (!clearedData[i]) { + clearedData[i] = []; + } + + if (i === 0 && j === 0) { + clearedValue = _this4.hot.getDataAtCell(mergeParent.row, mergeParent.col); + } else { + _this4.hot.setCellMeta(mergeParent.row + i, mergeParent.col + j, 'hidden', true); + } + + clearedData[i][j] = clearedValue; + }); + }); + this.hot.setCellMeta(mergeParent.row, mergeParent.col, 'spanned', true); + var mergedCellAdded = this.mergedCellsCollection.add(mergeParent); + + if (mergedCellAdded) { + if (preventPopulation) { + populationInfo = [mergeParent.row, mergeParent.col, clearedData]; + } else { + this.hot.populateFromArray(mergeParent.row, mergeParent.col, clearedData, void 0, void 0, this.pluginName); + } + + this.hot.runHooks('afterMergeCells', cellRange, mergeParent, auto); + return populationInfo; + } + + return true; + } + /** + * Unmerges the selection provided as a cell range. If no cell range is provided, it uses the current selection. + * + * @private + * @param {CellRange} cellRange Selection cell range. + * @param {boolean} [auto=false] `true` if called automatically by the plugin. + * + * @fires Hooks#beforeUnmergeCells + * @fires Hooks#afterUnmergeCells + */ + + }, { + key: "unmergeRange", + value: function unmergeRange(cellRange) { + var _this5 = this; + + var auto = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var mergedCells = this.mergedCellsCollection.getWithinRange(cellRange); + + if (!mergedCells) { + return; + } + + this.hot.runHooks('beforeUnmergeCells', cellRange, auto); + arrayEach(mergedCells, function (currentCollection) { + _this5.mergedCellsCollection.remove(currentCollection.row, currentCollection.col); + + rangeEach(0, currentCollection.rowspan - 1, function (i) { + rangeEach(0, currentCollection.colspan - 1, function (j) { + _this5.hot.removeCellMeta(currentCollection.row + i, currentCollection.col + j, 'hidden'); + }); + }); + + _this5.hot.removeCellMeta(currentCollection.row, currentCollection.col, 'spanned'); + }); + this.hot.runHooks('afterUnmergeCells', cellRange, auto); + this.hot.render(); + } + /** + * Merges or unmerges, based on the cell range provided as `cellRange`. + * + * @private + * @param {CellRange} cellRange The cell range to merge or unmerged. + */ + + }, { + key: "toggleMerge", + value: function toggleMerge(cellRange) { + var mergedCell = this.mergedCellsCollection.get(cellRange.from.row, cellRange.from.col); + var mergedCellCoversWholeRange = mergedCell.row === cellRange.from.row && mergedCell.col === cellRange.from.col && mergedCell.row + mergedCell.rowspan - 1 === cellRange.to.row && mergedCell.col + mergedCell.colspan - 1 === cellRange.to.col; + + if (mergedCellCoversWholeRange) { + this.unmergeRange(cellRange); + } else { + this.mergeSelection(cellRange); + } + } + /** + * Merges the specified range. + * + * @param {number} startRow Start row of the merged cell. + * @param {number} startColumn Start column of the merged cell. + * @param {number} endRow End row of the merged cell. + * @param {number} endColumn End column of the merged cell. + * @fires Hooks#beforeMergeCells + * @fires Hooks#afterMergeCells + */ + + }, { + key: "merge", + value: function merge(startRow, startColumn, endRow, endColumn) { + var start = new CellCoords(startRow, startColumn); + var end = new CellCoords(endRow, endColumn); + this.mergeRange(new CellRange(start, start, end)); + } + /** + * Unmerges the merged cell in the provided range. + * + * @param {number} startRow Start row of the merged cell. + * @param {number} startColumn Start column of the merged cell. + * @param {number} endRow End row of the merged cell. + * @param {number} endColumn End column of the merged cell. + * @fires Hooks#beforeUnmergeCells + * @fires Hooks#afterUnmergeCells + */ + + }, { + key: "unmerge", + value: function unmerge(startRow, startColumn, endRow, endColumn) { + var start = new CellCoords(startRow, startColumn); + var end = new CellCoords(endRow, endColumn); + this.unmergeRange(new CellRange(start, start, end)); + } + /** + * `afterInit` hook callback. + * + * @private + */ + + }, { + key: "onAfterInit", + value: function onAfterInit() { + this.generateFromSettings(this.hot.getSettings()[PLUGIN_KEY$g]); + this.hot.render(); + } + /** + * `beforeKeyDown` hook callback. + * + * @private + * @param {KeyboardEvent} event The `keydown` event object. + */ + + }, { + key: "onBeforeKeyDown", + value: function onBeforeKeyDown(event) { + var ctrlDown = (event.ctrlKey || event.metaKey) && !event.altKey; + + if (ctrlDown && event.keyCode === 77) { + // CTRL + M + this.toggleMerge(this.hot.getSelectedRangeLast()); + this.hot.render(); + stopImmediatePropagation(event); + } + } + /** + * Modifies the information on whether the current selection contains multiple cells. The `afterIsMultipleSelection` hook callback. + * + * @private + * @param {boolean} isMultiple Determines whether the current selection contains multiple cells. + * @returns {boolean} + */ + + }, { + key: "onAfterIsMultipleSelection", + value: function onAfterIsMultipleSelection(isMultiple) { + if (isMultiple) { + var mergedCells = this.mergedCellsCollection.mergedCells; + var selectionRange = this.hot.getSelectedRangeLast(); + + for (var group = 0; group < mergedCells.length; group += 1) { + if (selectionRange.from.row === mergedCells[group].row && selectionRange.from.col === mergedCells[group].col && selectionRange.to.row === mergedCells[group].row + mergedCells[group].rowspan - 1 && selectionRange.to.col === mergedCells[group].col + mergedCells[group].colspan - 1) { + return false; + } + } + } + + return isMultiple; + } + /** + * `modifyTransformStart` hook callback. + * + * @private + * @param {object} delta The transformation delta. + */ + + }, { + key: "onModifyTransformStart", + value: function onModifyTransformStart(delta) { + var priv = privatePool$e.get(this); + var currentlySelectedRange = this.hot.getSelectedRangeLast(); + var newDelta = { + row: delta.row, + col: delta.col + }; + var nextPosition = null; + var currentPosition = new CellCoords(currentlySelectedRange.highlight.row, currentlySelectedRange.highlight.col); + var mergedParent = this.mergedCellsCollection.get(currentPosition.row, currentPosition.col); + + if (!priv.lastDesiredCoords) { + priv.lastDesiredCoords = new CellCoords(null, null); + } + + if (mergedParent) { + // only merge selected + var mergeTopLeft = new CellCoords(mergedParent.row, mergedParent.col); + var mergeBottomRight = new CellCoords(mergedParent.row + mergedParent.rowspan - 1, mergedParent.col + mergedParent.colspan - 1); + var mergeRange = new CellRange(mergeTopLeft, mergeTopLeft, mergeBottomRight); + + if (!mergeRange.includes(priv.lastDesiredCoords)) { + priv.lastDesiredCoords = new CellCoords(null, null); // reset outdated version of lastDesiredCoords + } + + newDelta.row = priv.lastDesiredCoords.row ? priv.lastDesiredCoords.row - currentPosition.row : newDelta.row; + newDelta.col = priv.lastDesiredCoords.col ? priv.lastDesiredCoords.col - currentPosition.col : newDelta.col; + + if (delta.row > 0) { + // moving down + newDelta.row = mergedParent.row + mergedParent.rowspan - 1 - currentPosition.row + delta.row; + } else if (delta.row < 0) { + // moving up + newDelta.row = currentPosition.row - mergedParent.row + delta.row; + } + + if (delta.col > 0) { + // moving right + newDelta.col = mergedParent.col + mergedParent.colspan - 1 - currentPosition.col + delta.col; + } else if (delta.col < 0) { + // moving left + newDelta.col = currentPosition.col - mergedParent.col + delta.col; + } + } + + nextPosition = new CellCoords(currentlySelectedRange.highlight.row + newDelta.row, currentlySelectedRange.highlight.col + newDelta.col); + var nextPositionMergedCell = this.mergedCellsCollection.get(nextPosition.row, nextPosition.col); + + if (nextPositionMergedCell) { + // skipping the invisible cells in the merge range + var firstRenderableCoords = this.mergedCellsCollection.getFirstRenderableCoords(nextPositionMergedCell.row, nextPositionMergedCell.col); + priv.lastDesiredCoords = nextPosition; + newDelta = { + row: firstRenderableCoords.row - currentPosition.row, + col: firstRenderableCoords.col - currentPosition.col + }; + } + + if (newDelta.row !== 0) { + delta.row = newDelta.row; + } + + if (newDelta.col !== 0) { + delta.col = newDelta.col; + } + } + /** + * `modifyTransformEnd` hook callback. Needed to handle "jumping over" merged merged cells, while selecting. + * + * @private + * @param {object} delta The transformation delta. + */ + + }, { + key: "onModifyTransformEnd", + value: function onModifyTransformEnd(delta) { + var _this6 = this; + + var currentSelectionRange = this.hot.getSelectedRangeLast(); + var newDelta = clone(delta); + var newSelectionRange = this.selectionCalculations.getUpdatedSelectionRange(currentSelectionRange, delta); + var tempDelta = clone(newDelta); + var mergedCellsWithinRange = this.mergedCellsCollection.getWithinRange(newSelectionRange, true); + + do { + tempDelta = clone(newDelta); + this.selectionCalculations.getUpdatedSelectionRange(currentSelectionRange, newDelta); + arrayEach(mergedCellsWithinRange, function (mergedCell) { + _this6.selectionCalculations.snapDelta(newDelta, currentSelectionRange, mergedCell); + }); + } while (newDelta.row !== tempDelta.row || newDelta.col !== tempDelta.col); + + delta.row = newDelta.row; + delta.col = newDelta.col; + } + /** + * `modifyGetCellCoords` hook callback. Swaps the `getCell` coords with the merged parent coords. + * + * @private + * @param {number} row Row index. + * @param {number} column Visual column index. + * @returns {Array|undefined} Visual coordinates of the merge. + */ + + }, { + key: "onModifyGetCellCoords", + value: function onModifyGetCellCoords(row, column) { + if (row < 0 || column < 0) { + return; + } + + var mergeParent = this.mergedCellsCollection.get(row, column); + + if (!mergeParent) { + return; + } + + var mergeRow = mergeParent.row, + mergeColumn = mergeParent.col, + colspan = mergeParent.colspan, + rowspan = mergeParent.rowspan; + return [// Most top-left merged cell coords. + mergeRow, mergeColumn, // Most bottom-right merged cell coords. + mergeRow + rowspan - 1, mergeColumn + colspan - 1]; + } + /** + * `afterContextMenuDefaultOptions` hook callback. + * + * @private + * @param {object} defaultOptions The default context menu options. + */ + + }, { + key: "addMergeActionsToContextMenu", + value: function addMergeActionsToContextMenu(defaultOptions) { + defaultOptions.items.push({ + name: '---------' + }, toggleMergeItem(this)); + } + /** + * `afterRenderer` hook callback. + * + * @private + * @param {HTMLElement} TD The cell to be modified. + * @param {number} row Row index. + * @param {number} col Visual column index. + */ + + }, { + key: "onAfterRenderer", + value: function onAfterRenderer(TD, row, col) { + var mergedCell = this.mergedCellsCollection.get(row, col); // We shouldn't override data in the collection. + + var mergedCellCopy = isObject$1(mergedCell) ? clone(mergedCell) : void 0; + + if (isObject$1(mergedCellCopy)) { + var _this$hot3 = this.hot, + rowMapper = _this$hot3.rowIndexMapper, + columnMapper = _this$hot3.columnIndexMapper; + var mergeRow = mergedCellCopy.row, + mergeColumn = mergedCellCopy.col, + colspan = mergedCellCopy.colspan, + rowspan = mergedCellCopy.rowspan; + + var _this$translateMerged = this.translateMergedCellToRenderable(mergeRow, rowspan, mergeColumn, colspan), + _this$translateMerged2 = _slicedToArray$p(_this$translateMerged, 2), + lastMergedRowIndex = _this$translateMerged2[0], + lastMergedColumnIndex = _this$translateMerged2[1]; + + var renderedRowIndex = rowMapper.getRenderableFromVisualIndex(row); + var renderedColumnIndex = columnMapper.getRenderableFromVisualIndex(col); + var maxRowSpan = lastMergedRowIndex - renderedRowIndex + 1; // Number of rendered columns. + + var maxColSpan = lastMergedColumnIndex - renderedColumnIndex + 1; // Number of rendered columns. + // We just try to determine some values basing on the actual number of rendered indexes (some columns may be hidden). + + mergedCellCopy.row = rowMapper.getFirstNotHiddenIndex(mergedCellCopy.row, 1); // We just try to determine some values basing on the actual number of rendered indexes (some columns may be hidden). + + mergedCellCopy.col = columnMapper.getFirstNotHiddenIndex(mergedCellCopy.col, 1); // The `rowSpan` property for a `TD` element should be at most equal to number of rendered rows in the merge area. + + mergedCellCopy.rowspan = Math.min(mergedCellCopy.rowspan, maxRowSpan); // The `colSpan` property for a `TD` element should be at most equal to number of rendered columns in the merge area. + + mergedCellCopy.colspan = Math.min(mergedCellCopy.colspan, maxColSpan); + } + + applySpanProperties(TD, mergedCellCopy, row, col); + } + /** + * `beforeSetRangeStart` and `beforeSetRangeStartOnly` hook callback. + * A selection within merge area should be rewritten to the start of merge area. + * + * @private + * @param {object} coords Cell coords. + */ + + }, { + key: "onBeforeSetRangeStart", + value: function onBeforeSetRangeStart(coords) { + // TODO: It is a workaround, but probably this hook may be needed. Every selection on the merge area + // could set start point of the selection to the start of the merge area. However, logic inside `expandByRange` need + // an initial start point. Click on the merge cell when there are some hidden indexes break the logic in some cases. + // Please take a look at #7010 for more information. I'm not sure if selection directions are calculated properly + // and what was idea for flipping direction inside `expandByRange` method. + if (this.mergedCellsCollection.isFirstRenderableMergedCell(coords.row, coords.col)) { + var mergeParent = this.mergedCellsCollection.get(coords.row, coords.col); + var _ref = [mergeParent.row, mergeParent.col]; + coords.row = _ref[0]; + coords.col = _ref[1]; + } + } + /** + * `beforeSetRangeEnd` hook callback. + * While selecting cells with keyboard or mouse, make sure that rectangular area is expanded to the extent of the merged cell. + * + * Note: Please keep in mind that callback may modify both start and end range coordinates by the reference. + * + * @private + * @param {object} coords Cell coords. + */ + + }, { + key: "onBeforeSetRangeEnd", + value: function onBeforeSetRangeEnd(coords) { + var selRange = this.hot.getSelectedRangeLast(); + selRange.highlight = new CellCoords(selRange.highlight.row, selRange.highlight.col); // clone in case we will modify its reference + + selRange.to = coords; + var rangeExpanded = false; + + if (this.hot.selection.isSelectedByColumnHeader() || this.hot.selection.isSelectedByRowHeader()) { + return; + } + + do { + rangeExpanded = false; + + for (var i = 0; i < this.mergedCellsCollection.mergedCells.length; i += 1) { + var cellInfo = this.mergedCellsCollection.mergedCells[i]; + var mergedCellRange = cellInfo.getRange(); + + if (selRange.expandByRange(mergedCellRange)) { + coords.row = selRange.to.row; + coords.col = selRange.to.col; + rangeExpanded = true; + } + } + } while (rangeExpanded); + } + /** + * The `afterGetCellMeta` hook callback. + * + * @private + * @param {number} row Row index. + * @param {number} col Column index. + * @param {object} cellProperties The cell properties object. + */ + + }, { + key: "onAfterGetCellMeta", + value: function onAfterGetCellMeta(row, col, cellProperties) { + var mergeParent = this.mergedCellsCollection.get(row, col); + + if (mergeParent) { + if (mergeParent.row !== row || mergeParent.col !== col) { + cellProperties.copyable = false; + } else { + cellProperties.rowspan = mergeParent.rowspan; + cellProperties.colspan = mergeParent.colspan; + } + } + } + /** + * `afterViewportRowCalculatorOverride` hook callback. + * + * @private + * @param {object} calc The row calculator object. + */ + + }, { + key: "onAfterViewportRowCalculatorOverride", + value: function onAfterViewportRowCalculatorOverride(calc) { + var nrOfColumns = this.hot.countCols(); + this.modifyViewportRowStart(calc, nrOfColumns); + this.modifyViewportRowEnd(calc, nrOfColumns); + } + /** + * Modify viewport start when needed. We extend viewport when merged cells aren't fully visible. + * + * @private + * @param {object} calc The row calculator object. + * @param {number} nrOfColumns Number of visual columns. + */ + + }, { + key: "modifyViewportRowStart", + value: function modifyViewportRowStart(calc, nrOfColumns) { + var rowMapper = this.hot.rowIndexMapper; + var visualStartRow = rowMapper.getVisualFromRenderableIndex(calc.startRow); + + for (var visualColumnIndex = 0; visualColumnIndex < nrOfColumns; visualColumnIndex += 1) { + var mergeParentForViewportStart = this.mergedCellsCollection.get(visualStartRow, visualColumnIndex); + + if (isObject$1(mergeParentForViewportStart)) { + var renderableIndexAtMergeStart = rowMapper.getRenderableFromVisualIndex(rowMapper.getFirstNotHiddenIndex(mergeParentForViewportStart.row, 1)); // Merge start is out of the viewport (i.e. when we scrolled to the bottom and we can see just part of a merge). + + if (renderableIndexAtMergeStart < calc.startRow) { + // We extend viewport when some rows have been merged. + calc.startRow = renderableIndexAtMergeStart; // We are looking for next merges inside already extended viewport (starting again from row equal to 0). + + this.modifyViewportRowStart(calc, nrOfColumns); // recursively search upwards + + return; // Finish the current loop. Everything will be checked from the beginning by above recursion. + } + } + } + } + /** + * Modify viewport end when needed. We extend viewport when merged cells aren't fully visible. + * + * @private + * @param {object} calc The row calculator object. + * @param {number} nrOfColumns Number of visual columns. + */ + + }, { + key: "modifyViewportRowEnd", + value: function modifyViewportRowEnd(calc, nrOfColumns) { + var rowMapper = this.hot.rowIndexMapper; + var visualEndRow = rowMapper.getVisualFromRenderableIndex(calc.endRow); + + for (var visualColumnIndex = 0; visualColumnIndex < nrOfColumns; visualColumnIndex += 1) { + var mergeParentForViewportEnd = this.mergedCellsCollection.get(visualEndRow, visualColumnIndex); + + if (isObject$1(mergeParentForViewportEnd)) { + var mergeEnd = mergeParentForViewportEnd.row + mergeParentForViewportEnd.rowspan - 1; + var renderableIndexAtMergeEnd = rowMapper.getRenderableFromVisualIndex(rowMapper.getFirstNotHiddenIndex(mergeEnd, -1)); // Merge end is out of the viewport. + + if (renderableIndexAtMergeEnd > calc.endRow) { + // We extend the viewport when some rows have been merged. + calc.endRow = renderableIndexAtMergeEnd; // We are looking for next merges inside already extended viewport (starting again from row equal to 0). + + this.modifyViewportRowEnd(calc, nrOfColumns); // recursively search upwards + + return; // Finish the current loop. Everything will be checked from the beginning by above recursion. + } + } + } + } + /** + * `afterViewportColumnCalculatorOverride` hook callback. + * + * @private + * @param {object} calc The column calculator object. + */ + + }, { + key: "onAfterViewportColumnCalculatorOverride", + value: function onAfterViewportColumnCalculatorOverride(calc) { + var nrOfRows = this.hot.countRows(); + this.modifyViewportColumnStart(calc, nrOfRows); + this.modifyViewportColumnEnd(calc, nrOfRows); + } + /** + * Modify viewport start when needed. We extend viewport when merged cells aren't fully visible. + * + * @private + * @param {object} calc The column calculator object. + * @param {number} nrOfRows Number of visual rows. + */ + + }, { + key: "modifyViewportColumnStart", + value: function modifyViewportColumnStart(calc, nrOfRows) { + var columnMapper = this.hot.columnIndexMapper; + var visualStartCol = columnMapper.getVisualFromRenderableIndex(calc.startColumn); + + for (var visualRowIndex = 0; visualRowIndex < nrOfRows; visualRowIndex += 1) { + var mergeParentForViewportStart = this.mergedCellsCollection.get(visualRowIndex, visualStartCol); + + if (isObject$1(mergeParentForViewportStart)) { + var renderableIndexAtMergeStart = columnMapper.getRenderableFromVisualIndex(columnMapper.getFirstNotHiddenIndex(mergeParentForViewportStart.col, 1)); // Merge start is out of the viewport (i.e. when we scrolled to the right and we can see just part of a merge). + + if (renderableIndexAtMergeStart < calc.startColumn) { + // We extend viewport when some columns have been merged. + calc.startColumn = renderableIndexAtMergeStart; // We are looking for next merges inside already extended viewport (starting again from column equal to 0). + + this.modifyViewportColumnStart(calc, nrOfRows); // recursively search upwards + + return; // Finish the current loop. Everything will be checked from the beginning by above recursion. + } + } + } + } + /** + * Modify viewport end when needed. We extend viewport when merged cells aren't fully visible. + * + * @private + * @param {object} calc The column calculator object. + * @param {number} nrOfRows Number of visual rows. + */ + + }, { + key: "modifyViewportColumnEnd", + value: function modifyViewportColumnEnd(calc, nrOfRows) { + var columnMapper = this.hot.columnIndexMapper; + var visualEndCol = columnMapper.getVisualFromRenderableIndex(calc.endColumn); + + for (var visualRowIndex = 0; visualRowIndex < nrOfRows; visualRowIndex += 1) { + var mergeParentForViewportEnd = this.mergedCellsCollection.get(visualRowIndex, visualEndCol); + + if (isObject$1(mergeParentForViewportEnd)) { + var mergeEnd = mergeParentForViewportEnd.col + mergeParentForViewportEnd.colspan - 1; + var renderableIndexAtMergeEnd = columnMapper.getRenderableFromVisualIndex(columnMapper.getFirstNotHiddenIndex(mergeEnd, -1)); // Merge end is out of the viewport. + + if (renderableIndexAtMergeEnd > calc.endColumn) { + // We extend the viewport when some columns have been merged. + calc.endColumn = renderableIndexAtMergeEnd; // We are looking for next merges inside already extended viewport (starting again from column equal to 0). + + this.modifyViewportColumnEnd(calc, nrOfRows); // recursively search upwards + + return; // Finish the current loop. Everything will be checked from the beginning by above recursion. + } + } + } + } + /** + * Translates merged cell coordinates to renderable indexes. + * + * @private + * @param {number} parentRow Visual row index. + * @param {number} rowspan Rowspan which describes shift which will be applied to parent row + * to calculate renderable index which points to the most bottom + * index position. Pass rowspan as `0` to calculate the most top + * index position. + * @param {number} parentColumn Visual column index. + * @param {number} colspan Colspan which describes shift which will be applied to parent column + * to calculate renderable index which points to the most right + * index position. Pass colspan as `0` to calculate the most left + * index position. + * @returns {number[]} + */ + + }, { + key: "translateMergedCellToRenderable", + value: function translateMergedCellToRenderable(parentRow, rowspan, parentColumn, colspan) { + var _this$hot4 = this.hot, + rowMapper = _this$hot4.rowIndexMapper, + columnMapper = _this$hot4.columnIndexMapper; + var firstNonHiddenRow; + var firstNonHiddenColumn; + + if (rowspan === 0) { + firstNonHiddenRow = rowMapper.getFirstNotHiddenIndex(parentRow, 1); + } else { + firstNonHiddenRow = rowMapper.getFirstNotHiddenIndex(parentRow + rowspan - 1, -1); + } + + if (colspan === 0) { + firstNonHiddenColumn = columnMapper.getFirstNotHiddenIndex(parentColumn, 1); + } else { + firstNonHiddenColumn = columnMapper.getFirstNotHiddenIndex(parentColumn + colspan - 1, -1); + } + + var renderableRow = parentRow >= 0 ? rowMapper.getRenderableFromVisualIndex(firstNonHiddenRow) : parentRow; + var renderableColumn = parentColumn >= 0 ? columnMapper.getRenderableFromVisualIndex(firstNonHiddenColumn) : parentColumn; + return [renderableRow, renderableColumn]; + } + /** + * The `modifyAutofillRange` hook callback. + * + * @private + * @param {Array} drag The drag area coordinates. + * @param {Array} select The selection information. + * @returns {Array} The new drag area. + */ + + }, { + key: "onModifyAutofillRange", + value: function onModifyAutofillRange(drag, select) { + this.autofillCalculations.correctSelectionAreaSize(select); + var dragDirection = this.autofillCalculations.getDirection(select, drag); + var dragArea = drag; + + if (this.autofillCalculations.dragAreaOverlapsCollections(select, dragArea, dragDirection)) { + dragArea = select; + return dragArea; + } + + var mergedCellsWithinSelectionArea = this.mergedCellsCollection.getWithinRange({ + from: { + row: select[0], + col: select[1] + }, + to: { + row: select[2], + col: select[3] + } + }); + + if (!mergedCellsWithinSelectionArea) { + return dragArea; + } + + dragArea = this.autofillCalculations.snapDragArea(select, dragArea, dragDirection, mergedCellsWithinSelectionArea); + return dragArea; + } + /** + * `afterCreateCol` hook callback. + * + * @private + * @param {number} column Column index. + * @param {number} count Number of created columns. + */ + + }, { + key: "onAfterCreateCol", + value: function onAfterCreateCol(column, count) { + this.mergedCellsCollection.shiftCollections('right', column, count); + } + /** + * `afterRemoveCol` hook callback. + * + * @private + * @param {number} column Column index. + * @param {number} count Number of removed columns. + */ + + }, { + key: "onAfterRemoveCol", + value: function onAfterRemoveCol(column, count) { + this.mergedCellsCollection.shiftCollections('left', column, count); + } + /** + * `afterCreateRow` hook callback. + * + * @private + * @param {number} row Row index. + * @param {number} count Number of created rows. + * @param {string} source Source of change. + */ + + }, { + key: "onAfterCreateRow", + value: function onAfterCreateRow(row, count, source) { + if (source === 'auto') { + return; + } + + this.mergedCellsCollection.shiftCollections('down', row, count); + } + /** + * `afterRemoveRow` hook callback. + * + * @private + * @param {number} row Row index. + * @param {number} count Number of removed rows. + */ + + }, { + key: "onAfterRemoveRow", + value: function onAfterRemoveRow(row, count) { + this.mergedCellsCollection.shiftCollections('up', row, count); + } + /** + * `afterChange` hook callback. Used to propagate merged cells after using Autofill. + * + * @private + * @param {Array} changes The changes array. + * @param {string} source Determines the source of the change. + */ + + }, { + key: "onAfterChange", + value: function onAfterChange(changes, source) { + if (source !== 'Autofill.fill') { + return; + } + + this.autofillCalculations.recreateAfterDataPopulation(changes); + } + /** + * `beforeDrawAreaBorders` hook callback. + * + * @private + * @param {Array} corners Visual coordinates of the area corners. + * @param {string} className Class name for the area. + */ + + }, { + key: "onBeforeDrawAreaBorders", + value: function onBeforeDrawAreaBorders(corners, className) { + if (className && className === 'area') { + var selectedRange = this.hot.getSelectedRangeLast(); + var mergedCellsWithinRange = this.mergedCellsCollection.getWithinRange(selectedRange); + arrayEach(mergedCellsWithinRange, function (mergedCell) { + if (selectedRange.getBottomRightCorner().row === mergedCell.getLastRow() && selectedRange.getBottomRightCorner().col === mergedCell.getLastColumn()) { + corners[2] = mergedCell.row; + corners[3] = mergedCell.col; + } + }); + } + } + /** + * `afterModifyTransformStart` hook callback. Fixes a problem with navigating through merged cells at the edges of the table + * with the ENTER/SHIFT+ENTER/TAB/SHIFT+TAB keys. + * + * @private + * @param {CellCoords} coords Coordinates of the to-be-selected cell. + * @param {number} rowTransformDir Row transformation direction (negative value = up, 0 = none, positive value = down). + * @param {number} colTransformDir Column transformation direction (negative value = up, 0 = none, positive value = down). + */ + + }, { + key: "onAfterModifyTransformStart", + value: function onAfterModifyTransformStart(coords, rowTransformDir, colTransformDir) { + if (!this.enabled) { + return; + } + + var mergedCellAtCoords = this.mergedCellsCollection.get(coords.row, coords.col); + + if (!mergedCellAtCoords) { + return; + } + + var goingDown = rowTransformDir > 0; + var goingUp = rowTransformDir < 0; + var goingLeft = colTransformDir < 0; + var goingRight = colTransformDir > 0; + var mergedCellOnBottomEdge = mergedCellAtCoords.row + mergedCellAtCoords.rowspan - 1 === this.hot.countRows() - 1; + var mergedCellOnTopEdge = mergedCellAtCoords.row === 0; + var mergedCellOnRightEdge = mergedCellAtCoords.col + mergedCellAtCoords.colspan - 1 === this.hot.countCols() - 1; + var mergedCellOnLeftEdge = mergedCellAtCoords.col === 0; + + if (goingDown && mergedCellOnBottomEdge || goingUp && mergedCellOnTopEdge || goingRight && mergedCellOnRightEdge || goingLeft && mergedCellOnLeftEdge) { + coords.row = mergedCellAtCoords.row; + coords.col = mergedCellAtCoords.col; + } + } + /** + * `afterDrawSelection` hook callback. Used to add the additional class name for the entirely-selected merged cells. + * + * @private + * @param {number} currentRow Visual row index of the currently processed cell. + * @param {number} currentColumn Visual column index of the currently cell. + * @param {Array} cornersOfSelection Array of the current selection in a form of `[startRow, startColumn, endRow, endColumn]`. + * @param {number|undefined} layerLevel Number indicating which layer of selection is currently processed. + * @returns {string|undefined} A `String`, which will act as an additional `className` to be added to the currently processed cell. + */ + + }, { + key: "onAfterDrawSelection", + value: function onAfterDrawSelection(currentRow, currentColumn, cornersOfSelection, layerLevel) { + // Nothing's selected (hook might be triggered by the custom borders) + if (!cornersOfSelection) { + return; + } + + return this.selectionCalculations.getSelectedMergedCellClassName(currentRow, currentColumn, cornersOfSelection, layerLevel); + } + /** + * `beforeRemoveCellClassNames` hook callback. Used to remove additional class name from all cells in the table. + * + * @private + * @returns {string[]} An `Array` of `String`s. Each of these strings will act like class names to be removed from all the cells in the table. + */ + + }, { + key: "onBeforeRemoveCellClassNames", + value: function onBeforeRemoveCellClassNames() { + return this.selectionCalculations.getSelectedMergedCellClassNameToRemove(); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$g; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$f; + } + }]); + + return MergeCells; +}(BasePlugin); + +function _typeof$11(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$11 = function _typeof(obj) { return typeof obj; }; } else { _typeof$11 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$11(obj); } + +function _classCallCheck$1T(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1N(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); } } + +function _createClass$1N(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1N(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1N(Constructor, staticProps); return Constructor; } + +function _get$v(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$v = Reflect.get; } else { _get$v = function _get(target, property, receiver) { var base = _superPropBase$v(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$v(target, property, receiver || target); } + +function _superPropBase$v(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$S(object); if (object === null) break; } return object; } + +function _inherits$S(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$T(subClass, superClass); } + +function _setPrototypeOf$T(o, p) { _setPrototypeOf$T = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$T(o, p); } + +function _createSuper$S(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$T(); return function _createSuperInternal() { var Super = _getPrototypeOf$S(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$S(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$S(this, result); }; } + +function _possibleConstructorReturn$S(self, call) { if (call && (_typeof$11(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$S(self); } + +function _assertThisInitialized$S(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$T() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$S(o) { _getPrototypeOf$S = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$S(o); } +var PLUGIN_KEY$h = 'multipleSelectionHandles'; +var PLUGIN_PRIORITY$g = 160; +/** + * @private + * @plugin MultipleSelectionHandles + */ + +var MultipleSelectionHandles = /*#__PURE__*/function (_BasePlugin) { + _inherits$S(MultipleSelectionHandles, _BasePlugin); + + var _super = _createSuper$S(MultipleSelectionHandles); + + /** + * @param {object} hotInstance The handsontable instance. + */ + function MultipleSelectionHandles(hotInstance) { + var _this2; + + _classCallCheck$1T(this, MultipleSelectionHandles); + + _this2 = _super.call(this, hotInstance); + /** + * @type {Array} + */ + + _this2.dragged = []; + /** + * Instance of EventManager. + * + * @type {EventManager} + */ + + _this2.eventManager = null; + /** + * @type {null} + */ + + _this2.lastSetCell = null; + return _this2; + } + /** + * Check if the plugin is enabled in the handsontable settings. + * + * @returns {boolean} + */ + + + _createClass$1N(MultipleSelectionHandles, [{ + key: "isEnabled", + value: function isEnabled() { + return isMobileBrowser(); + } + /** + * Enable plugin for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + if (this.enabled) { + return; + } + + if (!this.eventManager) { + this.eventManager = new EventManager(this); + } + + this.registerListeners(); + + _get$v(_getPrototypeOf$S(MultipleSelectionHandles.prototype), "enablePlugin", this).call(this); + } + /** + * Bind the touch events. + * + * @private + */ + + }, { + key: "registerListeners", + value: function registerListeners() { + var _this3 = this; + + var _this = this; + + var rootElement = this.hot.rootElement; + /** + * @param {string} query Query for the position. + * @returns {boolean} + */ + + function removeFromDragged(query) { + if (_this.dragged.length === 1) { + // clear array + _this.dragged.splice(0, _this.dragged.length); + + return true; + } + + var entryPosition = _this.dragged.indexOf(query); + + if (entryPosition === -1) { + return false; + } else if (entryPosition === 0) { + _this.dragged = _this.dragged.slice(0, 1); + } else if (entryPosition === 1) { + _this.dragged = _this.dragged.slice(-1); + } + } + + this.eventManager.addEventListener(rootElement, 'touchstart', function (event) { + var selectedRange; + + if (hasClass(event.target, 'topLeftSelectionHandle-HitArea')) { + selectedRange = _this.hot.getSelectedRangeLast(); + + _this.dragged.push('topLeft'); + + _this.touchStartRange = { + width: selectedRange.getWidth(), + height: selectedRange.getHeight(), + direction: selectedRange.getDirection() + }; + event.preventDefault(); + return false; + } else if (hasClass(event.target, 'bottomRightSelectionHandle-HitArea')) { + selectedRange = _this.hot.getSelectedRangeLast(); + + _this.dragged.push('bottomRight'); + + _this.touchStartRange = { + width: selectedRange.getWidth(), + height: selectedRange.getHeight(), + direction: selectedRange.getDirection() + }; + event.preventDefault(); + return false; + } + }); + this.eventManager.addEventListener(rootElement, 'touchend', function (event) { + if (hasClass(event.target, 'topLeftSelectionHandle-HitArea')) { + removeFromDragged.call(_this, 'topLeft'); + _this.touchStartRange = void 0; + event.preventDefault(); + return false; + } else if (hasClass(event.target, 'bottomRightSelectionHandle-HitArea')) { + removeFromDragged.call(_this, 'bottomRight'); + _this.touchStartRange = void 0; + event.preventDefault(); + return false; + } + }); + this.eventManager.addEventListener(rootElement, 'touchmove', function (event) { + var _this3$hot = _this3.hot, + rootWindow = _this3$hot.rootWindow, + rootDocument = _this3$hot.rootDocument; + var scrollTop = getWindowScrollTop(rootWindow); + var scrollLeft = getWindowScrollLeft(rootWindow); + var targetCoords; + var selectedRange; + var rangeWidth; + var rangeHeight; + var rangeDirection; + var newRangeCoords; + + if (_this.dragged.length === 0) { + return; + } + + var endTarget = rootDocument.elementFromPoint(event.touches[0].screenX - scrollLeft, event.touches[0].screenY - scrollTop); + + if (!endTarget || endTarget === _this.lastSetCell) { + return; + } + + if (endTarget.nodeName === 'TD' || endTarget.nodeName === 'TH') { + targetCoords = _this.hot.getCoords(endTarget); + + if (targetCoords.col === -1) { + targetCoords.col = 0; + } + + selectedRange = _this.hot.getSelectedRangeLast(); + rangeWidth = selectedRange.getWidth(); + rangeHeight = selectedRange.getHeight(); + rangeDirection = selectedRange.getDirection(); + + if (rangeWidth === 1 && rangeHeight === 1) { + _this.hot.selection.setRangeEnd(targetCoords); + } + + newRangeCoords = _this.getCurrentRangeCoords(selectedRange, targetCoords, _this.touchStartRange.direction, rangeDirection, _this.dragged[0]); + + if (newRangeCoords.start !== null) { + _this.hot.selection.setRangeStart(newRangeCoords.start); + } + + _this.hot.selection.setRangeEnd(newRangeCoords.end); + + _this.lastSetCell = endTarget; + } + + event.preventDefault(); + }); + } + }, { + key: "getCurrentRangeCoords", + value: function getCurrentRangeCoords(selectedRange, currentTouch, touchStartDirection, currentDirection, draggedHandle) { + var topLeftCorner = selectedRange.getTopLeftCorner(); + var bottomRightCorner = selectedRange.getBottomRightCorner(); + var bottomLeftCorner = selectedRange.getBottomLeftCorner(); + var topRightCorner = selectedRange.getTopRightCorner(); + var newCoords = { + start: null, + end: null + }; + + switch (touchStartDirection) { + case 'NE-SW': + switch (currentDirection) { + case 'NE-SW': + case 'NW-SE': + if (draggedHandle === 'topLeft') { + newCoords = { + start: new CellCoords(currentTouch.row, selectedRange.highlight.col), + end: new CellCoords(bottomLeftCorner.row, currentTouch.col) + }; + } else { + newCoords = { + start: new CellCoords(selectedRange.highlight.row, currentTouch.col), + end: new CellCoords(currentTouch.row, topLeftCorner.col) + }; + } + + break; + + case 'SE-NW': + if (draggedHandle === 'bottomRight') { + newCoords = { + start: new CellCoords(bottomRightCorner.row, currentTouch.col), + end: new CellCoords(currentTouch.row, topLeftCorner.col) + }; + } + + break; + } + + break; + + case 'NW-SE': + switch (currentDirection) { + case 'NE-SW': + if (draggedHandle === 'topLeft') { + newCoords = { + start: currentTouch, + end: bottomLeftCorner + }; + } else { + newCoords.end = currentTouch; + } + + break; + + case 'NW-SE': + if (draggedHandle === 'topLeft') { + newCoords = { + start: currentTouch, + end: bottomRightCorner + }; + } else { + newCoords.end = currentTouch; + } + + break; + + case 'SE-NW': + if (draggedHandle === 'topLeft') { + newCoords = { + start: currentTouch, + end: topLeftCorner + }; + } else { + newCoords.end = currentTouch; + } + + break; + + case 'SW-NE': + if (draggedHandle === 'topLeft') { + newCoords = { + start: currentTouch, + end: topRightCorner + }; + } else { + newCoords.end = currentTouch; + } + + break; + } + + break; + + case 'SW-NE': + switch (currentDirection) { + case 'NW-SE': + if (draggedHandle === 'bottomRight') { + newCoords = { + start: new CellCoords(currentTouch.row, topLeftCorner.col), + end: new CellCoords(bottomLeftCorner.row, currentTouch.col) + }; + } else { + newCoords = { + start: new CellCoords(topLeftCorner.row, currentTouch.col), + end: new CellCoords(currentTouch.row, bottomRightCorner.col) + }; + } + + break; + // case 'NE-SW': + // + // break; + + case 'SW-NE': + if (draggedHandle === 'topLeft') { + newCoords = { + start: new CellCoords(selectedRange.highlight.row, currentTouch.col), + end: new CellCoords(currentTouch.row, bottomRightCorner.col) + }; + } else { + newCoords = { + start: new CellCoords(currentTouch.row, topLeftCorner.col), + end: new CellCoords(topLeftCorner.row, currentTouch.col) + }; + } + + break; + + case 'SE-NW': + if (draggedHandle === 'bottomRight') { + newCoords = { + start: new CellCoords(currentTouch.row, topRightCorner.col), + end: new CellCoords(topLeftCorner.row, currentTouch.col) + }; + } else if (draggedHandle === 'topLeft') { + newCoords = { + start: bottomLeftCorner, + end: currentTouch + }; + } + + break; + } + + break; + + case 'SE-NW': + switch (currentDirection) { + case 'NW-SE': + case 'NE-SW': + case 'SW-NE': + if (draggedHandle === 'topLeft') { + newCoords.end = currentTouch; + } + + break; + + case 'SE-NW': + if (draggedHandle === 'topLeft') { + newCoords.end = currentTouch; + } else { + newCoords = { + start: currentTouch, + end: topLeftCorner + }; + } + + break; + } + + break; + } + + return newCoords; + } + /** + * Check if user is currently dragging the handle. + * + * @returns {boolean} Dragging state. + */ + + }, { + key: "isDragged", + value: function isDragged() { + return this.dragged.length > 0; + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$h; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$g; + } + }]); + + return MultipleSelectionHandles; +}(BasePlugin); + +function _toArray$1(arr) { return _arrayWithHoles$r(arr) || _iterableToArray$l(arr) || _unsupportedIterableToArray$D(arr) || _nonIterableRest$r(); } + +function _nonIterableRest$r() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$D(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$D(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$D(o, minLen); } + +function _arrayLikeToArray$D(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArray$l(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithHoles$r(arr) { if (Array.isArray(arr)) return arr; } +/** + * Sort comparator handled by conventional sort algorithm. + * + * @param {Array} sortingOrders Sort orders (`asc` for ascending, `desc` for descending). + * @param {Array} columnMetas Column meta objects. + * @returns {Function} + */ + +function rootComparator$1(sortingOrders, columnMetas) { + return function (rowIndexWithValues, nextRowIndexWithValues) { + // We sort array of arrays. Single array is in form [rowIndex, ...values]. + // We compare just values, stored at second index of array. + var _rowIndexWithValues = _toArray$1(rowIndexWithValues), + values = _rowIndexWithValues.slice(1); + + var _nextRowIndexWithValu = _toArray$1(nextRowIndexWithValues), + nextValues = _nextRowIndexWithValu.slice(1); + + return function getCompareResult(column) { + var sortingOrder = sortingOrders[column]; + var columnMeta = columnMetas[column]; + var value = values[column]; + var nextValue = nextValues[column]; + var pluginSettings = columnMeta.multiColumnSorting; + var compareFunctionFactory = pluginSettings.compareFunctionFactory ? pluginSettings.compareFunctionFactory : getCompareFunctionFactory(columnMeta.type); + var compareResult = compareFunctionFactory(sortingOrder, columnMeta, pluginSettings)(value, nextValue); + + if (compareResult === DO_NOT_SWAP) { + var nextSortedColumn = column + 1; + + if (typeof columnMetas[nextSortedColumn] !== 'undefined') { + return getCompareResult(nextSortedColumn); + } + } + + return compareResult; + }(0); + }; +} + +var _templateObject$7; + +function _taggedTemplateLiteral$7(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } +/** + * Warn users about problems when using `columnSorting` and `multiColumnSorting` plugins simultaneously. + */ + +function warnAboutPluginsConflict() { + warn(toSingleLine(_templateObject$7 || (_templateObject$7 = _taggedTemplateLiteral$7(["Plugins `columnSorting` and `multiColumnSorting` should not be enabled simultaneously. \n Only `multiColumnSorting` will work."], ["Plugins \\`columnSorting\\` and \\`multiColumnSorting\\` should not be enabled simultaneously. \n Only \\`multiColumnSorting\\` will work."])))); +} + +var COLUMN_ORDER_PREFIX = 'sort'; +/** + * Get CSS classes which should be added to particular column header. + * + * @param {object} columnStatesManager Instance of column state manager. + * @param {number} column Visual column index. + * @param {boolean} showSortIndicator Indicates if indicator should be shown for the particular column. + * @returns {Array} Array of CSS classes. + */ + +function getClassesToAdd$1(columnStatesManager, column, showSortIndicator) { + var cssClasses = []; + + if (showSortIndicator === false) { + return cssClasses; + } + + if (columnStatesManager.isColumnSorted(column) && columnStatesManager.getNumberOfSortedColumns() > 1) { + cssClasses.push("".concat(COLUMN_ORDER_PREFIX, "-").concat(columnStatesManager.getIndexOfColumnInSortQueue(column) + 1)); + } + + return cssClasses; +} +/** + * Get CSS classes which should be removed from column header. + * + * @param {HTMLElement} htmlElement An element to process. + * @returns {Array} Array of CSS classes. + */ + +function getClassesToRemove$1(htmlElement) { + var cssClasses = htmlElement.className.split(' '); + var sortSequenceRegExp = new RegExp("^".concat(COLUMN_ORDER_PREFIX, "-[0-9]{1,2}$")); + return cssClasses.filter(function (cssClass) { + return sortSequenceRegExp.test(cssClass); + }); +} + +function _typeof$12(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$12 = function _typeof(obj) { return typeof obj; }; } else { _typeof$12 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$12(obj); } + +function _classCallCheck$1U(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1O(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); } } + +function _createClass$1O(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1O(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1O(Constructor, staticProps); return Constructor; } + +function _get$w(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$w = Reflect.get; } else { _get$w = function _get(target, property, receiver) { var base = _superPropBase$w(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$w(target, property, receiver || target); } + +function _superPropBase$w(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$T(object); if (object === null) break; } return object; } + +function _inherits$T(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$U(subClass, superClass); } + +function _setPrototypeOf$U(o, p) { _setPrototypeOf$U = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$U(o, p); } + +function _createSuper$T(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$U(); return function _createSuperInternal() { var Super = _getPrototypeOf$T(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$T(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$T(this, result); }; } + +function _possibleConstructorReturn$T(self, call) { if (call && (_typeof$12(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$T(self); } + +function _assertThisInitialized$T(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$U() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$T(o) { _getPrototypeOf$T = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$T(o); } +var PLUGIN_KEY$i = 'multiColumnSorting'; +var PLUGIN_PRIORITY$h = 170; +var APPEND_COLUMN_CONFIG_STRATEGY$1 = 'append'; +var CONFLICTED_PLUGIN_KEY = 'columnSorting'; +registerRootComparator(PLUGIN_KEY$i, rootComparator$1); +/** + * @plugin MultiColumnSorting + * + * @description + * This plugin sorts the view by columns (but does not sort the data source!). To enable the plugin, set the + * {@link Options#multiColumnSorting} property to the correct value (see the examples below). + * + * @example + * ```js + * // as boolean + * multiColumnSorting: true + * + * // as an object with initial sort config (sort ascending for column at index 1 and then sort descending for column at index 0) + * multiColumnSorting: { + * initialConfig: [{ + * column: 1, + * sortOrder: 'asc' + * }, { + * column: 0, + * sortOrder: 'desc' + * }] + * } + * + * // as an object which define specific sorting options for all columns + * multiColumnSorting: { + * sortEmptyCells: true, // true = the table sorts empty cells, false = the table moves all empty cells to the end of the table (by default) + * indicator: true, // true = shows indicator for all columns (by default), false = don't show indicator for columns + * headerAction: true, // true = allow to click on the headers to sort (by default), false = turn off possibility to click on the headers to sort + * compareFunctionFactory: function(sortOrder, columnMeta) { + * return function(value, nextValue) { + * // Some value comparisons which will return -1, 0 or 1... + * } + * } + * } + * + * // as an object passed to the `column` property, allows specifying a custom options for the desired column. + * // please take a look at documentation of `column` property: https://handsontable.com/docs/Options.html#columns + * columns: [{ + * multiColumnSorting: { + * indicator: false, // disable indicator for the first column, + * sortEmptyCells: true, + * headerAction: false, // clicks on the first column won't sort + * compareFunctionFactory: function(sortOrder, columnMeta) { + * return function(value, nextValue) { + * return 0; // Custom compare function for the first column (don't sort) + * } + * } + * } + * }]``` + */ + +var MultiColumnSorting = /*#__PURE__*/function (_ColumnSorting) { + _inherits$T(MultiColumnSorting, _ColumnSorting); + + var _super = _createSuper$T(MultiColumnSorting); + + function MultiColumnSorting(hotInstance) { + var _this; + + _classCallCheck$1U(this, MultiColumnSorting); + + _this = _super.call(this, hotInstance); + /** + * Main settings key designed for the plugin. + * + * @private + * @type {string} + */ + + _this.pluginKey = PLUGIN_KEY$i; + return _this; + } + /** + * Checks if the plugin is enabled in the Handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link MultiColumnSorting#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1O(MultiColumnSorting, [{ + key: "isEnabled", + value: function isEnabled() { + return _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "isEnabled", this).call(this); + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + if (!this.enabled && this.hot.getSettings()[this.pluginKey] && this.hot.getSettings()[CONFLICTED_PLUGIN_KEY]) { + warnAboutPluginsConflict(); + } + + _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "disablePlugin", this).call(this); + } + /** + * Sorts the table by chosen columns and orders. + * + * @param {undefined|object|Array} sortConfig Single column sort configuration or full sort configuration (for all sorted columns). + * The configuration object contains `column` and `sortOrder` properties. First of them contains visual column index, the second one contains + * sort order (`asc` for ascending, `desc` for descending). + * + * **Note**: Please keep in mind that every call of `sort` function set an entirely new sort order. Previous sort configs aren't preserved. + * + * @example + * ```js + * // sort ascending first visual column + * hot.getPlugin('multiColumnSorting').sort({ column: 0, sortOrder: 'asc' }); + * + * // sort first two visual column in the defined sequence + * hot.getPlugin('multiColumnSorting').sort([{ + * column: 1, sortOrder: 'asc' + * }, { + * column: 0, sortOrder: 'desc' + * }]); + * ``` + * + * @fires Hooks#beforeColumnSort + * @fires Hooks#afterColumnSort + */ + + }, { + key: "sort", + value: function sort(sortConfig) { + _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "sort", this).call(this, sortConfig); + } + /** + * Clear the sort performed on the table. + */ + + }, { + key: "clearSort", + value: function clearSort() { + _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "clearSort", this).call(this); + } + /** + * Checks if the table is sorted (any column have to be sorted). + * + * @returns {boolean} + */ + + }, { + key: "isSorted", + value: function isSorted() { + return _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "isSorted", this).call(this); + } + /** + * Get sort configuration for particular column or for all sorted columns. Objects contain `column` and `sortOrder` properties. + * + * **Note**: Please keep in mind that returned objects expose **visual** column index under the `column` key. They are handled by the `sort` function. + * + * @param {number} [column] Visual column index. + * @returns {undefined|object|Array} + */ + + }, { + key: "getSortConfig", + value: function getSortConfig(column) { + return _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "getSortConfig", this).call(this, column); + } + /** + * @description + * Warn: Useful mainly for providing server side sort implementation (see in the example below). It doesn't sort the data set. It just sets sort configuration for all sorted columns. + * Note: Please keep in mind that this method doesn't re-render the table. + * + * @example + * ```js + * beforeColumnSort: function(currentSortConfig, destinationSortConfigs) { + * const columnSortPlugin = this.getPlugin('multiColumnSorting'); + * + * columnSortPlugin.setSortConfig(destinationSortConfigs); + * + * // const newData = ... // Calculated data set, ie. from an AJAX call. + * + * this.loadData(newData); // Load new data set and re-render the table. + * + * return false; // The blockade for the default sort action. + * }``` + * + * @param {undefined|object|Array} sortConfig Single column sort configuration or full sort configuration (for all sorted columns). + * The configuration object contains `column` and `sortOrder` properties. First of them contains visual column index, the second one contains + * sort order (`asc` for ascending, `desc` for descending). + */ + + }, { + key: "setSortConfig", + value: function setSortConfig(sortConfig) { + _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "setSortConfig", this).call(this, sortConfig); + } + /** + * Get normalized sort configs. + * + * @private + * @param {object|Array} [sortConfig=[]] Single column sort configuration or full sort configuration (for all sorted columns). + * The configuration object contains `column` and `sortOrder` properties. First of them contains visual column index, the second one contains + * sort order (`asc` for ascending, `desc` for descending). + * @returns {Array} + */ + + }, { + key: "getNormalizedSortConfigs", + value: function getNormalizedSortConfigs() { + var sortConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + + if (Array.isArray(sortConfig)) { + return sortConfig; + } + + return [sortConfig]; + } + /** + * Update header classes. + * + * @private + * @param {HTMLElement} headerSpanElement Header span element. + * @param {...*} args Extra arguments for helpers. + */ + + }, { + key: "updateHeaderClasses", + value: function updateHeaderClasses(headerSpanElement) { + var _get2; + + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + (_get2 = _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "updateHeaderClasses", this)).call.apply(_get2, [this, headerSpanElement].concat(args)); + + removeClass(headerSpanElement, getClassesToRemove$1(headerSpanElement)); + + if (this.enabled !== false) { + addClass(headerSpanElement, getClassesToAdd$1.apply(void 0, args)); + } + } + /** + * Overwriting base plugin's `onUpdateSettings` method. Please keep in mind that `onAfterUpdateSettings` isn't called + * for `updateSettings` in specific situations. + * + * @private + * @param {object} newSettings New settings object. + */ + + }, { + key: "onUpdateSettings", + value: function onUpdateSettings(newSettings) { + if (this.hot.getSettings()[this.pluginKey] && this.hot.getSettings()[CONFLICTED_PLUGIN_KEY]) { + warnAboutPluginsConflict(); + } + + _get$w(_getPrototypeOf$T(MultiColumnSorting.prototype), "onUpdateSettings", this).call(this, newSettings); + } + /** + * Callback for the `onAfterOnCellMouseDown` hook. + * + * @private + * @param {Event} event Event which are provided by hook. + * @param {CellCoords} coords Visual coords of the selected cell. + */ + + }, { + key: "onAfterOnCellMouseDown", + value: function onAfterOnCellMouseDown(event, coords) { + if (wasHeaderClickedProperly(coords.row, coords.col, event) === false) { + return; + } + + if (this.wasClickableHeaderClicked(event, coords.col)) { + if (isPressedCtrlKey()) { + this.hot.deselectCell(); + this.hot.selectColumns(coords.col); + this.sort(this.getNextSortConfig(coords.col, APPEND_COLUMN_CONFIG_STRATEGY$1)); + } else { + this.sort(this.getColumnNextConfig(coords.col)); + } + } + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$i; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$h; + } + }]); + + return MultiColumnSorting; +}(ColumnSorting); + +function _typeof$13(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$13 = function _typeof(obj) { return typeof obj; }; } else { _typeof$13 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$13(obj); } + +/*! + * https://github.com/Starcounter-Jack/JSON-Patch + * json-patch-duplex.js version: 0.5.7 + * (c) 2013 Joachim Wester + * MIT license + */ +var __extends = undefined && undefined.__extends || function (d, b) { + for (var p in b) { + if (b.hasOwnProperty(p)) d[p] = b[p]; + } + + function __() { + this.constructor = d; + } + + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; + +var OriginalError = Error; +var jsonpatch; + +(function (jsonpatch) { + var _objectKeys = function _objectKeys(obj) { + if (_isArray(obj)) { + var keys = new Array(obj.length); + + for (var k = 0; k < keys.length; k++) { + keys[k] = "" + k; + } + + return keys; + } + + if (Object.keys) { + return Object.keys(obj); + } + + var keys = []; + + for (var i in obj) { + if (obj.hasOwnProperty(i)) { + keys.push(i); + } + } + + return keys; + }; + + function _equals(a, b) { + switch (_typeof$13(a)) { + case 'undefined': //backward compatibility, but really I think we should return false + + case 'boolean': + case 'string': + case 'number': + return a === b; + + case 'object': + if (a === null) return b === null; + + if (_isArray(a)) { + if (!_isArray(b) || a.length !== b.length) return false; + + for (var i = 0, l = a.length; i < l; i++) { + if (!_equals(a[i], b[i])) return false; + } + + return true; + } + + var bKeys = _objectKeys(b); + + var bLength = bKeys.length; + if (_objectKeys(a).length !== bLength) return false; + + for (var i = 0; i < bLength; i++) { + if (!_equals(a[i], b[i])) return false; + } + + return true; + + default: + return false; + } + } + /* We use a Javascript hash to store each + function. Each hash entry (property) uses + the operation identifiers specified in rfc6902. + In this way, we can map each patch operation + to its dedicated function in efficient way. + */ + + /* The operations applicable to an object */ + + + var objOps = { + add: function add(obj, key) { + obj[key] = this.value; + return true; + }, + remove: function remove(obj, key) { + delete obj[key]; + return true; + }, + replace: function replace(obj, key) { + obj[key] = this.value; + return true; + }, + move: function move(obj, key, tree) { + var temp = { + op: "_get", + path: this.from + }; + apply(tree, [temp]); + apply(tree, [{ + op: "remove", + path: this.from + }]); + apply(tree, [{ + op: "add", + path: this.path, + value: temp.value + }]); + return true; + }, + copy: function copy(obj, key, tree) { + var temp = { + op: "_get", + path: this.from + }; + apply(tree, [temp]); + apply(tree, [{ + op: "add", + path: this.path, + value: temp.value + }]); + return true; + }, + test: function test(obj, key) { + return _equals(obj[key], this.value); + }, + _get: function _get(obj, key) { + this.value = obj[key]; + } + }; + /* The operations applicable to an array. Many are the same as for the object */ + + var arrOps = { + add: function add(arr, i) { + arr.splice(i, 0, this.value); + return true; + }, + remove: function remove(arr, i) { + arr.splice(i, 1); + return true; + }, + replace: function replace(arr, i) { + arr[i] = this.value; + return true; + }, + move: objOps.move, + copy: objOps.copy, + test: objOps.test, + _get: objOps._get + }; + /* The operations applicable to object root. Many are the same as for the object */ + + var rootOps = { + add: function add(obj) { + rootOps.remove.call(this, obj); + + for (var key in this.value) { + if (this.value.hasOwnProperty(key)) { + obj[key] = this.value[key]; + } + } + + return true; + }, + remove: function remove(obj) { + for (var key in obj) { + if (obj.hasOwnProperty(key)) { + objOps.remove.call(this, obj, key); + } + } + + return true; + }, + replace: function replace(obj) { + apply(obj, [{ + op: "remove", + path: this.path + }]); + apply(obj, [{ + op: "add", + path: this.path, + value: this.value + }]); + return true; + }, + move: objOps.move, + copy: objOps.copy, + test: function test(obj) { + return JSON.stringify(obj) === JSON.stringify(this.value); + }, + _get: function _get(obj) { + this.value = obj; + } + }; + + function escapePathComponent(str) { + if (str.indexOf('/') === -1 && str.indexOf('~') === -1) return str; + return str.replace(/~/g, '~0').replace(/\//g, '~1'); + } + + var beforeDict = []; + + var Mirror = function () { + function Mirror(obj) { + this.observers = []; + this.obj = obj; + } + + return Mirror; + }(); + + var ObserverInfo = function () { + function ObserverInfo(callback, observer) { + this.callback = callback; + this.observer = observer; + } + + return ObserverInfo; + }(); + + function getMirror(obj) { + for (var i = 0, ilen = beforeDict.length; i < ilen; i++) { + if (beforeDict[i].obj === obj) { + return beforeDict[i]; + } + } + } + + function getObserverFromMirror(mirror, callback) { + for (var j = 0, jlen = mirror.observers.length; j < jlen; j++) { + if (mirror.observers[j].callback === callback) { + return mirror.observers[j].observer; + } + } + } + + function removeObserverFromMirror(mirror, observer) { + for (var j = 0, jlen = mirror.observers.length; j < jlen; j++) { + if (mirror.observers[j].observer === observer) { + mirror.observers.splice(j, 1); + return; + } + } + } + + function unobserve(root, observer) { + observer.unobserve(); + } + + jsonpatch.unobserve = unobserve; + + function deepClone(obj) { + if (_typeof$13(obj) === "object") { + return JSON.parse(JSON.stringify(obj)); //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5 + } else { + return obj; //no need to clone primitives + } + } + + function observe(obj, callback) { + var patches = []; + var observer; + var mirror = getMirror(obj); + + if (!mirror) { + mirror = new Mirror(obj); + beforeDict.push(mirror); + } else { + observer = getObserverFromMirror(mirror, callback); + } + + if (observer) { + return observer; + } + + observer = {}; + mirror.value = deepClone(obj); + + if (callback) { + observer.callback = callback; + observer.next = null; + var intervals = this.intervals || [100, 1000, 10000, 60000]; + + if (intervals.push === void 0) { + throw new OriginalError("jsonpatch.intervals must be an array"); + } + + var currentInterval = 0; + + var dirtyCheck = function dirtyCheck() { + generate(observer); + }; + + var fastCheck = function fastCheck() { + clearTimeout(observer.next); + observer.next = setTimeout(function () { + dirtyCheck(); + currentInterval = 0; + observer.next = setTimeout(slowCheck, intervals[currentInterval++]); + }, 0); + }; + + var slowCheck = function slowCheck() { + dirtyCheck(); + if (currentInterval == intervals.length) currentInterval = intervals.length - 1; + observer.next = setTimeout(slowCheck, intervals[currentInterval++]); + }; + + if (typeof window !== 'undefined') { + if (window.addEventListener) { + window.addEventListener('mousedown', fastCheck); + window.addEventListener('mouseup', fastCheck); + window.addEventListener('keydown', fastCheck); + } else { + document.documentElement.attachEvent('onmousedown', fastCheck); + document.documentElement.attachEvent('onmouseup', fastCheck); + document.documentElement.attachEvent('onkeydown', fastCheck); + } + } + + observer.next = setTimeout(slowCheck, intervals[currentInterval++]); + } + + observer.patches = patches; + observer.object = obj; + + observer.unobserve = function () { + generate(observer); + clearTimeout(observer.next); + removeObserverFromMirror(mirror, observer); + + if (mirror.observers.length === 0) { + beforeDict.splice(beforeDict.indexOf(mirror), 1); + } + + if (typeof window !== 'undefined') { + if (window.removeEventListener) { + window.removeEventListener('mousedown', fastCheck); + window.removeEventListener('mouseup', fastCheck); + window.removeEventListener('keydown', fastCheck); + } else { + document.documentElement.detachEvent('onmousedown', fastCheck); + document.documentElement.detachEvent('onmouseup', fastCheck); + document.documentElement.detachEvent('onkeydown', fastCheck); + } + } + }; + + mirror.observers.push(new ObserverInfo(callback, observer)); + return observer; + } + + jsonpatch.observe = observe; + + function generate(observer) { + var mirror; + + for (var i = 0, ilen = beforeDict.length; i < ilen; i++) { + if (beforeDict[i].obj === observer.object) { + mirror = beforeDict[i]; + break; + } + } + + _generate(mirror.value, observer.object, observer.patches, ""); + + if (observer.patches.length) { + apply(mirror.value, observer.patches); + } + + var temp = observer.patches; + + if (temp.length > 0) { + observer.patches = []; + + if (observer.callback) { + observer.callback(temp); + } + } + + return temp; + } + + jsonpatch.generate = generate; // Dirty check if obj is different from mirror, generate patches and update mirror + + function _generate(mirror, obj, patches, path) { + var newKeys = _objectKeys(obj); + + var oldKeys = _objectKeys(mirror); + var deleted = false; //if ever "move" operation is implemented here, make sure this test runs OK: "should not generate the same patch twice (move)" + + for (var t = oldKeys.length - 1; t >= 0; t--) { + var key = oldKeys[t]; + var oldVal = mirror[key]; + + if (obj.hasOwnProperty(key)) { + var newVal = obj[key]; + + if (_typeof$13(oldVal) == "object" && oldVal != null && _typeof$13(newVal) == "object" && newVal != null) { + _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key)); + } else { + if (oldVal != newVal) { + patches.push({ + op: "replace", + path: path + "/" + escapePathComponent(key), + value: deepClone(newVal) + }); + } + } + } else { + patches.push({ + op: "remove", + path: path + "/" + escapePathComponent(key) + }); + deleted = true; // property has been deleted + } + } + + if (!deleted && newKeys.length == oldKeys.length) { + return; + } + + for (var t = 0; t < newKeys.length; t++) { + var key = newKeys[t]; + + if (!mirror.hasOwnProperty(key)) { + patches.push({ + op: "add", + path: path + "/" + escapePathComponent(key), + value: deepClone(obj[key]) + }); + } + } + } + + var _isArray; + + if (Array.isArray) { + _isArray = Array.isArray; + } else { + _isArray = function _isArray(obj) { + return obj.push && typeof obj.length === 'number'; + }; + } //3x faster than cached /^\d+$/.test(str) + + + function isInteger(str) { + var i = 0; + var len = str.length; + var charCode; + + while (i < len) { + charCode = str.charCodeAt(i); + + if (charCode >= 48 && charCode <= 57) { + i++; + continue; + } + + return false; + } + + return true; + } /// Apply a json-patch operation on an object tree + + + function apply(tree, patches, validate) { + var result = false, + p = 0, + plen = patches.length, + patch, + key; + + while (p < plen) { + patch = patches[p]; + p++; // Find the object + + var path = patch.path || ""; + var keys = path.split('/'); + var obj = tree; + var t = 1; //skip empty element - http://jsperf.com/to-shift-or-not-to-shift + + var len = keys.length; + var existingPathFragment = undefined; + + while (true) { + key = keys[t]; + + if (validate) { + if (existingPathFragment === undefined) { + if (obj[key] === undefined) { + existingPathFragment = keys.slice(0, t).join('/'); + } else if (t == len - 1) { + existingPathFragment = patch.path; + } + + if (existingPathFragment !== undefined) { + this.validator(patch, p - 1, tree, existingPathFragment); + } + } + } + + t++; + + if (key === undefined) { + if (t >= len) { + result = rootOps[patch.op].call(patch, obj, key, tree); // Apply patch + + break; + } + } + + if (_isArray(obj)) { + if (key === '-') { + key = obj.length; + } else { + if (validate && !isInteger(key)) { + throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", p - 1, patch.path, patch); + } + + key = parseInt(key, 10); + } + + if (t >= len) { + if (validate && patch.op === "add" && key > obj.length) { + throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", p - 1, patch.path, patch); + } + + result = arrOps[patch.op].call(patch, obj, key, tree); // Apply patch + + break; + } + } else { + if (key && key.indexOf('~') != -1) key = key.replace(/~1/g, '/').replace(/~0/g, '~'); // escape chars + + if (t >= len) { + result = objOps[patch.op].call(patch, obj, key, tree); // Apply patch + + break; + } + } + + obj = obj[key]; + } + } + + return result; + } + + jsonpatch.apply = apply; + + function compare(tree1, tree2) { + var patches = []; + + _generate(tree1, tree2, patches, ''); + + return patches; + } + + jsonpatch.compare = compare; + + var JsonPatchError = function (_super) { + __extends(JsonPatchError, _super); + + function JsonPatchError(message, name, index, operation, tree) { + _super.call(this, message); + + this.message = message; + this.name = name; + this.index = index; + this.operation = operation; + this.tree = tree; + } + + return JsonPatchError; + }(OriginalError); + + jsonpatch.JsonPatchError = JsonPatchError; + jsonpatch.Error = JsonPatchError; + /** + * Recursively checks whether an object has any undefined values inside. + */ + + function hasUndefined(obj) { + if (obj === undefined) { + return true; + } + + if (typeof obj == "array" || _typeof$13(obj) == "object") { + for (var i in obj) { + if (hasUndefined(obj[i])) { + return true; + } + } + } + + return false; + } + /** + * Validates a single operation. Called from `jsonpatch.validate`. Throws `JsonPatchError` in case of an error. + * @param {object} operation - operation object (patch) + * @param {number} index - index of operation in the sequence + * @param {object} [tree] - object where the operation is supposed to be applied + * @param {string} [existingPathFragment] - comes along with `tree` + */ + + + function validator(operation, index, tree, existingPathFragment) { + if (_typeof$13(operation) !== 'object' || operation === null || _isArray(operation)) { + throw new JsonPatchError('Operation is not an object', 'OPERATION_NOT_AN_OBJECT', index, operation, tree); + } else if (!objOps[operation.op]) { + throw new JsonPatchError('Operation `op` property is not one of operations defined in RFC-6902', 'OPERATION_OP_INVALID', index, operation, tree); + } else if (typeof operation.path !== 'string') { + throw new JsonPatchError('Operation `path` property is not a string', 'OPERATION_PATH_INVALID', index, operation, tree); + } else if ((operation.op === 'move' || operation.op === 'copy') && typeof operation.from !== 'string') { + throw new JsonPatchError('Operation `from` property is not present (applicable in `move` and `copy` operations)', 'OPERATION_FROM_REQUIRED', index, operation, tree); + } else if ((operation.op === 'add' || operation.op === 'replace' || operation.op === 'test') && operation.value === undefined) { + throw new JsonPatchError('Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)', 'OPERATION_VALUE_REQUIRED', index, operation, tree); + } else if ((operation.op === 'add' || operation.op === 'replace' || operation.op === 'test') && hasUndefined(operation.value)) { + throw new JsonPatchError('Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)', 'OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED', index, operation, tree); + } else if (tree) { + if (operation.op == "add") { + var pathLen = operation.path.split("/").length; + var existingPathLen = existingPathFragment.split("/").length; + + if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) { + throw new JsonPatchError('Cannot perform an `add` operation at the desired path', 'OPERATION_PATH_CANNOT_ADD', index, operation, tree); + } + } else if (operation.op === 'replace' || operation.op === 'remove' || operation.op === '_get') { + if (operation.path !== existingPathFragment) { + throw new JsonPatchError('Cannot perform the operation at a path that does not exist', 'OPERATION_PATH_UNRESOLVABLE', index, operation, tree); + } + } else if (operation.op === 'move' || operation.op === 'copy') { + var existingValue = { + op: "_get", + path: operation.from, + value: undefined + }; + var error = jsonpatch.validate([existingValue], tree); + + if (error && error.name === 'OPERATION_PATH_UNRESOLVABLE') { + throw new JsonPatchError('Cannot perform the operation from a path that does not exist', 'OPERATION_FROM_UNRESOLVABLE', index, operation, tree); + } + } + } + } + + jsonpatch.validator = validator; + /** + * Validates a sequence of operations. If `tree` parameter is provided, the sequence is additionally validated against the object tree. + * If error is encountered, returns a JsonPatchError object + * @param sequence + * @param tree + * @returns {JsonPatchError|undefined} + */ + + function validate(sequence, tree) { + try { + if (!_isArray(sequence)) { + throw new JsonPatchError('Patch sequence must be an array', 'SEQUENCE_NOT_AN_ARRAY'); + } + + if (tree) { + tree = JSON.parse(JSON.stringify(tree)); //clone tree so that we can safely try applying operations + + apply.call(this, tree, sequence, true); + } else { + for (var i = 0; i < sequence.length; i++) { + this.validator(sequence[i], i); + } + } + } catch (e) { + if (e instanceof JsonPatchError) { + return e; + } else { + throw e; + } + } + } + + jsonpatch.validate = validate; +})(jsonpatch || (jsonpatch = {})); + +var jsonpatch$1 = jsonpatch; + +function _slicedToArray$q(arr, i) { return _arrayWithHoles$s(arr) || _iterableToArrayLimit$q(arr, i) || _unsupportedIterableToArray$E(arr, i) || _nonIterableRest$s(); } + +function _nonIterableRest$s() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$E(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$E(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$E(o, minLen); } + +function _arrayLikeToArray$E(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$q(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$s(arr) { if (Array.isArray(arr)) return arr; } +/** + * Clean and extend patches from jsonpatch observer. + * + * @param {Array} patches The list of patches from jsonpatch lib to process. + * @returns {Array} + */ + +function cleanPatches(patches) { + var newOrRemovedColumns = []; + /** + * If observeChanges uses native Object.observe method, then it produces patches for length property. Filter them. + * If path can't be parsed. Filter it. + */ + + var cleanedPatches = arrayFilter(patches, function (patch) { + if (/[/]length/ig.test(patch.path)) { + return false; + } + + if (!parsePath(patch.path)) { + return false; + } + + return true; + }); + /** + * Extend patches with changed cells coords. + */ + + cleanedPatches = arrayMap(cleanedPatches, function (patch) { + var coords = parsePath(patch.path); + patch.row = coords.row; + patch.col = coords.col; + return patch; + }); + /** + * Removing or adding column will produce one patch for each table row. + * Leaves only one patch for each column add/remove operation. + */ + + cleanedPatches = arrayFilter(cleanedPatches, function (patch) { + if (['add', 'remove'].indexOf(patch.op) !== -1 && !isNaN(patch.col)) { + if (newOrRemovedColumns.indexOf(patch.col) !== -1) { + return false; + } + + newOrRemovedColumns.push(patch.col); + } + + return true; + }); + newOrRemovedColumns.length = 0; + return cleanedPatches; +} +/** + * Extract coordinates from path where data was changed. + * + * @param {string} path Path describing where data was changed. + * @returns {object|null} Returns an object with `row` and `col` properties or `null` if path doesn't have necessary information. + */ + +function parsePath(path) { + var match = path.match(/^\/(\d+)\/?(.*)?$/); + + if (!match) { + return null; + } + + var _match = _slicedToArray$q(match, 3), + row = _match[1], + column = _match[2]; + + return { + row: parseInt(row, 10), + col: /^\d*$/.test(column) ? parseInt(column, 10) : column + }; +} + +function _classCallCheck$1V(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1P(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); } } + +function _createClass$1P(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1P(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1P(Constructor, staticProps); return Constructor; } +/** + * @class DataObserver + * @plugin ObserveChanges + */ + +var DataObserver = /*#__PURE__*/function () { + function DataObserver(observedData) { + _classCallCheck$1V(this, DataObserver); + + /** + * Observed source data. + * + * @type {Array} + */ + this.observedData = null; + /** + * JsonPatch observer. + * + * @type {object} + */ + + this.observer = null; + /** + * Flag which determines if observer is paused or not. Paused observer doesn't emit `change` hooks. + * + * @type {boolean} + * @default false + */ + + this.paused = false; + this.setObservedData(observedData); + } + /** + * Set data to observe. + * + * @param {*} observedData Set an object to observe. + */ + + + _createClass$1P(DataObserver, [{ + key: "setObservedData", + value: function setObservedData(observedData) { + var _this = this; + + if (this.observer) { + jsonpatch$1.unobserve(this.observedData, this.observer); + } + + this.observedData = observedData; + this.observer = jsonpatch$1.observe(this.observedData, function (patches) { + return _this.onChange(patches); + }); + } + /** + * Check if observer was paused. + * + * @returns {boolean} + */ + + }, { + key: "isPaused", + value: function isPaused() { + return this.paused; + } + /** + * Pause observer (stop emitting all detected changes). + */ + + }, { + key: "pause", + value: function pause() { + this.paused = true; + } + /** + * Resume observer (emit all detected changes). + */ + + }, { + key: "resume", + value: function resume() { + this.paused = false; + } + /** + * JsonPatch on change listener. + * + * @private + * @param {Array} patches An array of object passed from jsonpatch. + */ + + }, { + key: "onChange", + value: function onChange(patches) { + this.runLocalHooks('change', cleanPatches(patches)); + } + /** + * Destroy observer instance. + */ + + }, { + key: "destroy", + value: function destroy() { + jsonpatch$1.unobserve(this.observedData, this.observer); + this.observedData = null; + this.observer = null; + } + }]); + + return DataObserver; +}(); + +mixin(DataObserver, localHooks); + +function _typeof$14(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$14 = function _typeof(obj) { return typeof obj; }; } else { _typeof$14 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$14(obj); } + +function _classCallCheck$1W(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1Q(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); } } + +function _createClass$1Q(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1Q(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1Q(Constructor, staticProps); return Constructor; } + +function _get$x(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$x = Reflect.get; } else { _get$x = function _get(target, property, receiver) { var base = _superPropBase$x(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$x(target, property, receiver || target); } + +function _superPropBase$x(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$U(object); if (object === null) break; } return object; } + +function _inherits$U(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$V(subClass, superClass); } + +function _setPrototypeOf$V(o, p) { _setPrototypeOf$V = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$V(o, p); } + +function _createSuper$U(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$V(); return function _createSuperInternal() { var Super = _getPrototypeOf$U(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$U(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$U(this, result); }; } + +function _possibleConstructorReturn$U(self, call) { if (call && (_typeof$14(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$U(self); } + +function _assertThisInitialized$U(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$V() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$U(o) { _getPrototypeOf$U = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$U(o); } + +var PLUGIN_KEY$j = 'observeChanges'; +var PLUGIN_PRIORITY$i = 180; +/** + * @plugin ObserveChanges + * + * @deprecated This plugin is deprecated and will be removed in the next major release. + * @description + * This plugin allows to observe data source changes. By default, the plugin is declared as `undefined`, which makes it + * disabled. Enabling this plugin switches the table into one-way data binding where changes are applied into the data + * source (outside from the table) will be automatically reflected in the table. + * + * @example + * ```js + * // as a boolean + * observeChanges: true, + * ``` + * + * To configure this plugin see {@link Options#observeChanges}. + */ + +var ObserveChanges = /*#__PURE__*/function (_BasePlugin) { + _inherits$U(ObserveChanges, _BasePlugin); + + var _super = _createSuper$U(ObserveChanges); + + function ObserveChanges(hotInstance) { + var _this; + + _classCallCheck$1W(this, ObserveChanges); + + _this = _super.call(this, hotInstance); + /** + * Instance of {@link DataObserver}. + * + * @private + * @type {DataObserver} + */ + + _this.observer = null; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ObserveChanges#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1Q(ObserveChanges, [{ + key: "isEnabled", + value: function isEnabled() { + return this.hot.getSettings()[PLUGIN_KEY$j]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + if (!this.observer) { + warn('The Observe Changes plugin is deprecated and will be removed in the next major release'); + this.observer = new DataObserver(this.hot.getSettings().data); + + this._exposePublicApi(); + } + + this.observer.addLocalHook('change', function (patches) { + return _this2.onDataChange(patches); + }); + this.addHook('afterCreateRow', function () { + return _this2.onAfterTableAlter(); + }); + this.addHook('afterRemoveRow', function () { + return _this2.onAfterTableAlter(); + }); + this.addHook('afterCreateCol', function () { + return _this2.onAfterTableAlter(); + }); + this.addHook('afterRemoveCol', function () { + return _this2.onAfterTableAlter(); + }); + this.addHook('afterChange', function (changes, source) { + return _this2.onAfterTableAlter(source); + }); + this.addHook('afterLoadData', function (sourceData, firstRun) { + return _this2.onAfterLoadData(sourceData, firstRun); + }); + + _get$x(_getPrototypeOf$U(ObserveChanges.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + if (this.observer) { + this.observer.destroy(); + this.observer = null; + + this._deletePublicApi(); + } + + _get$x(_getPrototypeOf$U(ObserveChanges.prototype), "disablePlugin", this).call(this); + } + /** + * Data change observer. + * + * @private + * @param {Array} patches An array of objects which every item defines coordinates where data was changed. + */ + + }, { + key: "onDataChange", + value: function onDataChange(patches) { + var _this3 = this; + + var render = false; + + if (!this.observer.isPaused()) { + var sourceName = "".concat(this.pluginName, ".change"); + var actions = { + add: function add(patch) { + var _ref = [patch.row, patch.col], + visualRow = _ref[0], + visualColumn = _ref[1]; + + if (isNaN(visualColumn)) { + _this3.hot.rowIndexMapper.insertIndexes(visualRow, 1); + + _this3.hot.runHooks('afterCreateRow', visualRow, 1, sourceName); + } else { + _this3.hot.columnIndexMapper.insertIndexes(visualColumn, 1); + + _this3.hot.runHooks('afterCreateCol', visualColumn, 1, sourceName); + } + }, + remove: function remove(patch) { + var _ref2 = [patch.row, patch.col], + visualRow = _ref2[0], + visualColumn = _ref2[1]; + + if (isNaN(visualColumn)) { + _this3.hot.rowIndexMapper.removeIndexes([visualRow]); + + _this3.hot.runHooks('afterRemoveRow', visualRow, 1, sourceName); + } else { + _this3.hot.columnIndexMapper.removeIndexes([visualColumn]); + + _this3.hot.runHooks('afterRemoveCol', visualColumn, 1, sourceName); + } + }, + replace: function replace(patch) { + _this3.hot.runHooks('afterChange', [[patch.row, patch.col, null, patch.value]], sourceName); + } + }; + arrayEach(patches, function (patch) { + if (actions[patch.op]) { + actions[patch.op](patch); + } + }); + render = true; + } + + this.hot.runHooks('afterChangesObserved'); + + if (render) { + this.hot.render(); + } + } + /** + * On after table alter listener. Prevents infinity loop between internal and external data changing. + * + * @private + * @param {string} source The identifier of the code that performed the action. + */ + + }, { + key: "onAfterTableAlter", + value: function onAfterTableAlter(source) { + var _this4 = this; + + if (source !== 'loadData') { + this.observer.pause(); + this.hot.addHookOnce('afterChangesObserved', function () { + return _this4.observer.resume(); + }); + } + } + /** + * On after load data listener. + * + * @private + * @param {Array} sourceData Source data array. + * @param {boolean} firstRun `true` if event was fired first time. + */ + + }, { + key: "onAfterLoadData", + value: function onAfterLoadData(sourceData, firstRun) { + if (!firstRun) { + this.observer.setObservedData(sourceData); + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + if (this.observer) { + this.observer.destroy(); + + this._deletePublicApi(); + } + + _get$x(_getPrototypeOf$U(ObserveChanges.prototype), "destroy", this).call(this); + } + /** + * Expose plugins methods to the core. + * + * @private + */ + + }, { + key: "_exposePublicApi", + value: function _exposePublicApi() { + var _this5 = this; + + var hot = this.hot; + + hot.pauseObservingChanges = function () { + return _this5.observer.pause(); + }; + + hot.resumeObservingChanges = function () { + return _this5.observer.resume(); + }; + + hot.isPausedObservingChanges = function () { + return _this5.observer.isPaused(); + }; + } + /** + * Deletes all previously exposed methods. + * + * @private + */ + + }, { + key: "_deletePublicApi", + value: function _deletePublicApi() { + var hot = this.hot; + delete hot.pauseObservingChanges; + delete hot.resumeObservingChanges; + delete hot.isPausedObservingChanges; + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$j; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$i; + } + }]); + + return ObserveChanges; +}(BasePlugin); + +function _typeof$15(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$15 = function _typeof(obj) { return typeof obj; }; } else { _typeof$15 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$15(obj); } + +function _toConsumableArray$m(arr) { return _arrayWithoutHoles$k(arr) || _iterableToArray$m(arr) || _unsupportedIterableToArray$F(arr) || _nonIterableSpread$k(); } + +function _nonIterableSpread$k() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$F(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$F(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$F(o, minLen); } + +function _iterableToArray$m(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$k(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$F(arr); } + +function _arrayLikeToArray$F(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$1X(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1R(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); } } + +function _createClass$1R(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1R(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1R(Constructor, staticProps); return Constructor; } + +function _get$y(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$y = Reflect.get; } else { _get$y = function _get(target, property, receiver) { var base = _superPropBase$y(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$y(target, property, receiver || target); } + +function _superPropBase$y(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$V(object); if (object === null) break; } return object; } + +function _inherits$V(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$W(subClass, superClass); } + +function _setPrototypeOf$W(o, p) { _setPrototypeOf$W = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$W(o, p); } + +function _createSuper$V(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$W(); return function _createSuperInternal() { var Super = _getPrototypeOf$V(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$V(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$V(this, result); }; } + +function _possibleConstructorReturn$V(self, call) { if (call && (_typeof$15(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$V(self); } + +function _assertThisInitialized$V(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$W() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$V(o) { _getPrototypeOf$V = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$V(o); } +var PLUGIN_KEY$k = 'search'; +var PLUGIN_PRIORITY$j = 190; +var DEFAULT_SEARCH_RESULT_CLASS = 'htSearchResult'; + +var DEFAULT_CALLBACK = function DEFAULT_CALLBACK(instance, row, col, data, testResult) { + instance.getCellMeta(row, col).isSearchResult = testResult; +}; + +var DEFAULT_QUERY_METHOD = function DEFAULT_QUERY_METHOD(query, value) { + if (isUndefined(query) || query === null || !query.toLowerCase || query.length === 0) { + return false; + } + + if (isUndefined(value) || value === null) { + return false; + } + + return value.toString().toLowerCase().indexOf(query.toLowerCase()) !== -1; +}; +/** + * @plugin Search + * + * @description + * The search plugin provides an easy interface to search data across Handsontable. + * + * In order to enable search mechanism, {@link Options#search} option must be set to `true`. + * + * @example + * ```js + * // as boolean + * search: true + * // as a object with one or more options + * search: { + * callback: myNewCallbackFunction, + * queryMethod: myNewQueryMethod, + * searchResultClass: 'customClass' + * } + * + * // Access to search plugin instance: + * const searchPlugin = hot.getPlugin('search'); + * + * // Set callback programmatically: + * searchPlugin.setCallback(myNewCallbackFunction); + * // Set query method programmatically: + * searchPlugin.setQueryMethod(myNewQueryMethod); + * // Set search result cells class programmatically: + * searchPlugin.setSearchResultClass(customClass); + * ``` + */ + + +var Search = /*#__PURE__*/function (_BasePlugin) { + _inherits$V(Search, _BasePlugin); + + var _super = _createSuper$V(Search); + + function Search(hotInstance) { + var _this; + + _classCallCheck$1X(this, Search); + + _this = _super.call(this, hotInstance); + /** + * Function called during querying for each cell from the {@link DataMap}. + * + * @private + * @type {Function} + */ + + _this.callback = DEFAULT_CALLBACK; + /** + * Query function is responsible for determining whether a query matches the value stored in a cell. + * + * @private + * @type {Function} + */ + + _this.queryMethod = DEFAULT_QUERY_METHOD; + /** + * Class name added to each cell that belongs to the searched query. + * + * @private + * @type {string} + */ + + _this.searchResultClass = DEFAULT_SEARCH_RESULT_CLASS; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link AutoRowSize#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1R(Search, [{ + key: "isEnabled", + value: function isEnabled() { + return this.hot.getSettings()[PLUGIN_KEY$k]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var searchSettings = this.hot.getSettings()[PLUGIN_KEY$k]; + this.updatePluginSettings(searchSettings); + this.addHook('beforeRenderer', function () { + return _this2.onBeforeRenderer.apply(_this2, arguments); + }); + + _get$y(_getPrototypeOf$V(Search.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + var _this3 = this; + + var beforeRendererCallback = function beforeRendererCallback() { + return _this3.onBeforeRenderer.apply(_this3, arguments); + }; + + this.hot.addHook('beforeRenderer', beforeRendererCallback); + this.hot.addHookOnce('afterRender', function () { + _this3.hot.removeHook('beforeRenderer', beforeRendererCallback); + }); + + _get$y(_getPrototypeOf$V(Search.prototype), "disablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$y(_getPrototypeOf$V(Search.prototype), "updatePlugin", this).call(this); + } + /** + * Makes the query. + * + * @param {string} queryStr Value to be search. + * @param {Function} [callback] Callback function performed on cells with values which matches to the searched query. + * @param {Function} [queryMethod] Query function responsible for determining whether a query matches the value stored in a cell. + * @returns {object[]} Return an array of objects with `row`, `col`, `data` properties or empty array. + */ + + }, { + key: "query", + value: function query(queryStr) { + var _this4 = this; + + var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getCallback(); + var queryMethod = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getQueryMethod(); + var rowCount = this.hot.countRows(); + var colCount = this.hot.countCols(); + var queryResult = []; + var instance = this.hot; + rangeEach(0, rowCount - 1, function (rowIndex) { + rangeEach(0, colCount - 1, function (colIndex) { + var cellData = _this4.hot.getDataAtCell(rowIndex, colIndex); + + var cellProperties = _this4.hot.getCellMeta(rowIndex, colIndex); + + var cellCallback = cellProperties.search.callback || callback; + var cellQueryMethod = cellProperties.search.queryMethod || queryMethod; + var testResult = cellQueryMethod(queryStr, cellData, cellProperties); + + if (testResult) { + var singleResult = { + row: rowIndex, + col: colIndex, + data: cellData + }; + queryResult.push(singleResult); + } + + if (cellCallback) { + cellCallback(instance, rowIndex, colIndex, cellData, testResult); + } + }); + }); + return queryResult; + } + /** + * Gets the callback function. + * + * @returns {Function} Return the callback function. + */ + + }, { + key: "getCallback", + value: function getCallback() { + return this.callback; + } + /** + * Sets the callback function. This function will be called during querying for each cell. + * + * @param {Function} newCallback A callback function. + */ + + }, { + key: "setCallback", + value: function setCallback(newCallback) { + this.callback = newCallback; + } + /** + * Gets the query method function. + * + * @returns {Function} Return the query method. + */ + + }, { + key: "getQueryMethod", + value: function getQueryMethod() { + return this.queryMethod; + } + /** + * Sets the query method function. The function is responsible for determining whether a query matches the value stored in a cell. + * + * @param {Function} newQueryMethod A function with specific match logic. + */ + + }, { + key: "setQueryMethod", + value: function setQueryMethod(newQueryMethod) { + this.queryMethod = newQueryMethod; + } + /** + * Gets search result cells class name. + * + * @returns {string} Return the cell class name. + */ + + }, { + key: "getSearchResultClass", + value: function getSearchResultClass() { + return this.searchResultClass; + } + /** + * Sets search result cells class name. This class name will be added to each cell that belongs to the searched query. + * + * @param {string} newElementClass CSS class name. + */ + + }, { + key: "setSearchResultClass", + value: function setSearchResultClass(newElementClass) { + this.searchResultClass = newElementClass; + } + /** + * Updates the settings of the plugin. + * + * @param {object} searchSettings The plugin settings, taken from Handsontable configuration. + * @private + */ + + }, { + key: "updatePluginSettings", + value: function updatePluginSettings(searchSettings) { + if (isObject$1(searchSettings)) { + if (searchSettings.searchResultClass) { + this.setSearchResultClass(searchSettings.searchResultClass); + } + + if (searchSettings.queryMethod) { + this.setQueryMethod(searchSettings.queryMethod); + } + + if (searchSettings.callback) { + this.setCallback(searchSettings.callback); + } + } + } + /** + * The `beforeRenderer` hook callback. + * + * @private + * @param {HTMLTableCellElement} TD The rendered `TD` element. + * @param {number} row Visual row index. + * @param {number} col Visual column index. + * @param {string|number} prop Column property name or a column index, if datasource is an array of arrays. + * @param {string} value Value of the rendered cell. + * @param {object} cellProperties Object containing the cell's properties. + */ + + }, { + key: "onBeforeRenderer", + value: function onBeforeRenderer(TD, row, col, prop, value, cellProperties) { + // TODO: #4972 + var className = cellProperties.className || []; + var classArray = []; + + if (typeof className === 'string') { + classArray = className.split(' '); + } else { + var _classArray; + + (_classArray = classArray).push.apply(_classArray, _toConsumableArray$m(className)); + } + + if (this.isEnabled() && cellProperties.isSearchResult) { + if (!classArray.includes(this.searchResultClass)) { + classArray.push("".concat(this.searchResultClass)); + } + } else if (classArray.includes(this.searchResultClass)) { + classArray.splice(classArray.indexOf(this.searchResultClass), 1); + } + + cellProperties.className = classArray.join(' '); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + _get$y(_getPrototypeOf$V(Search.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$k; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$j; + } + }]); + + return Search; +}(BasePlugin); + +function _typeof$16(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$16 = function _typeof(obj) { return typeof obj; }; } else { _typeof$16 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$16(obj); } + +function _classCallCheck$1Y(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1S(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); } } + +function _createClass$1S(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1S(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1S(Constructor, staticProps); return Constructor; } + +function _get$z(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$z = Reflect.get; } else { _get$z = function _get(target, property, receiver) { var base = _superPropBase$z(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$z(target, property, receiver || target); } + +function _superPropBase$z(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$W(object); if (object === null) break; } return object; } + +function _inherits$W(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$X(subClass, superClass); } + +function _setPrototypeOf$X(o, p) { _setPrototypeOf$X = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$X(o, p); } + +function _createSuper$W(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$X(); return function _createSuperInternal() { var Super = _getPrototypeOf$W(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$W(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$W(this, result); }; } + +function _possibleConstructorReturn$W(self, call) { if (call && (_typeof$16(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$W(self); } + +function _assertThisInitialized$W(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$X() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$W(o) { _getPrototypeOf$W = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$W(o); } +var PLUGIN_KEY$l = 'touchScroll'; +var PLUGIN_PRIORITY$k = 200; +/** + * @private + * @plugin TouchScroll + * @class TouchScroll + */ + +var TouchScroll = /*#__PURE__*/function (_BasePlugin) { + _inherits$W(TouchScroll, _BasePlugin); + + var _super = _createSuper$W(TouchScroll); + + function TouchScroll(hotInstance) { + var _this; + + _classCallCheck$1Y(this, TouchScroll); + + _this = _super.call(this, hotInstance); + /** + * Collection of scrollbars to update. + * + * @type {Array} + */ + + _this.scrollbars = []; + /** + * Collection of overlays to update. + * + * @type {Array} + */ + + _this.clones = []; + /** + * Flag which determines if collection of overlays should be refilled on every table render. + * + * @type {boolean} + * @default false + */ + + _this.lockedCollection = false; + /** + * Flag which determines if walkontable should freeze overlays while scrolling. + * + * @type {boolean} + * @default false + */ + + _this.freezeOverlays = false; + return _this; + } + /** + * Check if plugin is enabled. + * + * @returns {boolean} + */ + + + _createClass$1S(TouchScroll, [{ + key: "isEnabled", + value: function isEnabled() { + return isTouchSupported(); + } + /** + * Enable the plugin. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.addHook('afterRender', function () { + return _this2.onAfterRender(); + }); + this.registerEvents(); + + _get$z(_getPrototypeOf$W(TouchScroll.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin to use the latest options you have specified. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.lockedCollection = false; + + _get$z(_getPrototypeOf$W(TouchScroll.prototype), "updatePlugin", this).call(this); + } + /** + * Disable plugin for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + _get$z(_getPrototypeOf$W(TouchScroll.prototype), "disablePlugin", this).call(this); + } + /** + * Register all necessary events. + * + * @private + */ + + }, { + key: "registerEvents", + value: function registerEvents() { + var _this3 = this; + + this.addHook('beforeTouchScroll', function () { + return _this3.onBeforeTouchScroll(); + }); + this.addHook('afterMomentumScroll', function () { + return _this3.onAfterMomentumScroll(); + }); + } + /** + * After render listener. + * + * @private + */ + + }, { + key: "onAfterRender", + value: function onAfterRender() { + if (this.lockedCollection) { + return; + } + + var _this$hot$view$wt$wtO = this.hot.view.wt.wtOverlays, + topOverlay = _this$hot$view$wt$wtO.topOverlay, + bottomOverlay = _this$hot$view$wt$wtO.bottomOverlay, + leftOverlay = _this$hot$view$wt$wtO.leftOverlay, + topLeftCornerOverlay = _this$hot$view$wt$wtO.topLeftCornerOverlay, + bottomLeftCornerOverlay = _this$hot$view$wt$wtO.bottomLeftCornerOverlay; + this.lockedCollection = true; + this.scrollbars.length = 0; + this.scrollbars.push(topOverlay); + + if (bottomOverlay.clone) { + this.scrollbars.push(bottomOverlay); + } + + this.scrollbars.push(leftOverlay); + + if (topLeftCornerOverlay) { + this.scrollbars.push(topLeftCornerOverlay); + } + + if (bottomLeftCornerOverlay && bottomLeftCornerOverlay.clone) { + this.scrollbars.push(bottomLeftCornerOverlay); + } + + this.clones.length = 0; + + if (topOverlay.needFullRender) { + this.clones.push(topOverlay.clone.wtTable.holder.parentNode); + } + + if (bottomOverlay.needFullRender) { + this.clones.push(bottomOverlay.clone.wtTable.holder.parentNode); + } + + if (leftOverlay.needFullRender) { + this.clones.push(leftOverlay.clone.wtTable.holder.parentNode); + } + + if (topLeftCornerOverlay) { + this.clones.push(topLeftCornerOverlay.clone.wtTable.holder.parentNode); + } + + if (bottomLeftCornerOverlay && bottomLeftCornerOverlay.clone) { + this.clones.push(bottomLeftCornerOverlay.clone.wtTable.holder.parentNode); + } + } + /** + * Touch scroll listener. + * + * @private + */ + + }, { + key: "onBeforeTouchScroll", + value: function onBeforeTouchScroll() { + this.freezeOverlays = true; + arrayEach(this.clones, function (clone) { + addClass(clone, 'hide-tween'); + }); + } + /** + * After momentum scroll listener. + * + * @private + */ + + }, { + key: "onAfterMomentumScroll", + value: function onAfterMomentumScroll() { + var _this4 = this; + + this.freezeOverlays = false; + arrayEach(this.clones, function (clone) { + removeClass(clone, 'hide-tween'); + addClass(clone, 'show-tween'); + }); + setTimeout(function () { + arrayEach(_this4.clones, function (clone) { + removeClass(clone, 'show-tween'); + }); + }, 400); + arrayEach(this.scrollbars, function (scrollbar) { + scrollbar.refresh(); + scrollbar.resetFixedPosition(); + }); + this.hot.view.wt.wtOverlays.syncScrollWithMaster(); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$l; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$k; + } + }]); + + return TouchScroll; +}(BasePlugin); + +function _typeof$17(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$17 = function _typeof(obj) { return typeof obj; }; } else { _typeof$17 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$17(obj); } + +function _classCallCheck$1Z(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1T(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); } } + +function _createClass$1T(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1T(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1T(Constructor, staticProps); return Constructor; } + +function _inherits$X(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$Y(subClass, superClass); } + +function _setPrototypeOf$Y(o, p) { _setPrototypeOf$Y = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$Y(o, p); } + +function _createSuper$X(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$Y(); return function _createSuperInternal() { var Super = _getPrototypeOf$X(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$X(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$X(this, result); }; } + +function _possibleConstructorReturn$X(self, call) { if (call && (_typeof$17(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$X(self); } + +function _assertThisInitialized$X(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$Y() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$X(o) { _getPrototypeOf$X = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$X(o); } + +function _toConsumableArray$n(arr) { return _arrayWithoutHoles$l(arr) || _iterableToArray$n(arr) || _unsupportedIterableToArray$G(arr) || _nonIterableSpread$l(); } + +function _nonIterableSpread$l() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _iterableToArray$n(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$l(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$G(arr); } + +function _slicedToArray$r(arr, i) { return _arrayWithHoles$t(arr) || _iterableToArrayLimit$r(arr, i) || _unsupportedIterableToArray$G(arr, i) || _nonIterableRest$t(); } + +function _nonIterableRest$t() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$G(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$G(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$G(o, minLen); } + +function _arrayLikeToArray$G(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$r(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$t(arr) { if (Array.isArray(arr)) return arr; } +var PLUGIN_KEY$m = 'undoRedo'; +/** + * @description + * Handsontable UndoRedo plugin allows to undo and redo certain actions done in the table. + * + * __Note__, that not all actions are currently undo-able. The UndoRedo plugin is enabled by default. + * @example + * ```js + * undo: true + * ``` + * @class UndoRedo + * @plugin UndoRedo + * @param {Core} instance The Handsontable instance. + */ + +function UndoRedo(instance) { + var plugin = this; + this.instance = instance; + this.doneActions = []; + this.undoneActions = []; + this.ignoreNewActions = false; + this.enabled = false; + instance.addHook('afterChange', function (changes, source) { + var changesLen = changes && changes.length; + + if (!changesLen || ['UndoRedo.undo', 'UndoRedo.redo', 'MergeCells'].includes(source)) { + return; + } + + var hasDifferences = changes.find(function (change) { + var _change = _slicedToArray$r(change, 4), + oldValue = _change[2], + newValue = _change[3]; + + return oldValue !== newValue; + }); + + if (!hasDifferences) { + return; + } + + var clonedChanges = changes.reduce(function (arr, change) { + arr.push(_toConsumableArray$n(change)); + return arr; + }, []); + arrayEach(clonedChanges, function (change) { + change[1] = instance.propToCol(change[1]); + }); + var selected = changesLen > 1 ? this.getSelected() : [[clonedChanges[0][0], clonedChanges[0][1]]]; + plugin.done(new UndoRedo.ChangeAction(clonedChanges, selected)); + }); + instance.addHook('afterCreateRow', function (index, amount, source) { + if (source === 'UndoRedo.undo' || source === 'UndoRedo.undo' || source === 'auto') { + return; + } + + var action = new UndoRedo.CreateRowAction(index, amount); + plugin.done(action); + }); + instance.addHook('beforeRemoveRow', function (index, amount, logicRows, source) { + if (source === 'UndoRedo.undo' || source === 'UndoRedo.redo' || source === 'auto') { + return; + } + + var originalData = plugin.instance.getSourceDataArray(); + var rowIndex = (originalData.length + index) % originalData.length; + var physicalRowIndex = instance.toPhysicalRow(rowIndex); + var removedData = deepClone(originalData.slice(physicalRowIndex, physicalRowIndex + amount)); + plugin.done(new UndoRedo.RemoveRowAction(rowIndex, removedData, instance.getSettings().fixedRowsBottom, instance.getSettings().fixedRowsTop)); + }); + instance.addHook('afterCreateCol', function (index, amount, source) { + if (source === 'UndoRedo.undo' || source === 'UndoRedo.redo' || source === 'auto') { + return; + } + + plugin.done(new UndoRedo.CreateColumnAction(index, amount)); + }); + instance.addHook('beforeRemoveCol', function (index, amount, logicColumns, source) { + if (source === 'UndoRedo.undo' || source === 'UndoRedo.redo' || source === 'auto') { + return; + } + + var originalData = plugin.instance.getSourceDataArray(); + var columnIndex = (plugin.instance.countCols() + index) % plugin.instance.countCols(); + var removedData = []; + var headers = []; + var indexes = []; + rangeEach(originalData.length - 1, function (i) { + var column = []; + var origRow = originalData[i]; + rangeEach(columnIndex, columnIndex + (amount - 1), function (j) { + column.push(origRow[instance.toPhysicalColumn(j)]); + }); + removedData.push(column); + }); + rangeEach(amount - 1, function (i) { + indexes.push(instance.toPhysicalColumn(columnIndex + i)); + }); + + if (Array.isArray(instance.getSettings().colHeaders)) { + rangeEach(amount - 1, function (i) { + headers.push(instance.getSettings().colHeaders[instance.toPhysicalColumn(columnIndex + i)] || null); + }); + } + + var columnsMap = instance.columnIndexMapper.getIndexesSequence(); + var rowsMap = instance.rowIndexMapper.getIndexesSequence(); + var action = new UndoRedo.RemoveColumnAction(columnIndex, indexes, removedData, headers, columnsMap, rowsMap, instance.getSettings().fixedColumnsLeft); + plugin.done(action); + }); + instance.addHook('beforeCellAlignment', function (stateBefore, range, type, alignment) { + var action = new UndoRedo.CellAlignmentAction(stateBefore, range, type, alignment); + plugin.done(action); + }); + instance.addHook('beforeFilter', function (conditionsStack) { + plugin.done(new UndoRedo.FiltersAction(conditionsStack)); + }); + instance.addHook('beforeRowMove', function (rows, finalIndex) { + if (rows === false) { + return; + } + + plugin.done(new UndoRedo.RowMoveAction(rows, finalIndex)); + }); + instance.addHook('beforeMergeCells', function (cellRange, auto) { + if (auto) { + return; + } + + plugin.done(new UndoRedo.MergeCellsAction(instance, cellRange)); + }); + instance.addHook('afterUnmergeCells', function (cellRange, auto) { + if (auto) { + return; + } + + plugin.done(new UndoRedo.UnmergeCellsAction(instance, cellRange)); + }); +} +/** + * @param {object} action The action desciptor. + */ + + +UndoRedo.prototype.done = function (action) { + if (!this.ignoreNewActions) { + this.doneActions.push(action); + this.undoneActions.length = 0; + } +}; +/** + * Undo the last action performed to the table. + * + * @function undo + * @memberof UndoRedo# + * @fires Hooks#beforeUndo + * @fires Hooks#afterUndo + */ + + +UndoRedo.prototype.undo = function () { + if (this.isUndoAvailable()) { + var action = this.doneActions.pop(); + var actionClone = deepClone(action); + var instance = this.instance; + var continueAction = instance.runHooks('beforeUndo', actionClone); + + if (continueAction === false) { + return; + } + + this.ignoreNewActions = true; + var that = this; + action.undo(this.instance, function () { + that.ignoreNewActions = false; + that.undoneActions.push(action); + }); + instance.runHooks('afterUndo', actionClone); + } +}; +/** + * Redo the previous action performed to the table (used to reverse an undo). + * + * @function redo + * @memberof UndoRedo# + * @fires Hooks#beforeRedo + * @fires Hooks#afterRedo + */ + + +UndoRedo.prototype.redo = function () { + if (this.isRedoAvailable()) { + var action = this.undoneActions.pop(); + var actionClone = deepClone(action); + var instance = this.instance; + var continueAction = instance.runHooks('beforeRedo', actionClone); + + if (continueAction === false) { + return; + } + + this.ignoreNewActions = true; + var that = this; + action.redo(this.instance, function () { + that.ignoreNewActions = false; + that.doneActions.push(action); + }); + instance.runHooks('afterRedo', actionClone); + } +}; +/** + * Checks if undo action is available. + * + * @function isUndoAvailable + * @memberof UndoRedo# + * @returns {boolean} Return `true` if undo can be performed, `false` otherwise. + */ + + +UndoRedo.prototype.isUndoAvailable = function () { + return this.doneActions.length > 0; +}; +/** + * Checks if redo action is available. + * + * @function isRedoAvailable + * @memberof UndoRedo# + * @returns {boolean} Return `true` if redo can be performed, `false` otherwise. + */ + + +UndoRedo.prototype.isRedoAvailable = function () { + return this.undoneActions.length > 0; +}; +/** + * Clears undo history. + * + * @function clear + * @memberof UndoRedo# + */ + + +UndoRedo.prototype.clear = function () { + this.doneActions.length = 0; + this.undoneActions.length = 0; +}; +/** + * Checks if the plugin is enabled. + * + * @function isEnabled + * @memberof UndoRedo# + * @returns {boolean} + */ + + +UndoRedo.prototype.isEnabled = function () { + return this.enabled; +}; +/** + * Enables the plugin. + * + * @function enable + * @memberof UndoRedo# + */ + + +UndoRedo.prototype.enable = function () { + if (this.isEnabled()) { + return; + } + + var hot = this.instance; + this.enabled = true; + exposeUndoRedoMethods(hot); + hot.addHook('beforeKeyDown', onBeforeKeyDown); + hot.addHook('afterChange', onAfterChange); +}; +/** + * Disables the plugin. + * + * @function disable + * @memberof UndoRedo# + */ + + +UndoRedo.prototype.disable = function () { + if (!this.isEnabled()) { + return; + } + + var hot = this.instance; + this.enabled = false; + removeExposedUndoRedoMethods(hot); + hot.removeHook('beforeKeyDown', onBeforeKeyDown); + hot.removeHook('afterChange', onAfterChange); +}; +/** + * Destroys the instance. + * + * @function destroy + * @memberof UndoRedo# + */ + + +UndoRedo.prototype.destroy = function () { + this.clear(); + this.instance = null; + this.doneActions = null; + this.undoneActions = null; +}; + +UndoRedo.Action = function () {}; + +UndoRedo.Action.prototype.undo = function () {}; + +UndoRedo.Action.prototype.redo = function () {}; +/** + * Change action. + * + * @private + * @param {Array} changes 2D array containing information about each of the edited cells. + * @param {number[]} selected The cell selection. + */ + + +UndoRedo.ChangeAction = function (changes, selected) { + this.changes = changes; + this.selected = selected; + this.actionType = 'change'; +}; + +inherit(UndoRedo.ChangeAction, UndoRedo.Action); + +UndoRedo.ChangeAction.prototype.undo = function (instance, undoneCallback) { + var data = deepClone(this.changes); + var emptyRowsAtTheEnd = instance.countEmptyRows(true); + var emptyColsAtTheEnd = instance.countEmptyCols(true); + + for (var i = 0, len = data.length; i < len; i++) { + data[i].splice(3, 1); + } + + instance.addHookOnce('afterChange', undoneCallback); + instance.setDataAtCell(data, null, null, 'UndoRedo.undo'); + + for (var _i2 = 0, _len = data.length; _i2 < _len; _i2++) { + var _data$_i = _slicedToArray$r(data[_i2], 2), + row = _data$_i[0], + column = _data$_i[1]; + + if (instance.getSettings().minSpareRows && row + 1 + instance.getSettings().minSpareRows === instance.countRows() && emptyRowsAtTheEnd === instance.getSettings().minSpareRows) { + instance.alter('remove_row', parseInt(row + 1, 10), instance.getSettings().minSpareRows); + instance.undoRedo.doneActions.pop(); + } + + if (instance.getSettings().minSpareCols && column + 1 + instance.getSettings().minSpareCols === instance.countCols() && emptyColsAtTheEnd === instance.getSettings().minSpareCols) { + instance.alter('remove_col', parseInt(column + 1, 10), instance.getSettings().minSpareCols); + instance.undoRedo.doneActions.pop(); + } + } + + instance.selectCells(this.selected, false, false); +}; + +UndoRedo.ChangeAction.prototype.redo = function (instance, onFinishCallback) { + var data = deepClone(this.changes); + + for (var i = 0, len = data.length; i < len; i++) { + data[i].splice(2, 1); + } + + instance.addHookOnce('afterChange', onFinishCallback); + instance.setDataAtCell(data, null, null, 'UndoRedo.redo'); + + if (this.selected) { + instance.selectCells(this.selected, false, false); + } +}; +/** + * Create row action. + * + * @private + * @param {number} index The visual row index. + * @param {number} amount The number of created rows. + */ + + +UndoRedo.CreateRowAction = function (index, amount) { + this.index = index; + this.amount = amount; + this.actionType = 'insert_row'; +}; + +inherit(UndoRedo.CreateRowAction, UndoRedo.Action); + +UndoRedo.CreateRowAction.prototype.undo = function (instance, undoneCallback) { + var rowCount = instance.countRows(); + var minSpareRows = instance.getSettings().minSpareRows; + + if (this.index >= rowCount && this.index - minSpareRows < rowCount) { + this.index -= minSpareRows; // work around the situation where the needed row was removed due to an 'undo' of a made change + } + + instance.addHookOnce('afterRemoveRow', undoneCallback); + instance.alter('remove_row', this.index, this.amount, 'UndoRedo.undo'); +}; + +UndoRedo.CreateRowAction.prototype.redo = function (instance, redoneCallback) { + instance.addHookOnce('afterCreateRow', redoneCallback); + instance.alter('insert_row', this.index, this.amount, 'UndoRedo.redo'); +}; +/** + * Remove row action. + * + * @private + * @param {number} index The visual row index. + * @param {Array} data The removed data. + * @param {number} fixedRowsBottom Number of fixed rows on the bottom. Remove row action change it sometimes. + * @param {number} fixedRowsTop Number of fixed rows on the top. Remove row action change it sometimes. + */ + + +UndoRedo.RemoveRowAction = function (index, data, fixedRowsBottom, fixedRowsTop) { + this.index = index; + this.data = data; + this.actionType = 'remove_row'; + this.fixedRowsBottom = fixedRowsBottom; + this.fixedRowsTop = fixedRowsTop; +}; + +inherit(UndoRedo.RemoveRowAction, UndoRedo.Action); + +UndoRedo.RemoveRowAction.prototype.undo = function (instance, undoneCallback) { + var settings = instance.getSettings(); // Changing by the reference as `updateSettings` doesn't work the best. + + settings.fixedRowsBottom = this.fixedRowsBottom; + settings.fixedRowsTop = this.fixedRowsTop; + instance.alter('insert_row', this.index, this.data.length, 'UndoRedo.undo'); + instance.addHookOnce('afterRender', undoneCallback); + instance.populateFromArray(this.index, 0, this.data, void 0, void 0, 'UndoRedo.undo'); +}; + +UndoRedo.RemoveRowAction.prototype.redo = function (instance, redoneCallback) { + instance.addHookOnce('afterRemoveRow', redoneCallback); + instance.alter('remove_row', this.index, this.data.length, 'UndoRedo.redo'); +}; +/** + * Create column action. + * + * @private + * @param {number} index The visual column index. + * @param {number} amount The number of created columns. + */ + + +UndoRedo.CreateColumnAction = function (index, amount) { + this.index = index; + this.amount = amount; + this.actionType = 'insert_col'; +}; + +inherit(UndoRedo.CreateColumnAction, UndoRedo.Action); + +UndoRedo.CreateColumnAction.prototype.undo = function (instance, undoneCallback) { + instance.addHookOnce('afterRemoveCol', undoneCallback); + instance.alter('remove_col', this.index, this.amount, 'UndoRedo.undo'); +}; + +UndoRedo.CreateColumnAction.prototype.redo = function (instance, redoneCallback) { + instance.addHookOnce('afterCreateCol', redoneCallback); + instance.alter('insert_col', this.index, this.amount, 'UndoRedo.redo'); +}; +/** + * Remove column action. + * + * @private + * @param {number} index The visual column index. + * @param {number[]} indexes The visual column indexes. + * @param {Array} data The removed data. + * @param {Array} headers The header values. + * @param {number[]} columnPositions The column position. + * @param {number[]} rowPositions The row position. + * @param {number} fixedColumnsLeft Number of fixed columns on the left. Remove column action change it sometimes. + */ + + +UndoRedo.RemoveColumnAction = function (index, indexes, data, headers, columnPositions, rowPositions, fixedColumnsLeft) { + this.index = index; + this.indexes = indexes; + this.data = data; + this.amount = this.data[0].length; + this.headers = headers; + this.columnPositions = columnPositions.slice(0); + this.rowPositions = rowPositions.slice(0); + this.actionType = 'remove_col'; + this.fixedColumnsLeft = fixedColumnsLeft; +}; + +inherit(UndoRedo.RemoveColumnAction, UndoRedo.Action); + +UndoRedo.RemoveColumnAction.prototype.undo = function (instance, undoneCallback) { + var _this = this, + _instance$getPlugin$e, + _instance$getPlugin; + + var settings = instance.getSettings(); // Changing by the reference as `updateSettings` doesn't work the best. + + settings.fixedColumnsLeft = this.fixedColumnsLeft; + var ascendingIndexes = this.indexes.slice(0).sort(); + + var sortByIndexes = function sortByIndexes(elem, j, arr) { + return arr[_this.indexes.indexOf(ascendingIndexes[j])]; + }; + + var removedDataLength = this.data.length; + var sortedData = []; + + for (var rowIndex = 0; rowIndex < removedDataLength; rowIndex++) { + sortedData.push(arrayMap(this.data[rowIndex], sortByIndexes)); + } + + var sortedHeaders = arrayMap(this.headers, sortByIndexes); + var isFormulaPluginEnabled = (_instance$getPlugin$e = (_instance$getPlugin = instance.getPlugin('formulas')) === null || _instance$getPlugin === void 0 ? void 0 : _instance$getPlugin.enabled) !== null && _instance$getPlugin$e !== void 0 ? _instance$getPlugin$e : false; + var changes = []; + instance.alter('insert_col', this.indexes[0], this.indexes.length, 'UndoRedo.undo'); + arrayEach(instance.getSourceDataArray(), function (rowData, rowIndex) { + arrayEach(ascendingIndexes, function (changedIndex, contiquesIndex) { + rowData[changedIndex] = sortedData[rowIndex][contiquesIndex]; + changes.push([rowIndex, changedIndex, rowData[changedIndex]]); + }); + }); + instance.setSourceDataAtCell(changes); + instance.columnIndexMapper.insertIndexes(ascendingIndexes[0], ascendingIndexes.length); // TODO Temporary hook for undo/redo mess + + if (isFormulaPluginEnabled) { + var setDataAtCellChanges = []; + arrayEach(instance.getSourceDataArray(), function (rowData, rowIndex) { + arrayEach(ascendingIndexes, function (changedIndex, contiquesIndex) { + rowData[changedIndex] = sortedData[rowIndex][contiquesIndex]; + setDataAtCellChanges.push([rowIndex, changedIndex, null, rowData[changedIndex]]); + }); + }); + instance.getPlugin('formulas').onAfterSetDataAtCell(setDataAtCellChanges); + } + + if (typeof this.headers !== 'undefined') { + arrayEach(sortedHeaders, function (headerData, columnIndex) { + instance.getSettings().colHeaders[ascendingIndexes[columnIndex]] = headerData; + }); + } + + instance.batchExecution(function () { + // Restore row sequence in a case when all columns are removed. the original + // row sequence is lost in that case. + instance.rowIndexMapper.setIndexesSequence(_this.rowPositions); + instance.columnIndexMapper.setIndexesSequence(_this.columnPositions); + }, true); + instance.addHookOnce('afterRender', undoneCallback); // TODO Temporary hook for undo/redo mess + + instance.runHooks('afterCreateCol', this.indexes[0], this.indexes.length, 'UndoRedo.undo'); + + if (isFormulaPluginEnabled) { + instance.getPlugin('formulas').recalculateFull(); + } + + instance.render(); +}; + +UndoRedo.RemoveColumnAction.prototype.redo = function (instance, redoneCallback) { + instance.addHookOnce('afterRemoveCol', redoneCallback); + instance.alter('remove_col', this.index, this.amount, 'UndoRedo.redo'); +}; +/** + * Cell alignment action. + * + * @private + * @param {Array} stateBefore The previous state. + * @param {object} range The cell range. + * @param {string} type The type of the alignment ("top", "left", "bottom" or "right"). + * @param {string} alignment The alignment CSS class. + */ + + +UndoRedo.CellAlignmentAction = function (stateBefore, range, type, alignment) { + this.stateBefore = stateBefore; + this.range = range; + this.type = type; + this.alignment = alignment; +}; + +UndoRedo.CellAlignmentAction.prototype.undo = function (instance, undoneCallback) { + var _this2 = this; + + arrayEach(this.range, function (range) { + range.forAll(function (row, col) { + // Alignment classes should only collected within cell ranges. We skip header coordinates. + if (row >= 0 && col >= 0) { + instance.setCellMeta(row, col, 'className', _this2.stateBefore[row][col] || ' htLeft'); + } + }); + }); + instance.addHookOnce('afterRender', undoneCallback); + instance.render(); +}; + +UndoRedo.CellAlignmentAction.prototype.redo = function (instance, undoneCallback) { + align(this.range, this.type, this.alignment, function (row, col) { + return instance.getCellMeta(row, col); + }, function (row, col, key, value) { + return instance.setCellMeta(row, col, key, value); + }); + instance.addHookOnce('afterRender', undoneCallback); + instance.render(); +}; +/** + * Filters action. + * + * @private + * @param {Array} conditionsStack An array of the filter condition. + */ + + +UndoRedo.FiltersAction = function (conditionsStack) { + this.conditionsStack = conditionsStack; + this.actionType = 'filter'; +}; + +inherit(UndoRedo.FiltersAction, UndoRedo.Action); + +UndoRedo.FiltersAction.prototype.undo = function (instance, undoneCallback) { + var filters = instance.getPlugin('filters'); + instance.addHookOnce('afterRender', undoneCallback); + filters.conditionCollection.importAllConditions(this.conditionsStack.slice(0, this.conditionsStack.length - 1)); + filters.filter(); +}; + +UndoRedo.FiltersAction.prototype.redo = function (instance, redoneCallback) { + var filters = instance.getPlugin('filters'); + instance.addHookOnce('afterRender', redoneCallback); + filters.conditionCollection.importAllConditions(this.conditionsStack); + filters.filter(); +}; +/** + * Merge Cells action. + * + * @util + */ + + +var MergeCellsAction = /*#__PURE__*/function (_UndoRedo$Action) { + _inherits$X(MergeCellsAction, _UndoRedo$Action); + + var _super = _createSuper$X(MergeCellsAction); + + function MergeCellsAction(instance, cellRange) { + var _this3; + + _classCallCheck$1Z(this, MergeCellsAction); + + _this3 = _super.call(this); + _this3.cellRange = cellRange; + + var topLeftCorner = _this3.cellRange.getTopLeftCorner(); + + var bottomRightCorner = _this3.cellRange.getBottomRightCorner(); + + _this3.rangeData = instance.getData(topLeftCorner.row, topLeftCorner.col, bottomRightCorner.row, bottomRightCorner.col); + return _this3; + } + + _createClass$1T(MergeCellsAction, [{ + key: "undo", + value: function undo(instance, undoneCallback) { + var mergeCellsPlugin = instance.getPlugin('mergeCells'); + instance.addHookOnce('afterRender', undoneCallback); + mergeCellsPlugin.unmergeRange(this.cellRange, true); + var topLeftCorner = this.cellRange.getTopLeftCorner(); + instance.populateFromArray(topLeftCorner.row, topLeftCorner.col, this.rangeData, void 0, void 0, 'MergeCells'); + } + }, { + key: "redo", + value: function redo(instance, redoneCallback) { + var mergeCellsPlugin = instance.getPlugin('mergeCells'); + instance.addHookOnce('afterRender', redoneCallback); + mergeCellsPlugin.mergeRange(this.cellRange); + } + }]); + + return MergeCellsAction; +}(UndoRedo.Action); + +UndoRedo.MergeCellsAction = MergeCellsAction; +/** + * Unmerge Cells action. + * + * @util + */ + +var UnmergeCellsAction = /*#__PURE__*/function (_UndoRedo$Action2) { + _inherits$X(UnmergeCellsAction, _UndoRedo$Action2); + + var _super2 = _createSuper$X(UnmergeCellsAction); + + function UnmergeCellsAction(instance, cellRange) { + var _this4; + + _classCallCheck$1Z(this, UnmergeCellsAction); + + _this4 = _super2.call(this); + _this4.cellRange = cellRange; + return _this4; + } + + _createClass$1T(UnmergeCellsAction, [{ + key: "undo", + value: function undo(instance, undoneCallback) { + var mergeCellsPlugin = instance.getPlugin('mergeCells'); + instance.addHookOnce('afterRender', undoneCallback); + mergeCellsPlugin.mergeRange(this.cellRange, true); + } + }, { + key: "redo", + value: function redo(instance, redoneCallback) { + var mergeCellsPlugin = instance.getPlugin('mergeCells'); + instance.addHookOnce('afterRender', redoneCallback); + mergeCellsPlugin.unmergeRange(this.cellRange, true); + instance.render(); + } + }]); + + return UnmergeCellsAction; +}(UndoRedo.Action); + +UndoRedo.UnmergeCellsAction = UnmergeCellsAction; +/** + * ManualRowMove action. + * + * @TODO removeRow undo should works on logical index + * @private + * @param {number[]} rows An array with moved rows. + * @param {number} finalIndex The destination index. + */ + +UndoRedo.RowMoveAction = function (rows, finalIndex) { + this.rows = rows.slice(); + this.finalIndex = finalIndex; +}; + +inherit(UndoRedo.RowMoveAction, UndoRedo.Action); + +UndoRedo.RowMoveAction.prototype.undo = function (instance, undoneCallback) { + var _this5 = this; + + var manualRowMove = instance.getPlugin('manualRowMove'); + var copyOfRows = [].concat(this.rows); + var rowsMovedUp = copyOfRows.filter(function (a) { + return a > _this5.finalIndex; + }); + var rowsMovedDown = copyOfRows.filter(function (a) { + return a <= _this5.finalIndex; + }); + var allMovedRows = rowsMovedUp.sort(function (a, b) { + return b - a; + }).concat(rowsMovedDown.sort(function (a, b) { + return a - b; + })); + instance.addHookOnce('afterRender', undoneCallback); // Moving rows from those with higher indexes to those with lower indexes when action was performed from bottom to top + // Moving rows from those with lower indexes to those with higher indexes when action was performed from top to bottom + + for (var i = 0; i < allMovedRows.length; i += 1) { + var newPhysicalRow = instance.toVisualRow(allMovedRows[i]); + manualRowMove.moveRow(newPhysicalRow, allMovedRows[i]); + } + + instance.render(); + instance.deselectCell(); + instance.selectRows(this.rows[0], this.rows[0] + this.rows.length - 1); +}; + +UndoRedo.RowMoveAction.prototype.redo = function (instance, redoneCallback) { + var manualRowMove = instance.getPlugin('manualRowMove'); + instance.addHookOnce('afterRender', redoneCallback); + manualRowMove.moveRows(this.rows.slice(), this.finalIndex); + instance.render(); + instance.deselectCell(); + instance.selectRows(this.finalIndex, this.finalIndex + this.rows.length - 1); +}; +/** + * + */ + + +function init() { + var instance = this; + var settings = instance.getSettings().undo; + var pluginEnabled = typeof settings === 'undefined' || settings; + + if (!instance.undoRedo) { + /** + * Instance of Handsontable.UndoRedo Plugin {@link Handsontable.UndoRedo}. + * + * @alias undoRedo + * @memberof! Handsontable.Core# + * @type {UndoRedo} + */ + instance.undoRedo = new UndoRedo(instance); + } + + if (pluginEnabled) { + instance.undoRedo.enable(); + } else { + instance.undoRedo.disable(); + } +} +/** + * @param {Event} event The keyboard event object. + */ + + +function onBeforeKeyDown(event) { + if (isImmediatePropagationStopped(event)) { + return; + } + + var instance = this; + var editor = instance.getActiveEditor(); + + if (editor && editor.isOpened()) { + return; + } + + var altKey = event.altKey, + ctrlKey = event.ctrlKey, + keyCode = event.keyCode, + metaKey = event.metaKey, + shiftKey = event.shiftKey; + var isCtrlDown = (ctrlKey || metaKey) && !altKey; + + if (!isCtrlDown) { + return; + } + + var isRedoHotkey = keyCode === 89 || shiftKey && keyCode === 90; + + if (isRedoHotkey) { + // CTRL + Y or CTRL + SHIFT + Z + instance.undoRedo.redo(); + stopImmediatePropagation(event); + } else if (keyCode === 90) { + // CTRL + Z + instance.undoRedo.undo(); + stopImmediatePropagation(event); + } +} +/** + * @param {Array} changes 2D array containing information about each of the edited cells. + * @param {string} source String that identifies source of hook call. + * @returns {boolean} + */ + + +function onAfterChange(changes, source) { + var instance = this; + + if (source === 'loadData') { + return instance.undoRedo.clear(); + } +} +/** + * @param {Core} instance The Handsontable instance. + */ + + +function exposeUndoRedoMethods(instance) { + /** + * {@link UndoRedo#undo}. + * + * @alias undo + * @memberof! Handsontable.Core# + * @returns {boolean} + */ + instance.undo = function () { + return instance.undoRedo.undo(); + }; + /** + * {@link UndoRedo#redo}. + * + * @alias redo + * @memberof! Handsontable.Core# + * @returns {boolean} + */ + + + instance.redo = function () { + return instance.undoRedo.redo(); + }; + /** + * {@link UndoRedo#isUndoAvailable}. + * + * @alias isUndoAvailable + * @memberof! Handsontable.Core# + * @returns {boolean} + */ + + + instance.isUndoAvailable = function () { + return instance.undoRedo.isUndoAvailable(); + }; + /** + * {@link UndoRedo#isRedoAvailable}. + * + * @alias isRedoAvailable + * @memberof! Handsontable.Core# + * @returns {boolean} + */ + + + instance.isRedoAvailable = function () { + return instance.undoRedo.isRedoAvailable(); + }; + /** + * {@link UndoRedo#clear}. + * + * @alias clearUndo + * @memberof! Handsontable.Core# + * @returns {boolean} + */ + + + instance.clearUndo = function () { + return instance.undoRedo.clear(); + }; +} +/** + * @param {Core} instance The Handsontable instance. + */ + + +function removeExposedUndoRedoMethods(instance) { + delete instance.undo; + delete instance.redo; + delete instance.isUndoAvailable; + delete instance.isRedoAvailable; + delete instance.clearUndo; +} + +var hook = Hooks.getSingleton(); +hook.add('afterInit', init); +hook.add('afterUpdateSettings', init); +hook.register('beforeUndo'); +hook.register('afterUndo'); +hook.register('beforeRedo'); +hook.register('afterRedo'); +UndoRedo.PLUGIN_KEY = PLUGIN_KEY$m; + +function _typeof$18(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$18 = function _typeof(obj) { return typeof obj; }; } else { _typeof$18 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$18(obj); } + +function _classCallCheck$1_(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1U(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); } } + +function _createClass$1U(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1U(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1U(Constructor, staticProps); return Constructor; } + +function _get$A(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$A = Reflect.get; } else { _get$A = function _get(target, property, receiver) { var base = _superPropBase$A(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$A(target, property, receiver || target); } + +function _superPropBase$A(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$Y(object); if (object === null) break; } return object; } + +function _inherits$Y(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$Z(subClass, superClass); } + +function _setPrototypeOf$Z(o, p) { _setPrototypeOf$Z = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$Z(o, p); } + +function _createSuper$Y(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$Z(); return function _createSuperInternal() { var Super = _getPrototypeOf$Y(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$Y(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$Y(this, result); }; } + +function _possibleConstructorReturn$Y(self, call) { if (call && (_typeof$18(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$Y(self); } + +function _assertThisInitialized$Y(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$Z() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$Y(o) { _getPrototypeOf$Y = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$Y(o); } + +var _alterUtilsFactory = alterUtilsFactory('physicallyIndexed'), + getListWithInsertedItems$2 = _alterUtilsFactory.getListWithInsertedItems, + getListWithRemovedItems$2 = _alterUtilsFactory.getListWithRemovedItems; +/** + * Map from physical index to another index. + */ + + +var LooseBindsMap = /*#__PURE__*/function (_IndexMap) { + _inherits$Y(LooseBindsMap, _IndexMap); + + var _super = _createSuper$Y(LooseBindsMap); + + function LooseBindsMap() { + _classCallCheck$1_(this, LooseBindsMap); + + return _super.call(this, function (index) { + return index; + }); + } + /** + * Add values to list and reorganize. + * + * @private + * @param {number} insertionIndex Position inside the list. + * @param {Array} insertedIndexes List of inserted indexes. + */ + + + _createClass$1U(LooseBindsMap, [{ + key: "insert", + value: function insert(insertionIndex, insertedIndexes) { + var listAfterUpdate = getIncreasedIndexes(this.indexedValues, insertedIndexes); + this.indexedValues = getListWithInsertedItems$2(listAfterUpdate, insertionIndex, insertedIndexes, this.initValueOrFn); + + _get$A(_getPrototypeOf$Y(LooseBindsMap.prototype), "insert", this).call(this, insertionIndex, insertedIndexes); + } + /** + * Remove values from the list and reorganize. + * + * @private + * @param {Array} removedIndexes List of removed indexes. + */ + + }, { + key: "remove", + value: function remove(removedIndexes) { + var listAfterUpdate = getListWithRemovedItems$2(this.indexedValues, removedIndexes); + this.indexedValues = getDecreasedIndexes(listAfterUpdate, removedIndexes); + + _get$A(_getPrototypeOf$Y(LooseBindsMap.prototype), "remove", this).call(this, removedIndexes); + } + }]); + + return LooseBindsMap; +}(IndexMap); + +function _typeof$19(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$19 = function _typeof(obj) { return typeof obj; }; } else { _typeof$19 = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$19(obj); } + +function _toConsumableArray$o(arr) { return _arrayWithoutHoles$m(arr) || _iterableToArray$o(arr) || _unsupportedIterableToArray$H(arr) || _nonIterableSpread$m(); } + +function _nonIterableSpread$m() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$H(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$H(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$H(o, minLen); } + +function _iterableToArray$o(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$m(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$H(arr); } + +function _arrayLikeToArray$H(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$1$(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1V(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); } } + +function _createClass$1V(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1V(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1V(Constructor, staticProps); return Constructor; } + +function _get$B(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$B = Reflect.get; } else { _get$B = function _get(target, property, receiver) { var base = _superPropBase$B(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$B(target, property, receiver || target); } + +function _superPropBase$B(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$Z(object); if (object === null) break; } return object; } + +function _inherits$Z(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$_(subClass, superClass); } + +function _setPrototypeOf$_(o, p) { _setPrototypeOf$_ = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$_(o, p); } + +function _createSuper$Z(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$_(); return function _createSuperInternal() { var Super = _getPrototypeOf$Z(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$Z(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$Z(this, result); }; } + +function _possibleConstructorReturn$Z(self, call) { if (call && (_typeof$19(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$Z(self); } + +function _assertThisInitialized$Z(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$_() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$Z(o) { _getPrototypeOf$Z = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$Z(o); } + +var _alterUtilsFactory$1 = alterUtilsFactory('physicallyIndexed'), + getListWithInsertedItems$3 = _alterUtilsFactory$1.getListWithInsertedItems, + getListWithRemovedItems$3 = _alterUtilsFactory$1.getListWithRemovedItems; +/** + * Map from physical index to another index. + */ + + +var StrictBindsMap = /*#__PURE__*/function (_IndexMap) { + _inherits$Z(StrictBindsMap, _IndexMap); + + var _super = _createSuper$Z(StrictBindsMap); + + function StrictBindsMap() { + _classCallCheck$1$(this, StrictBindsMap); + + return _super.call(this, function (index) { + return index; + }); + } + /** + * Add values to list and reorganize. + * + * @private + * @param {number} insertionIndex Position inside the list. + * @param {Array} insertedIndexes List of inserted indexes. + */ + + + _createClass$1V(StrictBindsMap, [{ + key: "insert", + value: function insert(insertionIndex, insertedIndexes) { + var _this = this; + + this.indexedValues = getListWithInsertedItems$3(this.indexedValues, insertionIndex, insertedIndexes, function (_, ordinalNumber) { + return _this.getNextValue(ordinalNumber); + }); + + _get$B(_getPrototypeOf$Z(StrictBindsMap.prototype), "insert", this).call(this, insertionIndex, insertedIndexes); + } + /** + * Remove values from the list and reorganize. + * + * @private + * @param {Array} removedIndexes List of removed indexes. + */ + + }, { + key: "remove", + value: function remove(removedIndexes) { + this.indexedValues = getListWithRemovedItems$3(this.indexedValues, removedIndexes); + + _get$B(_getPrototypeOf$Z(StrictBindsMap.prototype), "remove", this).call(this, removedIndexes); + } + /** + * Get next values, which should be greater than actual maximum value in the list. + * + * @param {number} ordinalNumber Position in the list. + * @returns {number} + */ + + }, { + key: "getNextValue", + value: function getNextValue(ordinalNumber) { + return Math.max.apply(Math, _toConsumableArray$o(this.getValues())) + 1 + ordinalNumber; + } + }]); + + return StrictBindsMap; +}(IndexMap); + +function _typeof$1a(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1a = function _typeof(obj) { return typeof obj; }; } else { _typeof$1a = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1a(obj); } + +function _classCallCheck$20(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1W(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); } } + +function _createClass$1W(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1W(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1W(Constructor, staticProps); return Constructor; } + +function _get$C(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$C = Reflect.get; } else { _get$C = function _get(target, property, receiver) { var base = _superPropBase$C(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$C(target, property, receiver || target); } + +function _superPropBase$C(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$_(object); if (object === null) break; } return object; } + +function _inherits$_(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$$(subClass, superClass); } + +function _setPrototypeOf$$(o, p) { _setPrototypeOf$$ = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$$(o, p); } + +function _createSuper$_(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$$(); return function _createSuperInternal() { var Super = _getPrototypeOf$_(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$_(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$_(this, result); }; } + +function _possibleConstructorReturn$_(self, call) { if (call && (_typeof$1a(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$_(self); } + +function _assertThisInitialized$_(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$$() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$_(o) { _getPrototypeOf$_ = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$_(o); } +var PLUGIN_KEY$n = 'bindRowsWithHeaders'; +var PLUGIN_PRIORITY$l = 210; +var DEFAULT_BIND = 'loose'; +var bindTypeToMapStrategy = new Map([['loose', LooseBindsMap], ['strict', StrictBindsMap]]); +/** + * @plugin BindRowsWithHeaders + * + * @description + * Plugin allows binding the table rows with their headers. + * + * If the plugin is enabled, the table row headers will "stick" to the rows, when they are hidden/moved. Basically, if + * at the initialization row 0 has a header titled "A", it will have it no matter what you do with the table. + * + * @example + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData(), + * // enable plugin + * bindRowsWithHeaders: true + * }); + * ``` + */ + +var BindRowsWithHeaders = /*#__PURE__*/function (_BasePlugin) { + _inherits$_(BindRowsWithHeaders, _BasePlugin); + + var _super = _createSuper$_(BindRowsWithHeaders); + + function BindRowsWithHeaders(hotInstance) { + var _this; + + _classCallCheck$20(this, BindRowsWithHeaders); + + _this = _super.call(this, hotInstance); + /** + * Plugin indexes cache. + * + * @private + * @type {null|IndexMap} + */ + + _this.headerIndexes = null; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link BindRowsWithHeaders#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1W(BindRowsWithHeaders, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$n]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var bindType = this.hot.getSettings()[PLUGIN_KEY$n]; + + if (typeof bindType !== 'string') { + bindType = DEFAULT_BIND; + } + + var MapStrategy = bindTypeToMapStrategy.get(bindType); + this.headerIndexes = this.hot.rowIndexMapper.registerMap('bindRowsWithHeaders', new MapStrategy()); + this.addHook('modifyRowHeader', function (row) { + return _this2.onModifyRowHeader(row); + }); + + _get$C(_getPrototypeOf$_(BindRowsWithHeaders.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.hot.rowIndexMapper.unregisterMap('bindRowsWithHeaders'); + + _get$C(_getPrototypeOf$_(BindRowsWithHeaders.prototype), "disablePlugin", this).call(this); + } + /** + * On modify row header listener. + * + * @private + * @param {number} row Row index. + * @returns {number} + */ + + }, { + key: "onModifyRowHeader", + value: function onModifyRowHeader(row) { + return this.headerIndexes.getValueAtIndex(this.hot.toPhysicalRow(row)); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.rowIndexMapper.unregisterMap('bindRowsWithHeaders'); + + _get$C(_getPrototypeOf$_(BindRowsWithHeaders.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$n; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$l; + } + }]); + + return BindRowsWithHeaders; +}(BasePlugin); + +// `thisNumberValue` abstract operation +// https://tc39.es/ecma262/#sec-thisnumbervalue +var thisNumberValue = function (value) { + if (typeof value != 'number' && classofRaw(value) != 'Number') { + throw TypeError('Incorrect invocation'); + } + return +value; +}; + +var nativeToFixed = 1.0.toFixed; +var floor$3 = Math.floor; + +var pow = function (x, n, acc) { + return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc); +}; + +var log = function (x) { + var n = 0; + var x2 = x; + while (x2 >= 4096) { + n += 12; + x2 /= 4096; + } + while (x2 >= 2) { + n += 1; + x2 /= 2; + } return n; +}; + +var multiply = function (data, n, c) { + var index = -1; + var c2 = c; + while (++index < 6) { + c2 += n * data[index]; + data[index] = c2 % 1e7; + c2 = floor$3(c2 / 1e7); + } +}; + +var divide = function (data, n) { + var index = 6; + var c = 0; + while (--index >= 0) { + c += data[index]; + data[index] = floor$3(c / n); + c = (c % n) * 1e7; + } +}; + +var dataToString = function (data) { + var index = 6; + var s = ''; + while (--index >= 0) { + if (s !== '' || index === 0 || data[index] !== 0) { + var t = String(data[index]); + s = s === '' ? t : s + stringRepeat.call('0', 7 - t.length) + t; + } + } return s; +}; + +var FORCED$5 = nativeToFixed && ( + 0.00008.toFixed(3) !== '0.000' || + 0.9.toFixed(0) !== '1' || + 1.255.toFixed(2) !== '1.25' || + 1000000000000000128.0.toFixed(0) !== '1000000000000000128' +) || !fails(function () { + // V8 ~ Android 4.3- + nativeToFixed.call({}); +}); + +// `Number.prototype.toFixed` method +// https://tc39.es/ecma262/#sec-number.prototype.tofixed +_export({ target: 'Number', proto: true, forced: FORCED$5 }, { + toFixed: function toFixed(fractionDigits) { + var number = thisNumberValue(this); + var fractDigits = toInteger(fractionDigits); + var data = [0, 0, 0, 0, 0, 0]; + var sign = ''; + var result = '0'; + var e, z, j, k; + + if (fractDigits < 0 || fractDigits > 20) throw RangeError('Incorrect fraction digits'); + // eslint-disable-next-line no-self-compare -- NaN check + if (number != number) return 'NaN'; + if (number <= -1e21 || number >= 1e21) return String(number); + if (number < 0) { + sign = '-'; + number = -number; + } + if (number > 1e-21) { + e = log(number * pow(2, 69, 1)) - 69; + z = e < 0 ? number * pow(2, -e, 1) : number / pow(2, e, 1); + z *= 0x10000000000000; + e = 52 - e; + if (e > 0) { + multiply(data, 0, z); + j = fractDigits; + while (j >= 7) { + multiply(data, 1e7, 0); + j -= 7; + } + multiply(data, pow(10, j, 1), 0); + j = e - 1; + while (j >= 23) { + divide(data, 1 << 23); + j -= 23; + } + divide(data, 1 << j); + multiply(data, 1, 1); + divide(data, 2); + result = dataToString(data); + } else { + multiply(data, 0, z); + multiply(data, 1 << -e, 0); + result = dataToString(data) + stringRepeat.call('0', fractDigits); + } + } + if (fractDigits > 0) { + k = result.length; + result = sign + (k <= fractDigits + ? '0.' + stringRepeat.call('0', fractDigits - k) + result + : result.slice(0, k - fractDigits) + '.' + result.slice(k - fractDigits)); + } else { + result = sign + result; + } return result; + } +}); + +function _classCallCheck$21(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1X(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); } } + +function _createClass$1X(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1X(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1X(Constructor, staticProps); return Constructor; } +/** + * Class used to make all endpoint-related operations. + * + * @class Endpoints + * @plugin ColumnSummary + */ + +var Endpoints = /*#__PURE__*/function () { + function Endpoints(plugin, settings) { + _classCallCheck$21(this, Endpoints); + + /** + * The main plugin instance. + */ + this.plugin = plugin; + /** + * Handsontable instance. + * + * @type {object} + */ + + this.hot = this.plugin.hot; + /** + * Array of declared plugin endpoints (calculation destination points). + * + * @type {Array} + * @default {Array} Empty array. + */ + + this.endpoints = []; + /** + * The plugin settings, taken from Handsontable configuration. + * + * @type {object|Function} + * @default null + */ + + this.settings = settings; + /** + * Settings type. Can be either 'array' or 'function. + * + * @type {string} + * @default {'array'} + */ + + this.settingsType = 'array'; + /** + * The current endpoint (calculation destination point) in question. + * + * @type {object} + * @default null + */ + + this.currentEndpoint = null; + /** + * Array containing a list of changes to be applied. + * + * @private + * @type {Array} + * @default {[]} + */ + + this.cellsToSetCache = []; + } + /** + * Get a single endpoint object. + * + * @param {number} index Index of the endpoint. + * @returns {object} + */ + + + _createClass$1X(Endpoints, [{ + key: "getEndpoint", + value: function getEndpoint(index) { + if (this.settingsType === 'function') { + return this.fillMissingEndpointData(this.settings)[index]; + } + + return this.endpoints[index]; + } + /** + * Get an array with all the endpoints. + * + * @returns {Array} + */ + + }, { + key: "getAllEndpoints", + value: function getAllEndpoints() { + if (this.settingsType === 'function') { + return this.fillMissingEndpointData(this.settings); + } + + return this.endpoints; + } + /** + * Used to fill the blanks in the endpoint data provided by a settings function. + * + * @private + * @param {Function} func Function provided in the HOT settings. + * @returns {Array} An array of endpoints. + */ + + }, { + key: "fillMissingEndpointData", + value: function fillMissingEndpointData(func) { + return this.parseSettings(func.call(this)); + } + /** + * Parse plugin's settings. + * + * @param {Array} settings The settings array. + * @returns {object[]} + */ + + }, { + key: "parseSettings", + value: function parseSettings(settings) { + var _this = this; + + var endpointsArray = []; + var settingsArray = settings; + + if (!settingsArray && typeof this.settings === 'function') { + this.settingsType = 'function'; + return; + } + + if (!settingsArray) { + settingsArray = this.settings; + } + + arrayEach(settingsArray, function (val) { + var newEndpoint = {}; + + _this.assignSetting(val, newEndpoint, 'ranges', [[0, _this.hot.countRows() - 1]]); + + _this.assignSetting(val, newEndpoint, 'reversedRowCoords', false); + + _this.assignSetting(val, newEndpoint, 'destinationRow', new Error("\n You must provide a destination row for the Column Summary plugin in order to work properly!\n ")); + + _this.assignSetting(val, newEndpoint, 'destinationColumn', new Error("\n You must provide a destination column for the Column Summary plugin in order to work properly!\n ")); + + _this.assignSetting(val, newEndpoint, 'sourceColumn', val.destinationColumn); + + _this.assignSetting(val, newEndpoint, 'type', 'sum'); + + _this.assignSetting(val, newEndpoint, 'forceNumeric', false); + + _this.assignSetting(val, newEndpoint, 'suppressDataTypeErrors', true); + + _this.assignSetting(val, newEndpoint, 'suppressDataTypeErrors', true); + + _this.assignSetting(val, newEndpoint, 'customFunction', null); + + _this.assignSetting(val, newEndpoint, 'readOnly', true); + + _this.assignSetting(val, newEndpoint, 'roundFloat', false); + + endpointsArray.push(newEndpoint); + }); + return endpointsArray; + } + /** + * Setter for the internal setting objects. + * + * @param {object} settings Object with the settings. + * @param {object} endpoint Contains information about the endpoint for the the calculation. + * @param {string} name Settings name. + * @param {object} defaultValue Default value for the settings. + */ + + }, { + key: "assignSetting", + value: function assignSetting(settings, endpoint, name, defaultValue) { + if (name === 'ranges' && settings[name] === void 0) { + endpoint[name] = defaultValue; + return; + } else if (name === 'ranges' && settings[name].length === 0) { + return; + } + + if (settings[name] === void 0) { + if (defaultValue instanceof Error) { + throw defaultValue; + } + + endpoint[name] = defaultValue; + } else { + /* eslint-disable no-lonely-if */ + if (name === 'destinationRow' && endpoint.reversedRowCoords) { + endpoint[name] = this.hot.countRows() - settings[name] - 1; + } else { + endpoint[name] = settings[name]; + } + } + } + /** + * Resets the endpoint setup before the structure alteration (like inserting or removing rows/columns). Used for settings provided as a function. + * + * @private + * @param {string} action Type of the action performed. + * @param {number} index Row/column index. + * @param {number} number Number of rows/columns added/removed. + */ + + }, { + key: "resetSetupBeforeStructureAlteration", + value: function resetSetupBeforeStructureAlteration(action, index, number) { + if (this.settingsType !== 'function') { + return; + } + + var type = action.indexOf('row') > -1 ? 'row' : 'col'; + var endpoints = this.getAllEndpoints(); + arrayEach(endpoints, function (val) { + if (type === 'row' && val.destinationRow >= index) { + if (action === 'insert_row') { + val.alterRowOffset = number; + } else if (action === 'remove_row') { + val.alterRowOffset = -1 * number; + } + } + + if (type === 'col' && val.destinationColumn >= index) { + if (action === 'insert_col') { + val.alterColumnOffset = number; + } else if (action === 'remove_col') { + val.alterColumnOffset = -1 * number; + } + } + }); + this.resetAllEndpoints(endpoints, false); + } + /** + * AfterCreateRow/afterCreateRow/afterRemoveRow/afterRemoveCol hook callback. Reset and reenables the summary functionality + * after changing the table structure. + * + * @private + * @param {string} action Type of the action performed. + * @param {number} index Row/column index. + * @param {number} number Number of rows/columns added/removed. + * @param {Array} [logicRows] Array of the logical indexes. + * @param {string} [source] Source of change. + * @param {boolean} [forceRefresh] `true` of the endpoints should refresh after completing the function. + */ + + }, { + key: "resetSetupAfterStructureAlteration", + value: function resetSetupAfterStructureAlteration(action, index, number, logicRows, source) { + var _this2 = this; + + var forceRefresh = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true; + + if (this.settingsType === 'function') { + // We need to run it on a next avaiable hook, because the TrimRows' `afterCreateRow` hook triggers after this one, + // and it needs to be run to properly calculate the endpoint value. + var beforeRenderCallback = function beforeRenderCallback() { + _this2.hot.removeHook('beforeRender', beforeRenderCallback); + + return _this2.refreshAllEndpoints(); + }; + + this.hot.addHookOnce('beforeRender', beforeRenderCallback); + return; + } + + var type = action.indexOf('row') > -1 ? 'row' : 'col'; + var multiplier = action.indexOf('remove') > -1 ? -1 : 1; + var endpoints = this.getAllEndpoints(); + var rowMoving = action.indexOf('move_row') === 0; + var placeOfAlteration = index; + arrayEach(endpoints, function (val) { + if (type === 'row' && val.destinationRow >= placeOfAlteration) { + val.alterRowOffset = multiplier * number; + } + + if (type === 'col' && val.destinationColumn >= placeOfAlteration) { + val.alterColumnOffset = multiplier * number; + } + }); + this.resetAllEndpoints(endpoints, !rowMoving); + + if (rowMoving) { + arrayEach(endpoints, function (endpoint) { + _this2.extendEndpointRanges(endpoint, placeOfAlteration, logicRows[0], logicRows.length); + + _this2.recreatePhysicalRanges(endpoint); + + _this2.clearOffsetInformation(endpoint); + }); + } else { + arrayEach(endpoints, function (endpoint) { + _this2.shiftEndpointCoordinates(endpoint, placeOfAlteration); + }); + } + + if (forceRefresh) { + this.refreshAllEndpoints(); + } + } + /** + * Clear the offset information from the endpoint object. + * + * @private + * @param {object} endpoint And endpoint object. + */ + + }, { + key: "clearOffsetInformation", + value: function clearOffsetInformation(endpoint) { + endpoint.alterRowOffset = void 0; + endpoint.alterColumnOffset = void 0; + } + /** + * Extend the row ranges for the provided endpoint. + * + * @private + * @param {object} endpoint The endpoint object. + * @param {number} placeOfAlteration Index of the row where the alteration takes place. + * @param {number} previousPosition Previous endpoint result position. + * @param {number} offset Offset generated by the alteration. + */ + + }, { + key: "extendEndpointRanges", + value: function extendEndpointRanges(endpoint, placeOfAlteration, previousPosition, offset) { + arrayEach(endpoint.ranges, function (range) { + // is a range, not a single row + if (range[1]) { + if (placeOfAlteration >= range[0] && placeOfAlteration <= range[1]) { + if (previousPosition > range[1]) { + range[1] += offset; + } else if (previousPosition < range[0]) { + range[0] -= offset; + } + } else if (previousPosition >= range[0] && previousPosition <= range[1]) { + range[1] -= offset; + + if (placeOfAlteration <= range[0]) { + range[0] += 1; + range[1] += 1; + } + } + } + }); + } + /** + * Recreate the physical ranges for the provided endpoint. Used (for example) when a row gets moved and extends an existing range. + * + * @private + * @param {object} endpoint An endpoint object. + */ + + }, { + key: "recreatePhysicalRanges", + value: function recreatePhysicalRanges(endpoint) { + var _this3 = this; + + var ranges = endpoint.ranges; + var newRanges = []; + var allIndexes = []; + arrayEach(ranges, function (range) { + var newRange = []; + + if (range[1]) { + for (var i = range[0]; i <= range[1]; i++) { + newRange.push(_this3.hot.toPhysicalRow(i)); + } + } else { + newRange.push(_this3.hot.toPhysicalRow(range[0])); + } + + allIndexes.push(newRange); + }); + arrayEach(allIndexes, function (range) { + var newRange = []; + arrayEach(range, function (coord, index) { + if (index === 0) { + newRange.push(coord); + } else if (range[index] !== range[index - 1] + 1) { + newRange.push(range[index - 1]); + newRanges.push(newRange); + newRange = []; + newRange.push(coord); + } + + if (index === range.length - 1) { + newRange.push(coord); + newRanges.push(newRange); + } + }); + }); + endpoint.ranges = newRanges; + } + /** + * Shifts the endpoint coordinates by the defined offset. + * + * @private + * @param {object} endpoint Endpoint object. + * @param {number} offsetStartIndex Index of the performed change (if the change is located after the endpoint, nothing about the endpoint has to be changed. + */ + + }, { + key: "shiftEndpointCoordinates", + value: function shiftEndpointCoordinates(endpoint, offsetStartIndex) { + if (endpoint.alterRowOffset && endpoint.alterRowOffset !== 0) { + endpoint.destinationRow += endpoint.alterRowOffset || 0; + arrayEach(endpoint.ranges, function (element) { + arrayEach(element, function (subElement, j) { + if (subElement >= offsetStartIndex) { + element[j] += endpoint.alterRowOffset || 0; + } + }); + }); + } else if (endpoint.alterColumnOffset && endpoint.alterColumnOffset !== 0) { + endpoint.destinationColumn += endpoint.alterColumnOffset || 0; + endpoint.sourceColumn += endpoint.alterColumnOffset || 0; + } + } + /** + * Resets (removes) the endpoints from the table. + * + * @param {Array} [endpoints] Array containing the endpoints. + * @param {boolean} [useOffset=true] Use the cell offset value. + */ + + }, { + key: "resetAllEndpoints", + value: function resetAllEndpoints() { + var _this4 = this; + + var endpoints = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getAllEndpoints(); + var useOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var anyEndpointOutOfRange = endpoints.some(function (endpoint) { + var alterRowOffset = endpoint.alterRowOffset || 0; + var alterColOffset = endpoint.alterColumnOffset || 0; + + if (endpoint.destinationRow + alterRowOffset >= _this4.hot.countRows() || endpoint.destinationColumn + alterColOffset >= _this4.hot.countCols()) { + return true; + } + + return false; + }); + + if (anyEndpointOutOfRange) { + return; + } + + this.cellsToSetCache = []; + arrayEach(endpoints, function (endpoint) { + _this4.resetEndpointValue(endpoint, useOffset); + }); + this.hot.setDataAtCell(this.cellsToSetCache, 'ColumnSummary.reset'); + this.cellsToSetCache = []; + } + /** + * Calculate and refresh all defined endpoints. + */ + + }, { + key: "refreshAllEndpoints", + value: function refreshAllEndpoints() { + var _this5 = this; + + this.cellsToSetCache = []; + arrayEach(this.getAllEndpoints(), function (value) { + _this5.currentEndpoint = value; + + _this5.plugin.calculate(value); + + _this5.setEndpointValue(value, 'init'); + }); + this.currentEndpoint = null; + this.hot.setDataAtCell(this.cellsToSetCache, 'ColumnSummary.reset'); + this.cellsToSetCache = []; + } + /** + * Calculate and refresh endpoints only in the changed columns. + * + * @param {Array} changes Array of changes from the `afterChange` hook. + */ + + }, { + key: "refreshChangedEndpoints", + value: function refreshChangedEndpoints(changes) { + var _this6 = this; + + var needToRefresh = []; + this.cellsToSetCache = []; + arrayEach(changes, function (value, key, changesObj) { + // if nothing changed, dont update anything + if ("".concat(value[2] || '') === "".concat(value[3])) { + return; + } + + arrayEach(_this6.getAllEndpoints(), function (endpoint, j) { + if (_this6.hot.propToCol(changesObj[key][1]) === endpoint.sourceColumn && needToRefresh.indexOf(j) === -1) { + needToRefresh.push(j); + } + }); + }); + arrayEach(needToRefresh, function (value) { + _this6.refreshEndpoint(_this6.getEndpoint(value)); + }); + this.hot.setDataAtCell(this.cellsToSetCache, 'ColumnSummary.reset'); + this.cellsToSetCache = []; + } + /** + * Calculate and refresh a single endpoint. + * + * @param {object} endpoint Contains the endpoint information. + */ + + }, { + key: "refreshEndpoint", + value: function refreshEndpoint(endpoint) { + this.currentEndpoint = endpoint; + this.plugin.calculate(endpoint); + this.setEndpointValue(endpoint); + this.currentEndpoint = null; + } + /** + * Reset the endpoint value. + * + * @param {object} endpoint Contains the endpoint information. + * @param {boolean} [useOffset=true] Use the cell offset value. + */ + + }, { + key: "resetEndpointValue", + value: function resetEndpointValue(endpoint) { + var useOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var alterRowOffset = endpoint.alterRowOffset || 0; + var alterColOffset = endpoint.alterColumnOffset || 0; + var _ref = [this.hot.toVisualRow(endpoint.destinationRow), this.hot.toVisualColumn(endpoint.destinationColumn)], + visualRowIndex = _ref[0], + visualColumnIndex = _ref[1]; + + if (visualColumnIndex !== null && visualRowIndex !== null) { + // Clear the meta on the "old" indexes + var cellMeta = this.hot.getCellMeta(visualRowIndex, visualColumnIndex); + cellMeta.readOnly = false; + cellMeta.className = ''; + } + + this.cellsToSetCache.push([this.hot.toVisualRow(endpoint.destinationRow + (useOffset ? alterRowOffset : 0)), this.hot.toVisualColumn(endpoint.destinationColumn + (useOffset ? alterColOffset : 0)), '']); + } + /** + * Set the endpoint value. + * + * @param {object} endpoint Contains the endpoint information. + * @param {string} [source] Source of the call information. + * @param {boolean} [render=false] `true` if it needs to render the table afterwards. + */ + + }, { + key: "setEndpointValue", + value: function setEndpointValue(endpoint, source) { + var render = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + // We'll need the reversed offset values, because cellMeta will be shifted AGAIN afterwards. + var reverseRowOffset = -1 * endpoint.alterRowOffset || 0; + var reverseColOffset = -1 * endpoint.alterColumnOffset || 0; + var visualEndpointRowIndex = this.hot.toVisualRow(endpoint.destinationRow); + + if (endpoint.destinationRow >= this.hot.countRows() || endpoint.destinationColumn >= this.hot.countCols()) { + this.throwOutOfBoundsWarning(); + return; + } + + var destinationVisualRow = this.hot.toVisualRow(endpoint.destinationRow + reverseRowOffset); + + if (destinationVisualRow !== null) { + var cellMeta = this.hot.getCellMeta(destinationVisualRow, endpoint.destinationColumn + reverseColOffset); + + if (source === 'init' || cellMeta.readOnly !== endpoint.readOnly) { + cellMeta.readOnly = endpoint.readOnly; + cellMeta.className = 'columnSummaryResult'; + } + } + + if (endpoint.roundFloat && !isNaN(endpoint.result)) { + endpoint.result = endpoint.result.toFixed(endpoint.roundFloat); + } + + if (render) { + this.hot.setDataAtCell(visualEndpointRowIndex, endpoint.destinationColumn, endpoint.result, 'ColumnSummary.set'); + } else { + this.cellsToSetCache.push([visualEndpointRowIndex, endpoint.destinationColumn, endpoint.result]); + } + + endpoint.alterRowOffset = void 0; + endpoint.alterColumnOffset = void 0; + } + /** + * Throw an error for the calculation range being out of boundaries. + * + * @private + */ + + }, { + key: "throwOutOfBoundsWarning", + value: function throwOutOfBoundsWarning() { + warn('One of the Column Summary plugins\' destination points you provided is beyond the table boundaries!'); + } + }]); + + return Endpoints; +}(); + +function _typeof$1b(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1b = function _typeof(obj) { return typeof obj; }; } else { _typeof$1b = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1b(obj); } + +var _templateObject$8; + +function _taggedTemplateLiteral$8(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _classCallCheck$22(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1Y(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); } } + +function _createClass$1Y(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1Y(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1Y(Constructor, staticProps); return Constructor; } + +function _get$D(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$D = Reflect.get; } else { _get$D = function _get(target, property, receiver) { var base = _superPropBase$D(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$D(target, property, receiver || target); } + +function _superPropBase$D(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$$(object); if (object === null) break; } return object; } + +function _inherits$$(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$10(subClass, superClass); } + +function _setPrototypeOf$10(o, p) { _setPrototypeOf$10 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$10(o, p); } + +function _createSuper$$(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$10(); return function _createSuperInternal() { var Super = _getPrototypeOf$$(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$$(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$$(this, result); }; } + +function _possibleConstructorReturn$$(self, call) { if (call && (_typeof$1b(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$$(self); } + +function _assertThisInitialized$$(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$10() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$$(o) { _getPrototypeOf$$ = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$$(o); } +var PLUGIN_KEY$o = 'columnSummary'; +var PLUGIN_PRIORITY$m = 220; +/** + * @plugin ColumnSummary + * + * @description + * Allows making pre-defined calculations on the cell values and display the results within Handsontable. + * [See the demo for more information](https://handsontable.com/docs/demo-summary-calculations.html). + * + * @example + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData(), + * colHeaders: true, + * rowHeaders: true, + * columnSummary: [ + * { + * destinationRow: 4, + * destinationColumn: 1, + * type: 'min' + * }, + * { + * destinationRow: 0, + * destinationColumn: 3, + * reversedRowCoords: true, + * type: 'max' + * }, + * { + * destinationRow: 4, + * destinationColumn: 5, + * type: 'sum', + * forceNumeric: true + * } + * ] + * }); + */ + +var ColumnSummary = /*#__PURE__*/function (_BasePlugin) { + _inherits$$(ColumnSummary, _BasePlugin); + + var _super = _createSuper$$(ColumnSummary); + + function ColumnSummary(hotInstance) { + var _this; + + _classCallCheck$22(this, ColumnSummary); + + _this = _super.call(this, hotInstance); + /** + * The Endpoints class instance. Used to make all endpoint-related operations. + * + * @private + * @type {null|Endpoints} + */ + + _this.endpoints = null; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ColumnSummary#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1Y(ColumnSummary, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$o]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.settings = this.hot.getSettings()[PLUGIN_KEY$o]; + this.endpoints = new Endpoints(this, this.settings); + this.addHook('afterInit', function () { + return _this2.onAfterInit.apply(_this2, arguments); + }); + this.addHook('afterChange', function () { + return _this2.onAfterChange.apply(_this2, arguments); + }); + this.addHook('beforeCreateRow', function (index, amount, source) { + return _this2.endpoints.resetSetupBeforeStructureAlteration('insert_row', index, amount, null, source); + }); // eslint-disable-line max-len + + this.addHook('beforeCreateCol', function (index, amount, source) { + return _this2.endpoints.resetSetupBeforeStructureAlteration('insert_col', index, amount, null, source); + }); // eslint-disable-line max-len + + this.addHook('beforeRemoveRow', function () { + var _this2$endpoints; + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return (_this2$endpoints = _this2.endpoints).resetSetupBeforeStructureAlteration.apply(_this2$endpoints, ['remove_row'].concat(args)); + }); + this.addHook('beforeRemoveCol', function () { + var _this2$endpoints2; + + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + return (_this2$endpoints2 = _this2.endpoints).resetSetupBeforeStructureAlteration.apply(_this2$endpoints2, ['remove_col'].concat(args)); + }); + this.addHook('afterCreateRow', function (index, amount, source) { + return _this2.endpoints.resetSetupAfterStructureAlteration('insert_row', index, amount, null, source); + }); // eslint-disable-line max-len + + this.addHook('afterCreateCol', function (index, amount, source) { + return _this2.endpoints.resetSetupAfterStructureAlteration('insert_col', index, amount, null, source); + }); // eslint-disable-line max-len + + this.addHook('afterRemoveRow', function () { + var _this2$endpoints3; + + for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments[_key3]; + } + + return (_this2$endpoints3 = _this2.endpoints).resetSetupAfterStructureAlteration.apply(_this2$endpoints3, ['remove_row'].concat(args)); + }); + this.addHook('afterRemoveCol', function () { + var _this2$endpoints4; + + for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { + args[_key4] = arguments[_key4]; + } + + return (_this2$endpoints4 = _this2.endpoints).resetSetupAfterStructureAlteration.apply(_this2$endpoints4, ['remove_col'].concat(args)); + }); + this.addHook('afterRowMove', function () { + return _this2.onAfterRowMove.apply(_this2, arguments); + }); + + _get$D(_getPrototypeOf$$(ColumnSummary.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.endpoints = null; + this.settings = null; + this.currentEndpoint = null; + } + /** + * Calculates math for a single endpoint. + * + * @private + * @param {object} endpoint Contains information about the endpoint. + */ + + }, { + key: "calculate", + value: function calculate(endpoint) { + switch (endpoint.type.toLowerCase()) { + case 'sum': + endpoint.result = this.calculateSum(endpoint); + break; + + case 'min': + endpoint.result = this.calculateMinMax(endpoint, endpoint.type); + break; + + case 'max': + endpoint.result = this.calculateMinMax(endpoint, endpoint.type); + break; + + case 'count': + endpoint.result = this.countEntries(endpoint); + break; + + case 'average': + endpoint.result = this.calculateAverage(endpoint); + break; + + case 'custom': + endpoint.result = endpoint.customFunction.call(this, endpoint); + break; + } + } + /** + * Calculates sum of the values contained in ranges provided in the plugin config. + * + * @private + * @param {object} endpoint Contains the endpoint information. + * @returns {number} Sum for the selected range. + */ + + }, { + key: "calculateSum", + value: function calculateSum(endpoint) { + var _this3 = this; + + var sum = 0; + objectEach(endpoint.ranges, function (range) { + sum += _this3.getPartialSum(range, endpoint.sourceColumn); + }); + return sum; + } + /** + * Returns partial sum of values from a single row range. + * + * @private + * @param {Array} rowRange Range for the sum. + * @param {number} col Column index. + * @returns {number} The partial sum. + */ + + }, { + key: "getPartialSum", + value: function getPartialSum(rowRange, col) { + var sum = 0; + var i = rowRange[1] || rowRange[0]; + var cellValue = null; + var biggestDecimalPlacesCount = 0; + + do { + cellValue = this.getCellValue(i, col) || 0; + var decimalPlaces = ("".concat(cellValue).split('.')[1] || []).length || 1; + + if (decimalPlaces > biggestDecimalPlacesCount) { + biggestDecimalPlacesCount = decimalPlaces; + } + + sum += cellValue || 0; + i -= 1; + } while (i >= rowRange[0]); // Workaround for e.g. 802.2 + 1.1 = 803.3000000000001 + + + return Math.round(sum * Math.pow(10, biggestDecimalPlacesCount)) / Math.pow(10, biggestDecimalPlacesCount); + } + /** + * Calculates the minimal value for the selected ranges. + * + * @private + * @param {object} endpoint Contains the endpoint information. + * @param {string} type `'min'` or `'max'`. + * @returns {number} Min or Max value. + */ + + }, { + key: "calculateMinMax", + value: function calculateMinMax(endpoint, type) { + var _this4 = this; + + var result = null; + objectEach(endpoint.ranges, function (range) { + var partialResult = _this4.getPartialMinMax(range, endpoint.sourceColumn, type); + + if (result === null && partialResult !== null) { + result = partialResult; + } + + if (partialResult !== null) { + switch (type) { + case 'min': + result = Math.min(result, partialResult); + break; + + case 'max': + result = Math.max(result, partialResult); + break; + } + } + }); + return result === null ? 'Not enough data' : result; + } + /** + * Returns a local minimum of the provided sub-range. + * + * @private + * @param {Array} rowRange Range for the calculation. + * @param {number} col Column index. + * @param {string} type `'min'` or `'max'`. + * @returns {number} Min or max value. + */ + + }, { + key: "getPartialMinMax", + value: function getPartialMinMax(rowRange, col, type) { + var result = null; + var i = rowRange[1] || rowRange[0]; + var cellValue; + + do { + cellValue = this.getCellValue(i, col) || null; + + if (result === null) { + result = cellValue; + } else if (cellValue !== null) { + switch (type) { + case 'min': + result = Math.min(result, cellValue); + break; + + case 'max': + result = Math.max(result, cellValue); + break; + } + } + + i -= 1; + } while (i >= rowRange[0]); + + return result; + } + /** + * Counts empty cells in the provided row range. + * + * @private + * @param {Array} rowRange Row range for the calculation. + * @param {number} col Column index. + * @returns {number} Empty cells count. + */ + + }, { + key: "countEmpty", + value: function countEmpty(rowRange, col) { + var cellValue; + var counter = 0; + var i = rowRange[1] || rowRange[0]; + + do { + cellValue = this.getCellValue(i, col); + + if (!cellValue) { + counter += 1; + } + + i -= 1; + } while (i >= rowRange[0]); + + return counter; + } + /** + * Counts non-empty cells in the provided row range. + * + * @private + * @param {object} endpoint Contains the endpoint information. + * @returns {number} Entry count. + */ + + }, { + key: "countEntries", + value: function countEntries(endpoint) { + var _this5 = this; + + var result = 0; + var ranges = endpoint.ranges; + objectEach(ranges, function (range) { + var partial = range[1] === void 0 ? 1 : range[1] - range[0] + 1; + + var emptyCount = _this5.countEmpty(range, endpoint.sourceColumn); + + result += partial; + result -= emptyCount; + }); + return result; + } + /** + * Calculates the average value from the cells in the range. + * + * @private + * @param {object} endpoint Contains the endpoint information. + * @returns {number} Avarage value. + */ + + }, { + key: "calculateAverage", + value: function calculateAverage(endpoint) { + var sum = this.calculateSum(endpoint); + var entriesCount = this.countEntries(endpoint); + return sum / entriesCount; + } + /** + * Returns a cell value, taking into consideration a basic validation. + * + * @private + * @param {number} row Row index. + * @param {number} col Column index. + * @returns {string} The cell value. + */ + + }, { + key: "getCellValue", + value: function getCellValue(row, col) { + var visualRowIndex = this.hot.toVisualRow(row); + var visualColumnIndex = this.hot.toVisualColumn(col); + var cellValue = this.hot.getSourceDataAtCell(row, col); + var cellClassName = ''; + + if (visualRowIndex !== null && visualColumnIndex !== null) { + cellClassName = this.hot.getCellMeta(visualRowIndex, visualColumnIndex).className || ''; + } + + if (cellClassName.indexOf('columnSummaryResult') > -1) { + return null; + } + + if (this.endpoints.currentEndpoint.forceNumeric) { + if (typeof cellValue === 'string') { + cellValue = cellValue.replace(/,/, '.'); + } + + cellValue = parseFloat(cellValue); + } + + if (isNaN(cellValue)) { + if (!this.endpoints.currentEndpoint.suppressDataTypeErrors) { + throw new Error(toSingleLine(_templateObject$8 || (_templateObject$8 = _taggedTemplateLiteral$8(["ColumnSummary plugin: cell at (", ", ", ") is not in a \n numeric format. Cannot do the calculation."], ["ColumnSummary plugin: cell at (", ", ", ") is not in a\\x20\n numeric format. Cannot do the calculation."])), row, col)); + } + } + + return cellValue; + } + /** + * `afterInit` hook callback. + * + * @private + */ + + }, { + key: "onAfterInit", + value: function onAfterInit() { + this.endpoints.endpoints = this.endpoints.parseSettings(); + this.endpoints.refreshAllEndpoints(true); + } + /** + * `afterChange` hook callback. + * + * @private + * @param {Array} changes 2D array containing information about each of the edited cells. + * @param {string} source The string that identifies source of changes. + */ + + }, { + key: "onAfterChange", + value: function onAfterChange(changes, source) { + if (changes && source !== 'ColumnSummary.reset' && source !== 'ColumnSummary.set' && source !== 'loadData') { + this.endpoints.refreshChangedEndpoints(changes); + } + } + /** + * `beforeRowMove` hook callback. + * + * @private + * @param {Array} rows Array of visual row indexes to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements will be placed after the moving action. + * To check the visualization of the final index, please take a look at [documentation](/docs/demo-moving.html). + */ + + }, { + key: "onAfterRowMove", + value: function onAfterRowMove(rows, finalIndex) { + this.endpoints.resetSetupBeforeStructureAlteration('move_row', rows[0], rows.length, rows, this.pluginName); + this.endpoints.resetSetupAfterStructureAlteration('move_row', finalIndex, rows.length, rows, this.pluginName); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$o; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$m; + } + }]); + + return ColumnSummary; +}(BasePlugin); + +function _typeof$1c(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1c = function _typeof(obj) { return typeof obj; }; } else { _typeof$1c = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1c(obj); } + +function _classCallCheck$23(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1Z(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); } } + +function _createClass$1Z(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1Z(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1Z(Constructor, staticProps); return Constructor; } + +function _get$E(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$E = Reflect.get; } else { _get$E = function _get(target, property, receiver) { var base = _superPropBase$E(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$E(target, property, receiver || target); } + +function _superPropBase$E(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$10(object); if (object === null) break; } return object; } + +function _inherits$10(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$11(subClass, superClass); } + +function _setPrototypeOf$11(o, p) { _setPrototypeOf$11 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$11(o, p); } + +function _createSuper$10(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$11(); return function _createSuperInternal() { var Super = _getPrototypeOf$10(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$10(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$10(this, result); }; } + +function _possibleConstructorReturn$10(self, call) { if (call && (_typeof$1c(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$10(self); } + +function _assertThisInitialized$10(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$11() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$10(o) { _getPrototypeOf$10 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$10(o); } +Hooks.getSingleton().register('afterDropdownMenuDefaultOptions'); +Hooks.getSingleton().register('beforeDropdownMenuShow'); +Hooks.getSingleton().register('afterDropdownMenuShow'); +Hooks.getSingleton().register('afterDropdownMenuHide'); +Hooks.getSingleton().register('afterDropdownMenuExecute'); +var PLUGIN_KEY$p = 'dropdownMenu'; +var PLUGIN_PRIORITY$n = 230; +var BUTTON_CLASS_NAME = 'changeType'; +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @class DropdownMenu + * @plugin DropdownMenu + * + * @description + * This plugin creates the Handsontable Dropdown Menu. It allows to create a new row or column at any place in the grid + * among [other features](https://handsontable.com/docs/demo-context-menu.html). + * Possible values: + * * `true` (to enable default options), + * * `false` (to disable completely). + * + * or array of any available strings: + * * `["row_above", "row_below", "col_left", "col_right", + * "remove_row", "remove_col", "---------", "undo", "redo"]`. + * + * See [the dropdown menu demo](https://handsontable.com/docs/demo-dropdown-menu.html) for examples. + * + * @example + * ``` + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: data, + * colHeaders: true, + * // enable dropdown menu + * dropdownMenu: true + * }); + * + * // or + * const hot = new Handsontable(container, { + * data: data, + * colHeaders: true, + * // enable and configure dropdown menu + * dropdownMenu: ['remove_col', '---------', 'make_read_only', 'alignment'] + * }); + * ``` + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var DropdownMenu = /*#__PURE__*/function (_BasePlugin) { + _inherits$10(DropdownMenu, _BasePlugin); + + var _super = _createSuper$10(DropdownMenu); + + function DropdownMenu(hotInstance) { + var _this; + + _classCallCheck$23(this, DropdownMenu); + + _this = _super.call(this, hotInstance); + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + _this.eventManager = new EventManager(_assertThisInitialized$10(_this)); + /** + * Instance of {@link CommandExecutor}. + * + * @private + * @type {CommandExecutor} + */ + + _this.commandExecutor = new CommandExecutor(_this.hot); + /** + * Instance of {@link ItemsFactory}. + * + * @private + * @type {ItemsFactory} + */ + + _this.itemsFactory = null; + /** + * Instance of {@link Menu}. + * + * @private + * @type {Menu} + */ + + _this.menu = null; // One listener for enable/disable functionality + + _this.hot.addHook('afterGetColHeader', function (col, TH) { + return _this.onAfterGetColHeader(col, TH); + }); + + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link DropdownMenu#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$1Z(DropdownMenu, [{ + key: "isEnabled", + value: function isEnabled() { + return this.hot.getSettings()[PLUGIN_KEY$p]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + * + * @fires Hooks#afterDropdownMenuDefaultOptions + * @fires Hooks#beforeDropdownMenuSetItems + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.itemsFactory = new ItemsFactory(this.hot, DropdownMenu.DEFAULT_ITEMS); + var settings = this.hot.getSettings()[PLUGIN_KEY$p]; + var predefinedItems = { + items: this.itemsFactory.getItems(settings) + }; + this.registerEvents(); + + if (typeof settings.callback === 'function') { + this.commandExecutor.setCommonCallback(settings.callback); + } + + _get$E(_getPrototypeOf$10(DropdownMenu.prototype), "enablePlugin", this).call(this); + + this.callOnPluginsReady(function () { + _this2.hot.runHooks('afterDropdownMenuDefaultOptions', predefinedItems); + + _this2.itemsFactory.setPredefinedItems(predefinedItems.items); + + var menuItems = _this2.itemsFactory.getItems(settings); + + if (_this2.menu) { + _this2.menu.destroy(); + } + + _this2.menu = new Menu(_this2.hot, { + className: 'htDropdownMenu', + keepInViewport: true, + container: settings.uiContainer || _this2.hot.rootDocument.body + }); + + _this2.hot.runHooks('beforeDropdownMenuSetItems', menuItems); + + _this2.menu.setMenuItems(menuItems); + + _this2.menu.addLocalHook('beforeOpen', function () { + return _this2.onMenuBeforeOpen(); + }); + + _this2.menu.addLocalHook('afterOpen', function () { + return _this2.onMenuAfterOpen(); + }); + + _this2.menu.addLocalHook('afterClose', function () { + return _this2.onMenuAfterClose(); + }); + + _this2.menu.addLocalHook('executeCommand', function () { + var _this2$executeCommand; + + for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) { + params[_key] = arguments[_key]; + } + + return (_this2$executeCommand = _this2.executeCommand).call.apply(_this2$executeCommand, [_this2].concat(params)); + }); // Register all commands. Predefined and added by user or by plugins + + + arrayEach(menuItems, function (command) { + return _this2.commandExecutor.registerCommand(command.key, command); + }); + }); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$E(_getPrototypeOf$10(DropdownMenu.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.close(); + + if (this.menu) { + this.menu.destroy(); + } + + _get$E(_getPrototypeOf$10(DropdownMenu.prototype), "disablePlugin", this).call(this); + } + /** + * Registers the DOM listeners. + * + * @private + */ + + }, { + key: "registerEvents", + value: function registerEvents() { + var _this3 = this; + + this.eventManager.addEventListener(this.hot.rootElement, 'click', function (event) { + return _this3.onTableClick(event); + }); + } + /** + * Opens menu and re-position it based on the passed coordinates. + * + * @param {object|Event} position An object with `pageX` and `pageY` properties which contains values relative to + * the top left of the fully rendered content area in the browser or with `clientX` + * and `clientY` properties which contains values relative to the upper left edge + * of the content area (the viewport) of the browser window. This object is structurally + * compatible with native mouse event so it can be used either. + * @fires Hooks#beforeDropdownMenuShow + * @fires Hooks#afterDropdownMenuShow + */ + + }, { + key: "open", + value: function open(position) { + if (!this.menu) { + return; + } + + this.menu.open(); + + if (position.width) { + this.menu.setOffset('left', position.width); + } + + this.menu.setPosition(position); + } + /** + * Closes dropdown menu. + */ + + }, { + key: "close", + value: function close() { + if (!this.menu) { + return; + } + + this.menu.close(); + } + /** + * Executes context menu command. + * + * You can execute all predefined commands: + * * `'row_above'` - Insert row above + * * `'row_below'` - Insert row below + * * `'col_left'` - Insert column left + * * `'col_right'` - Insert column right + * * `'clear_column'` - Clear selected column + * * `'remove_row'` - Remove row + * * `'remove_col'` - Remove column + * * `'undo'` - Undo last action + * * `'redo'` - Redo last action + * * `'make_read_only'` - Make cell read only + * * `'alignment:left'` - Alignment to the left + * * `'alignment:top'` - Alignment to the top + * * `'alignment:right'` - Alignment to the right + * * `'alignment:bottom'` - Alignment to the bottom + * * `'alignment:middle'` - Alignment to the middle + * * `'alignment:center'` - Alignment to the center (justify). + * + * Or you can execute command registered in settings where `key` is your command name. + * + * @param {string} commandName Command name to execute. + * @param {*} params Additional parameters passed to the command executor. + */ + + }, { + key: "executeCommand", + value: function executeCommand(commandName) { + var _this$commandExecutor; + + for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + params[_key2 - 1] = arguments[_key2]; + } + + (_this$commandExecutor = this.commandExecutor).execute.apply(_this$commandExecutor, [commandName].concat(params)); + } + /** + * Turns on / off listening on dropdown menu. + * + * @private + * @param {boolean} listen Turn on listening when value is set to true, otherwise turn it off. + */ + + }, { + key: "setListening", + value: function setListening() { + var listen = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + if (this.menu.isOpened()) { + if (listen) { + this.menu.hotMenu.listen(); + } else { + this.menu.hotMenu.unlisten(); + } + } + } + /** + * Table click listener. + * + * @private + * @param {Event} event The mouse event object. + */ + + }, { + key: "onTableClick", + value: function onTableClick(event) { + event.stopPropagation(); + + if (hasClass(event.target, BUTTON_CLASS_NAME) && !this.menu.isOpened()) { + var offsetTop = 0; + var offsetLeft = 0; + + if (this.hot.rootDocument !== this.menu.container.ownerDocument) { + var frameElement = this.hot.rootWindow.frameElement; + + var _frameElement$getBoun = frameElement.getBoundingClientRect(), + top = _frameElement$getBoun.top, + left = _frameElement$getBoun.left; + + offsetTop = top; + offsetLeft = left; + } + + var rect = event.target.getBoundingClientRect(); + this.open({ + left: rect.left + offsetLeft, + top: rect.top + event.target.offsetHeight + 3 + offsetTop, + width: rect.width, + height: rect.height + }); + } + } + /** + * On after get column header listener. + * + * @private + * @param {number} col Visual column index. + * @param {HTMLTableCellElement} TH Header's TH element. + */ + + }, { + key: "onAfterGetColHeader", + value: function onAfterGetColHeader(col, TH) { + // Corner or a higher-level header + var headerRow = TH.parentNode; + + if (!headerRow) { + return; + } + + var headerRowList = headerRow.parentNode.childNodes; + var level = Array.prototype.indexOf.call(headerRowList, headerRow); + + if (col < 0 || level !== headerRowList.length - 1) { + return; + } + + var existingButton = TH.querySelector(".".concat(BUTTON_CLASS_NAME)); // Plugin enabled and buttons already exists, return. + + if (this.enabled && existingButton) { + return; + } // Plugin disabled and buttons still exists, so remove them. + + + if (!this.enabled) { + if (existingButton) { + existingButton.parentNode.removeChild(existingButton); + } + + return; + } + + var button = this.hot.rootDocument.createElement('button'); + button.className = BUTTON_CLASS_NAME; // prevent page reload on button click + + button.onclick = function () { + return false; + }; + + TH.firstChild.insertBefore(button, TH.firstChild.firstChild); + } + /** + * On menu before open listener. + * + * @private + * @fires Hooks#beforeDropdownMenuShow + */ + + }, { + key: "onMenuBeforeOpen", + value: function onMenuBeforeOpen() { + this.hot.runHooks('beforeDropdownMenuShow', this); + } + /** + * On menu after open listener. + * + * @private + * @fires Hooks#afterDropdownMenuShow + */ + + }, { + key: "onMenuAfterOpen", + value: function onMenuAfterOpen() { + this.hot.runHooks('afterDropdownMenuShow', this); + } + /** + * On menu after close listener. + * + * @private + * @fires Hooks#afterDropdownMenuHide + */ + + }, { + key: "onMenuAfterClose", + value: function onMenuAfterClose() { + this.hot.listen(); + this.hot.runHooks('afterDropdownMenuHide', this); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.close(); + + if (this.menu) { + this.menu.destroy(); + } + + _get$E(_getPrototypeOf$10(DropdownMenu.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$p; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$n; + } + }, { + key: "PLUGIN_DEPS", + get: function get() { + return ['plugin:AutoColumnSize']; + } + /** + * Default menu items order when `dropdownMenu` is enabled by setting the config item to `true`. + * + * @returns {Array} + */ + + }, { + key: "DEFAULT_ITEMS", + get: function get() { + return [KEY$3, KEY$4, KEY, KEY$7, KEY, KEY$2, KEY, KEY$5, KEY, KEY$1]; + } + }]); + + return DropdownMenu; +}(BasePlugin); +DropdownMenu.SEPARATOR = { + name: KEY +}; + +function _slicedToArray$s(arr, i) { return _arrayWithHoles$u(arr) || _iterableToArrayLimit$s(arr, i) || _unsupportedIterableToArray$I(arr, i) || _nonIterableRest$u(); } + +function _nonIterableRest$u() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$I(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$I(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$I(o, minLen); } + +function _arrayLikeToArray$I(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$s(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$u(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$24(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1_(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); } } + +function _createClass$1_(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1_(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1_(Constructor, staticProps); return Constructor; } +// jshint ignore: start + +/** + * @plugin ExportFile + * @private + */ + +var DataProvider = /*#__PURE__*/function () { + function DataProvider(hotInstance) { + _classCallCheck$24(this, DataProvider); + + /** + * Handsontable instance. + * + * @type {Core} + */ + this.hot = hotInstance; + /** + * Format type class options. + * + * @type {object} + */ + + this.options = {}; + } + /** + * Set options for data provider. + * + * @param {object} options Object with specified options. + */ + + + _createClass$1_(DataProvider, [{ + key: "setOptions", + value: function setOptions(options) { + this.options = options; + } + /** + * Get table data based on provided settings to the class constructor. + * + * @returns {Array} + */ + + }, { + key: "getData", + value: function getData() { + var _this = this; + + var _this$_getDataRange = this._getDataRange(), + startRow = _this$_getDataRange.startRow, + startCol = _this$_getDataRange.startCol, + endRow = _this$_getDataRange.endRow, + endCol = _this$_getDataRange.endCol; + + var options = this.options; + var data = []; + rangeEach(startRow, endRow, function (rowIndex) { + var row = []; + + if (!options.exportHiddenRows && _this._isHiddenRow(rowIndex)) { + return; + } + + rangeEach(startCol, endCol, function (colIndex) { + if (!options.exportHiddenColumns && _this._isHiddenColumn(colIndex)) { + return; + } + + row.push(_this.hot.getDataAtCell(rowIndex, colIndex)); + }); + data.push(row); + }); + return data; + } + /** + * Gets list of row headers. + * + * @returns {Array} + */ + + }, { + key: "getRowHeaders", + value: function getRowHeaders() { + var _this2 = this; + + var headers = []; + + if (this.options.rowHeaders) { + var _this$_getDataRange2 = this._getDataRange(), + startRow = _this$_getDataRange2.startRow, + endRow = _this$_getDataRange2.endRow; + + var rowHeaders = this.hot.getRowHeader(); + rangeEach(startRow, endRow, function (row) { + if (!_this2.options.exportHiddenRows && _this2._isHiddenRow(row)) { + return; + } + + headers.push(rowHeaders[row]); + }); + } + + return headers; + } + /** + * Gets list of columns headers. + * + * @returns {Array} + */ + + }, { + key: "getColumnHeaders", + value: function getColumnHeaders() { + var _this3 = this; + + var headers = []; + + if (this.options.columnHeaders) { + var _this$_getDataRange3 = this._getDataRange(), + startCol = _this$_getDataRange3.startCol, + endCol = _this$_getDataRange3.endCol; + + var colHeaders = this.hot.getColHeader(); + rangeEach(startCol, endCol, function (column) { + if (!_this3.options.exportHiddenColumns && _this3._isHiddenColumn(column)) { + return; + } + + headers.push(colHeaders[column]); + }); + } + + return headers; + } + /** + * Get data range object based on settings provided in the class constructor. + * + * @private + * @returns {object} Returns object with keys `startRow`, `startCol`, `endRow` and `endCol`. + */ + + }, { + key: "_getDataRange", + value: function _getDataRange() { + var cols = this.hot.countCols() - 1; + var rows = this.hot.countRows() - 1; + + var _this$options$range = _slicedToArray$s(this.options.range, 4), + _this$options$range$ = _this$options$range[0], + startRow = _this$options$range$ === void 0 ? 0 : _this$options$range$, + _this$options$range$2 = _this$options$range[1], + startCol = _this$options$range$2 === void 0 ? 0 : _this$options$range$2, + _this$options$range$3 = _this$options$range[2], + endRow = _this$options$range$3 === void 0 ? rows : _this$options$range$3, + _this$options$range$4 = _this$options$range[3], + endCol = _this$options$range$4 === void 0 ? cols : _this$options$range$4; + + startRow = Math.max(startRow, 0); + startCol = Math.max(startCol, 0); + endRow = Math.min(endRow, rows); + endCol = Math.min(endCol, cols); + return { + startRow: startRow, + startCol: startCol, + endRow: endRow, + endCol: endCol + }; + } + /** + * Check if row at specified row index is hidden. + * + * @private + * @param {number} row Row index. + * @returns {boolean} + */ + + }, { + key: "_isHiddenRow", + value: function _isHiddenRow(row) { + return this.hot.rowIndexMapper.isHidden(this.hot.toPhysicalRow(row)); + } + /** + * Check if column at specified column index is hidden. + * + * @private + * @param {number} column Visual column index. + * @returns {boolean} + */ + + }, { + key: "_isHiddenColumn", + value: function _isHiddenColumn(column) { + return this.hot.columnIndexMapper.isHidden(this.hot.toPhysicalColumn(column)); + } + }]); + + return DataProvider; +}(); + +function _classCallCheck$25(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$1$(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); } } + +function _createClass$1$(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1$(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1$(Constructor, staticProps); return Constructor; } +/** + * @plugin ExportFile + * @private + */ + +var BaseType = /*#__PURE__*/function () { + function BaseType(dataProvider, options) { + _classCallCheck$25(this, BaseType); + + /** + * Data provider. + * + * @type {DataProvider} + */ + this.dataProvider = dataProvider; + /** + * Format type class options. + * + * @type {object} + */ + + this.options = this._mergeOptions(options); + this.dataProvider.setOptions(this.options); + } + /** + * Merge options provided by users with defaults. + * + * @param {object} options An object with options to merge with. + * @returns {object} Returns new options object. + */ + + + _createClass$1$(BaseType, [{ + key: "_mergeOptions", + value: function _mergeOptions(options) { + var _options = clone(this.constructor.DEFAULT_OPTIONS); + + var date = new Date(); + _options = extend(clone(BaseType.DEFAULT_OPTIONS), _options); + _options = extend(_options, options); + _options.filename = substitute(_options.filename, { + YYYY: date.getFullYear(), + MM: "".concat(date.getMonth() + 1).padStart(2, '0'), + DD: "".concat(date.getDate()).padStart(2, '0') + }); + return _options; + } + }], [{ + key: "DEFAULT_OPTIONS", + get: + /** + * Default options. + * + * @returns {object} + */ + function get() { + return { + mimeType: 'text/plain', + fileExtension: 'txt', + filename: 'Handsontable [YYYY]-[MM]-[DD]', + encoding: 'utf-8', + bom: false, + columnHeaders: false, + rowHeaders: false, + exportHiddenColumns: false, + exportHiddenRows: false, + range: [] + }; + } + }]); + + return BaseType; +}(); + +function _typeof$1d(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1d = function _typeof(obj) { return typeof obj; }; } else { _typeof$1d = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1d(obj); } + +function _classCallCheck$26(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$20(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); } } + +function _createClass$20(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$20(Constructor.prototype, protoProps); if (staticProps) _defineProperties$20(Constructor, staticProps); return Constructor; } + +function _inherits$11(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$12(subClass, superClass); } + +function _setPrototypeOf$12(o, p) { _setPrototypeOf$12 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$12(o, p); } + +function _createSuper$11(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$12(); return function _createSuperInternal() { var Super = _getPrototypeOf$11(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$11(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$11(this, result); }; } + +function _possibleConstructorReturn$11(self, call) { if (call && (_typeof$1d(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$11(self); } + +function _assertThisInitialized$11(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$12() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$11(o) { _getPrototypeOf$11 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$11(o); } +var CHAR_CARRIAGE_RETURN = String.fromCharCode(13); +var CHAR_DOUBLE_QUOTES = String.fromCharCode(34); +var CHAR_LINE_FEED = String.fromCharCode(10); +/** + * @plugin ExportFile + * @private + */ + +var Csv = /*#__PURE__*/function (_BaseType) { + _inherits$11(Csv, _BaseType); + + var _super = _createSuper$11(Csv); + + function Csv() { + _classCallCheck$26(this, Csv); + + return _super.apply(this, arguments); + } + + _createClass$20(Csv, [{ + key: "export", + value: + /** + * Create string body in desired format. + * + * @returns {string} + */ + function _export() { + var _this = this; + + var options = this.options; + var data = this.dataProvider.getData(); + var columnHeaders = this.dataProvider.getColumnHeaders(); + var hasColumnHeaders = columnHeaders.length > 0; + var rowHeaders = this.dataProvider.getRowHeaders(); + var hasRowHeaders = rowHeaders.length > 0; + var result = options.bom ? String.fromCharCode(0xFEFF) : ''; + + if (hasColumnHeaders) { + columnHeaders = arrayMap(columnHeaders, function (value) { + return _this._escapeCell(value, true); + }); + + if (hasRowHeaders) { + result += options.columnDelimiter; + } + + result += columnHeaders.join(options.columnDelimiter); + result += options.rowDelimiter; + } + + arrayEach(data, function (value, index) { + if (index > 0) { + result += options.rowDelimiter; + } + + if (hasRowHeaders) { + result += _this._escapeCell(rowHeaders[index]) + options.columnDelimiter; + } + + result += value.map(function (cellValue) { + return _this._escapeCell(cellValue); + }).join(options.columnDelimiter); + }); + return result; + } + /** + * Escape cell value. + * + * @param {*} value Cell value. + * @param {boolean} [force=false] Indicates if cell value will be escaped forcefully. + * @returns {string} + */ + + }, { + key: "_escapeCell", + value: function _escapeCell(value) { + var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + var escapedValue = stringify(value); + + if (escapedValue !== '' && (force || escapedValue.indexOf(CHAR_CARRIAGE_RETURN) >= 0 || escapedValue.indexOf(CHAR_DOUBLE_QUOTES) >= 0 || escapedValue.indexOf(CHAR_LINE_FEED) >= 0 || escapedValue.indexOf(this.options.columnDelimiter) >= 0)) { + escapedValue = escapedValue.replace(new RegExp('"', 'g'), '""'); + escapedValue = "\"".concat(escapedValue, "\""); + } + + return escapedValue; + } + }], [{ + key: "DEFAULT_OPTIONS", + get: + /** + * Default options for exporting CSV format. + * + * @returns {object} + */ + function get() { + return { + mimeType: 'text/csv', + fileExtension: 'csv', + bom: true, + columnDelimiter: ',', + rowDelimiter: '\r\n' + }; + } + }]); + + return Csv; +}(BaseType); + +function _defineProperty$i(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +var TYPE_CSV = 'csv'; + +var EXPORT_TYPES = _defineProperty$i({}, TYPE_CSV, Csv); +/** + * @param {string} type The exporter type. + * @param {DataProvider} dataProvider The data provider. + * @param {object} options Constructor options for exporter class. + * @returns {BaseType|null} + */ + +function typeFactory(type, dataProvider, options) { + if (typeof EXPORT_TYPES[type] === 'function') { + return new EXPORT_TYPES[type](dataProvider, options); + } + + return null; +} + +function _typeof$1e(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1e = function _typeof(obj) { return typeof obj; }; } else { _typeof$1e = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1e(obj); } + +function _classCallCheck$27(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$21(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); } } + +function _createClass$21(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$21(Constructor.prototype, protoProps); if (staticProps) _defineProperties$21(Constructor, staticProps); return Constructor; } + +function _inherits$12(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$13(subClass, superClass); } + +function _setPrototypeOf$13(o, p) { _setPrototypeOf$13 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$13(o, p); } + +function _createSuper$12(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$13(); return function _createSuperInternal() { var Super = _getPrototypeOf$12(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$12(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$12(this, result); }; } + +function _possibleConstructorReturn$12(self, call) { if (call && (_typeof$1e(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$12(self); } + +function _assertThisInitialized$12(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$13() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$12(o) { _getPrototypeOf$12 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$12(o); } +var PLUGIN_KEY$q = 'exportFile'; +var PLUGIN_PRIORITY$o = 240; +/** + * @plugin ExportFile + * + * @description + * The plugin enables exporting table data to file. It allows to export data as a string, blob or a downloadable file in + * CSV format. + * + * See [the export file demo](https://handsontable.com/docs/demo-export-file.html) for examples. + * + * @example + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData() + * }); + * + * // access to exportFile plugin instance + * const exportPlugin = hot.getPlugin('exportFile'); + * + * // export as a string + * exportPlugin.exportAsString('csv'); + * + * // export as a blob object + * exportPlugin.exportAsBlob('csv'); + * + * // export to downloadable file (named: MyFile.csv) + * exportPlugin.downloadFile('csv', {filename: 'MyFile'}); + * + * // export as a string (with specified data range): + * exportPlugin.exportAsString('csv', { + * exportHiddenRows: true, // default false + * exportHiddenColumns: true, // default false + * columnHeaders: true, // default false + * rowHeaders: true, // default false + * columnDelimiter: ';', // default ',' + * range: [1, 1, 6, 6] // [startRow, endRow, startColumn, endColumn] + * }); + * ``` + */ + +var ExportFile = /*#__PURE__*/function (_BasePlugin) { + _inherits$12(ExportFile, _BasePlugin); + + var _super = _createSuper$12(ExportFile); + + function ExportFile() { + _classCallCheck$27(this, ExportFile); + + return _super.apply(this, arguments); + } + + _createClass$21(ExportFile, [{ + key: "isEnabled", + value: + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link ExportFile#enablePlugin} method is called. + * + * @returns {boolean} + */ + function isEnabled() { + return true; + } + /** + * @typedef ExportOptions + * @memberof ExportFile + * @type {object} + * @property {boolean} [exportHiddenRows=false] Include hidden rows in the exported file. + * @property {boolean} [exportHiddenColumns=false] Include hidden columns in the exported file. + * @property {boolean} [columnHeaders=false] Include column headers in the exported file. + * @property {boolean} [rowHeaders=false] Include row headers in the exported file. + * @property {string} [columnDelimiter=','] Column delimiter. + * @property {string} [range=[]] Cell range that will be exported to file. + */ + + /** + * Exports table data as a string. + * + * @param {string} format Export format type eq. `'csv'`. + * @param {ExportOptions} options Export options. + * @returns {string} + */ + + }, { + key: "exportAsString", + value: function exportAsString(format) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + return this._createTypeFormatter(format, options).export(); + } + /** + * Exports table data as a blob object. + * + * @param {string} format Export format type eq. `'csv'`. + * @param {ExportOptions} options Export options. + * @returns {Blob} + */ + + }, { + key: "exportAsBlob", + value: function exportAsBlob(format) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + return this._createBlob(this._createTypeFormatter(format, options)); + } + /** + * Exports table data as a downloadable file. + * + * @param {string} format Export format type eq. `'csv'`. + * @param {ExportOptions} options Export options. + */ + + }, { + key: "downloadFile", + value: function downloadFile(format) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _this$hot = this.hot, + rootDocument = _this$hot.rootDocument, + rootWindow = _this$hot.rootWindow; + + var formatter = this._createTypeFormatter(format, options); + + var blob = this._createBlob(formatter); + + var URL = rootWindow.URL || rootWindow.webkitURL; + var a = rootDocument.createElement('a'); + var name = "".concat(formatter.options.filename, ".").concat(formatter.options.fileExtension); + + if (a.download !== void 0) { + var url = URL.createObjectURL(blob); + a.style.display = 'none'; + a.setAttribute('href', url); + a.setAttribute('download', name); + rootDocument.body.appendChild(a); + a.dispatchEvent(new MouseEvent('click')); + rootDocument.body.removeChild(a); + setTimeout(function () { + URL.revokeObjectURL(url); + }, 100); + } else if (navigator.msSaveOrOpenBlob) { + // IE10+ + navigator.msSaveOrOpenBlob(blob, name); + } + } + /** + * Creates and returns class formatter for specified export type. + * + * @private + * @param {string} format Export format type eq. `'csv'`. + * @param {ExportOptions} options Export options. + * @returns {BaseType} + */ + + }, { + key: "_createTypeFormatter", + value: function _createTypeFormatter(format) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + if (!EXPORT_TYPES[format]) { + throw new Error("Export format type \"".concat(format, "\" is not supported.")); + } + + return typeFactory(format, new DataProvider(this.hot), options); + } + /** + * Creates blob object based on provided type formatter class. + * + * @private + * @param {BaseType} typeFormatter The instance of the specyfic formatter/exporter. + * @returns {Blob} + */ + + }, { + key: "_createBlob", + value: function _createBlob(typeFormatter) { + var formatter = null; + + if (typeof Blob !== 'undefined') { + formatter = new Blob([typeFormatter.export()], { + type: "".concat(typeFormatter.options.mimeType, ";charset=").concat(typeFormatter.options.encoding) + }); + } + + return formatter; + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$q; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$o; + } + }]); + + return ExportFile; +}(BasePlugin); + +function _classCallCheck$28(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$22(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); } } + +function _createClass$22(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$22(Constructor.prototype, protoProps); if (staticProps) _defineProperties$22(Constructor, staticProps); return Constructor; } +/** + * @plugin Filters + * @class BaseComponent + */ + +var BaseComponent = /*#__PURE__*/function () { + function BaseComponent(hotInstance, _ref) { + var id = _ref.id, + _ref$stateless = _ref.stateless, + stateless = _ref$stateless === void 0 ? true : _ref$stateless; + + _classCallCheck$28(this, BaseComponent); + + /** + * The Handsontable instance. + * + * @type {Core} + */ + this.hot = hotInstance; + /** + * The component uniq id. + * + * @type {string} + */ + + this.id = id; + /** + * List of registered component UI elements. + * + * @type {Array} + */ + + this.elements = []; + /** + * Flag which determines if element is hidden. + * + * @type {boolean} + */ + + this.hidden = false; + /** + * The component states id. + * + * @type {string} + */ + + this.stateId = "Filters.component.".concat(this.id); + /** + * Index map which stores component states for each column. + * + * @type {LinkedPhysicalIndexToValueMap|null} + */ + + this.state = stateless ? null : this.hot.columnIndexMapper.registerMap(this.stateId, new LinkedPhysicalIndexToValueMap()); + } + /** + * Reset elements to its initial state. + */ + + + _createClass$22(BaseComponent, [{ + key: "reset", + value: function reset() { + arrayEach(this.elements, function (ui) { + return ui.reset(); + }); + } + /** + * Hide component. + */ + + }, { + key: "hide", + value: function hide() { + this.hidden = true; + } + /** + * Show component. + */ + + }, { + key: "show", + value: function show() { + this.hidden = false; + } + /** + * Check if component is hidden. + * + * @returns {boolean} + */ + + }, { + key: "isHidden", + value: function isHidden() { + return this.hot === null || this.hidden; + } + /** + * Restores the component state from the given physical column index. The method + * internally calls the `setState` method. The state then is individually processed + * by each component. + * + * @param {number} physicalColumn The physical column index. + */ + + }, { + key: "restoreState", + value: function restoreState(physicalColumn) { + if (this.state) { + this.setState(this.state.getValueAtIndex(physicalColumn)); + } + } + /** + * The custom logic for component state restoring. + */ + + }, { + key: "setState", + value: function setState() { + throw new Error('The state setting logic is not implemented'); + } + /** + * Saves the component state to the given physical column index. The method + * internally calls the `getState` method, which returns the current state of + * the component. + * + * @param {number} physicalColumn The physical column index. + */ + + }, { + key: "saveState", + value: function saveState(physicalColumn) { + if (this.state) { + this.state.setValueAtIndex(physicalColumn, this.getState()); + } + } + /** + * The custom logic for component state gathering (for stateful components). + */ + + }, { + key: "getState", + value: function getState() { + throw new Error('The state gathering logic is not implemented'); + } + /** + * Destroy element. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.columnIndexMapper.unregisterMap(this.stateId); + this.clearLocalHooks(); + arrayEach(this.elements, function (ui) { + return ui.destroy(); + }); + this.state = null; + this.elements = null; + this.hot = null; + } + }]); + + return BaseComponent; +}(); + +mixin(BaseComponent, localHooks); + +var conditions = {}; +/** + * Get condition closure with pre-bound arguments. + * + * @param {string} name Condition name. + * @param {Array} args Condition arguments. + * @returns {Function} + */ + +function getCondition(name, args) { + if (!conditions[name]) { + throw Error("Filter condition \"".concat(name, "\" does not exist.")); + } + + var _conditions$name = conditions[name], + condition = _conditions$name.condition, + descriptor = _conditions$name.descriptor; + var conditionArguments = args; + + if (descriptor.inputValuesDecorator) { + conditionArguments = descriptor.inputValuesDecorator(conditionArguments); + } + + return function (dataRow) { + return condition.apply(dataRow.meta.instance, [].concat([dataRow], [conditionArguments])); + }; +} +/** + * Get condition object descriptor which defines some additional informations about this condition. + * + * @param {string} name Condition name. + * @returns {object} + */ + +function getConditionDescriptor(name) { + if (!conditions[name]) { + throw Error("Filter condition \"".concat(name, "\" does not exist.")); + } + + return conditions[name].descriptor; +} +/** + * Condition registerer. + * + * @param {string} name Condition name. + * @param {Function} condition Condition function. + * @param {object} descriptor Condition descriptor. + */ + +function registerCondition(name, condition, descriptor) { + descriptor.key = name; + conditions[name] = { + condition: condition, + descriptor: descriptor + }; +} + +var CONDITION_NAME = 'none'; +/** + * @returns {boolean} + */ + +function condition() { + return true; +} +registerCondition(CONDITION_NAME, condition, { + name: FILTERS_CONDITIONS_NONE, + inputsCount: 0, + showOperators: false +}); + +var CONDITION_NAME$1 = 'empty'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @returns {boolean} + */ + +function condition$1(dataRow) { + return dataRow.value === '' || dataRow.value === null || dataRow.value === void 0; +} +registerCondition(CONDITION_NAME$1, condition$1, { + name: FILTERS_CONDITIONS_EMPTY, + inputsCount: 0, + showOperators: true +}); + +var CONDITION_NAME$2 = 'not_empty'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$2(dataRow, inputValues) { + return !getCondition(CONDITION_NAME$1, inputValues)(dataRow); +} +registerCondition(CONDITION_NAME$2, condition$2, { + name: FILTERS_CONDITIONS_NOT_EMPTY, + inputsCount: 0, + showOperators: true +}); + +function _slicedToArray$t(arr, i) { return _arrayWithHoles$v(arr) || _iterableToArrayLimit$t(arr, i) || _unsupportedIterableToArray$J(arr, i) || _nonIterableRest$v(); } + +function _nonIterableRest$v() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$J(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$J(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$J(o, minLen); } + +function _arrayLikeToArray$J(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$t(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$v(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$3 = 'eq'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$3(dataRow, _ref) { + var _ref2 = _slicedToArray$t(_ref, 1), + value = _ref2[0]; + + return stringify(dataRow.value).toLowerCase() === stringify(value); +} +registerCondition(CONDITION_NAME$3, condition$3, { + name: FILTERS_CONDITIONS_EQUAL, + inputsCount: 1, + showOperators: true +}); + +var CONDITION_NAME$4 = 'neq'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$4(dataRow, inputValues) { + return !getCondition(CONDITION_NAME$3, inputValues)(dataRow); +} +registerCondition(CONDITION_NAME$4, condition$4, { + name: FILTERS_CONDITIONS_NOT_EQUAL, + inputsCount: 1, + showOperators: true +}); + +function _slicedToArray$u(arr, i) { return _arrayWithHoles$w(arr) || _iterableToArrayLimit$u(arr, i) || _unsupportedIterableToArray$K(arr, i) || _nonIterableRest$w(); } + +function _nonIterableRest$w() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$K(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$K(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$K(o, minLen); } + +function _arrayLikeToArray$K(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$u(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$w(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$5 = 'gt'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$5(dataRow, _ref) { + var _ref2 = _slicedToArray$u(_ref, 1), + value = _ref2[0]; + + var conditionValue = value; + + if (dataRow.meta.type === 'numeric') { + conditionValue = parseFloat(conditionValue, 10); + } + + return dataRow.value > conditionValue; +} +registerCondition(CONDITION_NAME$5, condition$5, { + name: FILTERS_CONDITIONS_GREATER_THAN, + inputsCount: 1, + showOperators: true +}); + +function _slicedToArray$v(arr, i) { return _arrayWithHoles$x(arr) || _iterableToArrayLimit$v(arr, i) || _unsupportedIterableToArray$L(arr, i) || _nonIterableRest$x(); } + +function _nonIterableRest$x() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$L(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$L(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$L(o, minLen); } + +function _arrayLikeToArray$L(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$v(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$x(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$6 = 'gte'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$6(dataRow, _ref) { + var _ref2 = _slicedToArray$v(_ref, 1), + value = _ref2[0]; + + var conditionValue = value; + + if (dataRow.meta.type === 'numeric') { + conditionValue = parseFloat(conditionValue, 10); + } + + return dataRow.value >= conditionValue; +} +registerCondition(CONDITION_NAME$6, condition$6, { + name: FILTERS_CONDITIONS_GREATER_THAN_OR_EQUAL, + inputsCount: 1, + showOperators: true +}); + +function _slicedToArray$w(arr, i) { return _arrayWithHoles$y(arr) || _iterableToArrayLimit$w(arr, i) || _unsupportedIterableToArray$M(arr, i) || _nonIterableRest$y(); } + +function _nonIterableRest$y() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$M(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$M(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$M(o, minLen); } + +function _arrayLikeToArray$M(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$w(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$y(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$7 = 'lt'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$7(dataRow, _ref) { + var _ref2 = _slicedToArray$w(_ref, 1), + value = _ref2[0]; + + var conditionValue = value; + + if (dataRow.meta.type === 'numeric') { + conditionValue = parseFloat(conditionValue, 10); + } + + return dataRow.value < conditionValue; +} +registerCondition(CONDITION_NAME$7, condition$7, { + name: FILTERS_CONDITIONS_LESS_THAN, + inputsCount: 1, + showOperators: true +}); + +function _slicedToArray$x(arr, i) { return _arrayWithHoles$z(arr) || _iterableToArrayLimit$x(arr, i) || _unsupportedIterableToArray$N(arr, i) || _nonIterableRest$z(); } + +function _nonIterableRest$z() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$N(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$N(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$N(o, minLen); } + +function _arrayLikeToArray$N(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$x(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$z(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$8 = 'lte'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$8(dataRow, _ref) { + var _ref2 = _slicedToArray$x(_ref, 1), + value = _ref2[0]; + + var conditionValue = value; + + if (dataRow.meta.type === 'numeric') { + conditionValue = parseFloat(conditionValue, 10); + } + + return dataRow.value <= conditionValue; +} +registerCondition(CONDITION_NAME$8, condition$8, { + name: FILTERS_CONDITIONS_LESS_THAN_OR_EQUAL, + inputsCount: 1, + showOperators: true +}); + +function _slicedToArray$y(arr, i) { return _arrayWithHoles$A(arr) || _iterableToArrayLimit$y(arr, i) || _unsupportedIterableToArray$O(arr, i) || _nonIterableRest$A(); } + +function _nonIterableRest$A() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$O(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$O(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$O(o, minLen); } + +function _arrayLikeToArray$O(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$y(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$A(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$9 = 'date_after'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$9(dataRow, _ref) { + var _ref2 = _slicedToArray$y(_ref, 1), + value = _ref2[0]; + + var date = moment(dataRow.value, dataRow.meta.dateFormat); + var inputDate = moment(value, dataRow.meta.dateFormat); + + if (!date.isValid() || !inputDate.isValid()) { + return false; + } + + return date.diff(inputDate) >= 0; +} +registerCondition(CONDITION_NAME$9, condition$9, { + name: FILTERS_CONDITIONS_AFTER, + inputsCount: 1, + showOperators: true +}); + +function _slicedToArray$z(arr, i) { return _arrayWithHoles$B(arr) || _iterableToArrayLimit$z(arr, i) || _unsupportedIterableToArray$P(arr, i) || _nonIterableRest$B(); } + +function _nonIterableRest$B() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$P(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$P(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$P(o, minLen); } + +function _arrayLikeToArray$P(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$z(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$B(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$a = 'date_before'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$a(dataRow, _ref) { + var _ref2 = _slicedToArray$z(_ref, 1), + value = _ref2[0]; + + var date = moment(dataRow.value, dataRow.meta.dateFormat); + var inputDate = moment(value, dataRow.meta.dateFormat); + + if (!date.isValid() || !inputDate.isValid()) { + return false; + } + + return date.diff(inputDate) <= 0; +} +registerCondition(CONDITION_NAME$a, condition$a, { + name: FILTERS_CONDITIONS_BEFORE, + inputsCount: 1, + showOperators: true +}); + +function _slicedToArray$A(arr, i) { return _arrayWithHoles$C(arr) || _iterableToArrayLimit$A(arr, i) || _unsupportedIterableToArray$Q(arr, i) || _nonIterableRest$C(); } + +function _nonIterableRest$C() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$Q(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$Q(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$Q(o, minLen); } + +function _arrayLikeToArray$Q(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$A(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$C(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$b = 'between'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$b(dataRow, _ref) { + var _ref2 = _slicedToArray$A(_ref, 2), + from = _ref2[0], + to = _ref2[1]; + + var fromValue = from; + var toValue = to; + + if (dataRow.meta.type === 'numeric') { + var _from = parseFloat(fromValue, 10); + + var _to = parseFloat(toValue, 10); + + fromValue = Math.min(_from, _to); + toValue = Math.max(_from, _to); + } else if (dataRow.meta.type === 'date') { + var dateBefore = getCondition(CONDITION_NAME$a, [toValue]); + var dateAfter = getCondition(CONDITION_NAME$9, [fromValue]); + return dateBefore(dataRow) && dateAfter(dataRow); + } + + return dataRow.value >= fromValue && dataRow.value <= toValue; +} +registerCondition(CONDITION_NAME$b, condition$b, { + name: FILTERS_CONDITIONS_BETWEEN, + inputsCount: 2, + showOperators: true +}); + +var CONDITION_NAME$c = 'not_between'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$c(dataRow, inputValues) { + return !getCondition(CONDITION_NAME$b, inputValues)(dataRow); +} +registerCondition(CONDITION_NAME$c, condition$c, { + name: FILTERS_CONDITIONS_NOT_BETWEEN, + inputsCount: 2, + showOperators: true +}); + +function _slicedToArray$B(arr, i) { return _arrayWithHoles$D(arr) || _iterableToArrayLimit$B(arr, i) || _unsupportedIterableToArray$R(arr, i) || _nonIterableRest$D(); } + +function _nonIterableRest$D() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$R(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$R(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$R(o, minLen); } + +function _arrayLikeToArray$R(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$B(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$D(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$d = 'begins_with'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$d(dataRow, _ref) { + var _ref2 = _slicedToArray$B(_ref, 1), + value = _ref2[0]; + + return stringify(dataRow.value).toLowerCase().startsWith(stringify(value)); +} +registerCondition(CONDITION_NAME$d, condition$d, { + name: FILTERS_CONDITIONS_BEGINS_WITH, + inputsCount: 1, + showOperators: true +}); + +var getOwnPropertyDescriptor$5 = objectGetOwnPropertyDescriptor.f; + + + + + + +var nativeEndsWith = ''.endsWith; +var min$7 = Math.min; + +var CORRECT_IS_REGEXP_LOGIC$1 = correctIsRegexpLogic('endsWith'); +// https://github.com/zloirock/core-js/pull/702 +var MDN_POLYFILL_BUG$1 = !CORRECT_IS_REGEXP_LOGIC$1 && !!function () { + var descriptor = getOwnPropertyDescriptor$5(String.prototype, 'endsWith'); + return descriptor && !descriptor.writable; +}(); + +// `String.prototype.endsWith` method +// https://tc39.es/ecma262/#sec-string.prototype.endswith +_export({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG$1 && !CORRECT_IS_REGEXP_LOGIC$1 }, { + endsWith: function endsWith(searchString /* , endPosition = @length */) { + var that = String(requireObjectCoercible(this)); + notARegexp(searchString); + var endPosition = arguments.length > 1 ? arguments[1] : undefined; + var len = toLength(that.length); + var end = endPosition === undefined ? len : min$7(toLength(endPosition), len); + var search = String(searchString); + return nativeEndsWith + ? nativeEndsWith.call(that, search, end) + : that.slice(end - search.length, end) === search; + } +}); + +function _slicedToArray$C(arr, i) { return _arrayWithHoles$E(arr) || _iterableToArrayLimit$C(arr, i) || _unsupportedIterableToArray$S(arr, i) || _nonIterableRest$E(); } + +function _nonIterableRest$E() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$S(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$S(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$S(o, minLen); } + +function _arrayLikeToArray$S(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$C(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$E(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$e = 'ends_with'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$e(dataRow, _ref) { + var _ref2 = _slicedToArray$C(_ref, 1), + value = _ref2[0]; + + return stringify(dataRow.value).toLowerCase().endsWith(stringify(value)); +} +registerCondition(CONDITION_NAME$e, condition$e, { + name: FILTERS_CONDITIONS_ENDS_WITH, + inputsCount: 1, + showOperators: true +}); + +function _slicedToArray$D(arr, i) { return _arrayWithHoles$F(arr) || _iterableToArrayLimit$D(arr, i) || _unsupportedIterableToArray$T(arr, i) || _nonIterableRest$F(); } + +function _nonIterableRest$F() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$T(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$T(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$T(o, minLen); } + +function _arrayLikeToArray$T(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$D(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$F(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$f = 'contains'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$f(dataRow, _ref) { + var _ref2 = _slicedToArray$D(_ref, 1), + value = _ref2[0]; + + return stringify(dataRow.value).toLowerCase().indexOf(stringify(value)) >= 0; +} +registerCondition(CONDITION_NAME$f, condition$f, { + name: FILTERS_CONDITIONS_CONTAINS, + inputsCount: 1, + showOperators: true +}); + +var CONDITION_NAME$g = 'not_contains'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$g(dataRow, inputValues) { + return !getCondition(CONDITION_NAME$f, inputValues)(dataRow); +} +registerCondition(CONDITION_NAME$g, condition$g, { + name: FILTERS_CONDITIONS_NOT_CONTAIN, + inputsCount: 1, + showOperators: true +}); + +var CONDITION_NAME$h = 'date_tomorrow'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @returns {boolean} + */ + +function condition$h(dataRow) { + var date = moment(dataRow.value, dataRow.meta.dateFormat); + + if (!date.isValid()) { + return false; + } + + return date.isSame(moment().subtract(-1, 'days').startOf('day'), 'd'); +} +registerCondition(CONDITION_NAME$h, condition$h, { + name: FILTERS_CONDITIONS_TOMORROW, + inputsCount: 0 +}); + +var CONDITION_NAME$i = 'date_today'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @returns {boolean} + */ + +function condition$i(dataRow) { + var date = moment(dataRow.value, dataRow.meta.dateFormat); + + if (!date.isValid()) { + return false; + } + + return date.isSame(moment().startOf('day'), 'd'); +} +registerCondition(CONDITION_NAME$i, condition$i, { + name: FILTERS_CONDITIONS_TODAY, + inputsCount: 0 +}); + +var CONDITION_NAME$j = 'date_yesterday'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @returns {boolean} + */ + +function condition$j(dataRow) { + var date = moment(dataRow.value, dataRow.meta.dateFormat); + + if (!date.isValid()) { + return false; + } + + return date.isSame(moment().subtract(1, 'days').startOf('day'), 'd'); +} +registerCondition(CONDITION_NAME$j, condition$j, { + name: FILTERS_CONDITIONS_YESTERDAY, + inputsCount: 0 +}); + +getComparisonFunction(); +/** + * Convert raw value into visual value. + * + * @param {*} value The value to convert. + * @param {string} defaultEmptyValue Default value for empty cells. + * @returns {*} + */ + +function toVisualValue(value, defaultEmptyValue) { + var visualValue = value; + + if (visualValue === '') { + visualValue = "(".concat(defaultEmptyValue, ")"); + } + + return visualValue; +} +var SUPPORT_SET_CONSTRUCTOR = new Set([1]).has(1); +var SUPPORT_FAST_DEDUPE = SUPPORT_SET_CONSTRUCTOR && typeof Array.from === 'function'; +/** + * Create an array assertion to compare if an element exists in that array (in a more efficient way than .indexOf). + * + * @param {Array} initialData Values to compare. + * @returns {Function} + */ + +function createArrayAssertion(initialData) { + var dataset = initialData; + + if (SUPPORT_SET_CONSTRUCTOR) { + dataset = new Set(dataset); + } + + return function (value) { + var result; + + if (SUPPORT_SET_CONSTRUCTOR) { + result = dataset.has(value); + } else { + /* eslint-disable no-bitwise */ + result = !!~dataset.indexOf(value); + } + + return result; + }; +} +/** + * Convert empty-ish values like null and undefined to an empty string. + * + * @param {*} value Value to check. + * @returns {string} + */ + +function toEmptyString(value) { + return value === null || value === void 0 ? '' : value; +} +/** + * Unify column values (replace `null` and `undefined` values into empty string, unique values and sort them). + * + * @param {Array} values An array of values. + * @returns {Array} + */ + +function unifyColumnValues(values) { + var unifiedValues = values; + + if (SUPPORT_FAST_DEDUPE) { + unifiedValues = Array.from(new Set(unifiedValues)); + } else { + unifiedValues = arrayUnique(unifiedValues); + } + + unifiedValues = unifiedValues.sort(function (a, b) { + if (typeof a === 'number' && typeof b === 'number') { + return a - b; + } + + if (a === b) { + return 0; + } + + return a > b ? 1 : -1; + }); + return unifiedValues; +} +/** + * Intersect 'base' values with 'selected' values and return an array of object. + * + * @param {Array} base An array of base values. + * @param {Array} selected An array of selected values. + * @param {string} defaultEmptyValue Default value for empty cells. + * @param {Function} [callback] A callback function which is invoked for every item in an array. + * @returns {Array} + */ + +function intersectValues(base, selected, defaultEmptyValue, callback) { + var result = []; + var same = base === selected; + var selectedItemsAssertion; + + if (!same) { + selectedItemsAssertion = createArrayAssertion(selected); + } + + arrayEach(base, function (value) { + var checked = false; + + if (same || selectedItemsAssertion(value)) { + checked = true; + } + + var item = { + checked: checked, + value: value, + visualValue: toVisualValue(value, defaultEmptyValue) + }; + + if (callback) { + callback(item); + } + + result.push(item); + }); + return result; +} + +function _slicedToArray$E(arr, i) { return _arrayWithHoles$G(arr) || _iterableToArrayLimit$E(arr, i) || _unsupportedIterableToArray$U(arr, i) || _nonIterableRest$G(); } + +function _nonIterableRest$G() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$U(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$U(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$U(o, minLen); } + +function _arrayLikeToArray$U(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$E(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$G(arr) { if (Array.isArray(arr)) return arr; } +var CONDITION_NAME$k = 'by_value'; +/** + * @param {object} dataRow The object which holds and describes the single cell value. + * @param {Array} inputValues An array of values to compare with. + * @returns {boolean} + */ + +function condition$k(dataRow, _ref) { + var _ref2 = _slicedToArray$E(_ref, 1), + value = _ref2[0]; + + return value(dataRow.value); +} +registerCondition(CONDITION_NAME$k, condition$k, { + name: 'By value', + inputsCount: 0, + inputValuesDecorator: function inputValuesDecorator(_ref3) { + var _ref4 = _slicedToArray$E(_ref3, 1), + data = _ref4[0]; + + return [createArrayAssertion(data)]; + }, + showOperators: false +}); + +var operations = {}; +/** + * Get operation closure with pre-bound arguments. + * + * @param {string} id Operator `id`. + * @returns {Function} + */ + +function getOperationFunc(id) { + if (!operations[id]) { + throw Error("Operation with id \"".concat(id, "\" does not exist.")); + } + + var func = operations[id].func; + return function (conditions, value) { + return func(conditions, value); + }; +} +/** + * Return name of operation which is displayed inside UI component, basing on it's `id`. + * + * @param {string} id `Id` of operation. + * @returns {string} + */ + +function getOperationName(id) { + return operations[id].name; +} +/** + * Operator registerer. + * + * @param {string} id Operation `id`. + * @param {string} name Operation name which is displayed inside UI component. + * @param {Function} func Operation function. + */ + +function registerOperation(id, name, func) { + operations[id] = { + name: name, + func: func + }; +} + +var OPERATION_ID = 'conjunction'; +var SHORT_NAME_FOR_COMPONENT = FILTERS_LABELS_CONJUNCTION; // p AND q AND w AND x AND... === TRUE? + +/** + * @param {Array} conditions An array with values to check. + * @param {*} value The comparable value. + * @returns {boolean} + */ + +function operationResult(conditions, value) { + return conditions.every(function (condition) { + return condition.func(value); + }); +} +registerOperation(OPERATION_ID, SHORT_NAME_FOR_COMPONENT, operationResult); + +var OPERATION_ID$1 = 'disjunction'; +var SHORT_NAME_FOR_COMPONENT$1 = FILTERS_LABELS_DISJUNCTION; // (p OR q OR w OR x OR...) === TRUE? + +/** + * @param {Array} conditions An array with values to check. + * @param {*} value The comparable value. + * @returns {boolean} + */ + +function operationResult$1(conditions, value) { + return conditions.some(function (condition) { + return condition.func(value); + }); +} +registerOperation(OPERATION_ID$1, SHORT_NAME_FOR_COMPONENT$1, operationResult$1); + +var OPERATION_ID$2 = 'disjunctionWithExtraCondition'; +var SHORT_NAME_FOR_COMPONENT$2 = FILTERS_LABELS_DISJUNCTION; // ((p OR q OR w OR x OR...) AND z) === TRUE? + +/** + * @param {Array} conditions An array with values to check. + * @param {*} value The comparable value. + * @returns {boolean} + */ + +function operationResult$2(conditions, value) { + if (conditions.length < 3) { + throw Error('Operation doesn\'t work on less then three conditions.'); + } + + return conditions.slice(0, conditions.length - 1).some(function (condition) { + return condition.func(value); + }) && conditions[conditions.length - 1].func(value); +} +registerOperation(OPERATION_ID$2, SHORT_NAME_FOR_COMPONENT$2, operationResult$2); + +var _TYPES; + +function _defineProperty$j(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +var TYPE_NUMERIC = 'numeric'; +var TYPE_TEXT = 'text'; +var TYPE_DATE = 'date'; +/** + * Default types and order for filter conditions. + * + * @type {object} + */ + +var TYPES = (_TYPES = {}, _defineProperty$j(_TYPES, TYPE_NUMERIC, [CONDITION_NAME, KEY, CONDITION_NAME$1, CONDITION_NAME$2, KEY, CONDITION_NAME$3, CONDITION_NAME$4, KEY, CONDITION_NAME$5, CONDITION_NAME$6, CONDITION_NAME$7, CONDITION_NAME$8, CONDITION_NAME$b, CONDITION_NAME$c]), _defineProperty$j(_TYPES, TYPE_TEXT, [CONDITION_NAME, KEY, CONDITION_NAME$1, CONDITION_NAME$2, KEY, CONDITION_NAME$3, CONDITION_NAME$4, KEY, CONDITION_NAME$d, CONDITION_NAME$e, KEY, CONDITION_NAME$f, CONDITION_NAME$g]), _defineProperty$j(_TYPES, TYPE_DATE, [CONDITION_NAME, KEY, CONDITION_NAME$1, CONDITION_NAME$2, KEY, CONDITION_NAME$3, CONDITION_NAME$4, KEY, CONDITION_NAME$a, CONDITION_NAME$9, CONDITION_NAME$b, KEY, CONDITION_NAME$h, CONDITION_NAME$i, CONDITION_NAME$j]), _TYPES); +/** + * Get options list for conditional filter by data type (e.q: `'text'`, `'numeric'`, `'date'`). + * + * @param {string} type The data type. + * @returns {object} + */ + +function getOptionsList(type) { + var items = []; + var typeName = type; + + if (!TYPES[typeName]) { + typeName = TYPE_TEXT; + } + + arrayEach(TYPES[typeName], function (typeValue) { + var option; + + if (typeValue === KEY) { + option = { + name: KEY + }; + } else { + option = clone(getConditionDescriptor(typeValue)); + } + + items.push(option); + }); + return items; +} + +function _classCallCheck$29(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$23(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); } } + +function _createClass$23(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$23(Constructor.prototype, protoProps); if (staticProps) _defineProperties$23(Constructor, staticProps); return Constructor; } +var STATE_BUILT$2 = 'built'; +var STATE_BUILDING = 'building'; +var EVENTS_TO_REGISTER = ['click', 'input', 'keydown', 'keypress', 'keyup', 'focus', 'blur', 'change']; +/** + * @class + * @private + */ + +var BaseUI$2 = /*#__PURE__*/function () { + function BaseUI(hotInstance, options) { + _classCallCheck$29(this, BaseUI); + + /** + * Instance of Handsontable. + * + * @type {Core} + */ + this.hot = hotInstance; + /** + * Instance of EventManager. + * + * @type {EventManager} + */ + + this.eventManager = new EventManager(this); + /** + * List of element options. + * + * @type {object} + */ + + this.options = extend(BaseUI.DEFAULTS, options); + /** + * Build root DOM element. + * + * @type {Element} + * @private + */ + + this._element = this.hot.rootDocument.createElement(this.options.wrapIt ? 'div' : this.options.tagName); + /** + * Flag which determines build state of element. + * + * @type {boolean} + */ + + this.buildState = false; + } + /** + * Set the element value. + * + * @param {*} value Set the component value. + */ + + + _createClass$23(BaseUI, [{ + key: "setValue", + value: function setValue(value) { + this.options.value = value; + this.update(); + } + /** + * Get the element value. + * + * @returns {*} + */ + + }, { + key: "getValue", + value: function getValue() { + return this.options.value; + } + /** + * Get element as a DOM object. + * + * @returns {Element} + */ + + }, { + key: "element", + get: function get() { + if (this.buildState === STATE_BUILDING) { + return this._element; + } + + if (this.buildState === STATE_BUILT$2) { + this.update(); + return this._element; + } + + this.buildState = STATE_BUILDING; + this.build(); + this.buildState = STATE_BUILT$2; + return this._element; + } + /** + * Check if element was built (built whole DOM structure). + * + * @returns {boolean} + */ + + }, { + key: "isBuilt", + value: function isBuilt() { + return this.buildState === STATE_BUILT$2; + } + /** + * Translate value if it is possible. It's checked if value belongs to namespace of translated phrases. + * + * @param {*} value Value which will may be translated. + * @returns {*} Translated value if translation was possible, original value otherwise. + */ + + }, { + key: "translateIfPossible", + value: function translateIfPossible(value) { + if (typeof value === 'string' && value.startsWith(FILTERS_NAMESPACE)) { + return this.hot.getTranslatedPhrase(value); + } + + return value; + } + /** + * Build DOM structure. + */ + + }, { + key: "build", + value: function build() { + var _this = this; + + var registerEvent = function registerEvent(element, eventName) { + _this.eventManager.addEventListener(element, eventName, function (event) { + return _this.runLocalHooks(eventName, event, _this); + }); + }; + + if (!this.buildState) { + this.buildState = STATE_BUILDING; + } + + if (this.options.className) { + addClass(this._element, this.options.className); + } + + if (this.options.children.length) { + arrayEach(this.options.children, function (element) { + return _this._element.appendChild(element.element); + }); + } else if (this.options.wrapIt) { + var element = this.hot.rootDocument.createElement(this.options.tagName); + objectEach(this.options, function (value, key) { + if (element[key] !== void 0 && key !== 'className' && key !== 'tagName' && key !== 'children') { + element[key] = _this.translateIfPossible(value); + } + }); + + this._element.appendChild(element); + + arrayEach(EVENTS_TO_REGISTER, function (eventName) { + return registerEvent(element, eventName); + }); + } else { + arrayEach(EVENTS_TO_REGISTER, function (eventName) { + return registerEvent(_this._element, eventName); + }); + } + } + /** + * Update DOM structure. + */ + + }, { + key: "update", + value: function update() {} + /** + * Reset to initial state. + */ + + }, { + key: "reset", + value: function reset() { + this.options.value = ''; + this.update(); + } + /** + * Show element. + */ + + }, { + key: "show", + value: function show() { + this.element.style.display = ''; + } + /** + * Hide element. + */ + + }, { + key: "hide", + value: function hide() { + this.element.style.display = 'none'; + } + /** + * Focus element. + */ + + }, { + key: "focus", + value: function focus() {} + }, { + key: "destroy", + value: function destroy() { + this.eventManager.destroy(); + this.eventManager = null; + this.hot = null; + + if (this._element.parentNode) { + this._element.parentNode.removeChild(this._element); + } + + this._element = null; + } + }], [{ + key: "DEFAULTS", + get: function get() { + return clone({ + className: '', + value: '', + tagName: 'div', + children: [], + wrapIt: true + }); + } + }]); + + return BaseUI; +}(); + +mixin(BaseUI$2, localHooks); + +function _typeof$1f(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1f = function _typeof(obj) { return typeof obj; }; } else { _typeof$1f = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1f(obj); } + +function _classCallCheck$2a(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$24(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); } } + +function _createClass$24(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$24(Constructor.prototype, protoProps); if (staticProps) _defineProperties$24(Constructor, staticProps); return Constructor; } + +function _get$F(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$F = Reflect.get; } else { _get$F = function _get(target, property, receiver) { var base = _superPropBase$F(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$F(target, property, receiver || target); } + +function _superPropBase$F(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$13(object); if (object === null) break; } return object; } + +function _inherits$13(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$14(subClass, superClass); } + +function _setPrototypeOf$14(o, p) { _setPrototypeOf$14 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$14(o, p); } + +function _createSuper$13(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$14(); return function _createSuperInternal() { var Super = _getPrototypeOf$13(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$13(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$13(this, result); }; } + +function _possibleConstructorReturn$13(self, call) { if (call && (_typeof$1f(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$13(self); } + +function _assertThisInitialized$13(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$14() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$13(o) { _getPrototypeOf$13 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$13(o); } +var privatePool$f = new WeakMap(); +/** + * @class InputUI + * @util + */ + +var InputUI = /*#__PURE__*/function (_BaseUI) { + _inherits$13(InputUI, _BaseUI); + + var _super = _createSuper$13(InputUI); + + function InputUI(hotInstance, options) { + var _this; + + _classCallCheck$2a(this, InputUI); + + _this = _super.call(this, hotInstance, extend(InputUI.DEFAULTS, options)); + privatePool$f.set(_assertThisInitialized$13(_this), {}); + + _this.registerHooks(); + + return _this; + } + /** + * Register all necessary hooks. + */ + + + _createClass$24(InputUI, [{ + key: "registerHooks", + value: function registerHooks() { + var _this2 = this; + + this.addLocalHook('click', function () { + return _this2.onClick(); + }); + this.addLocalHook('keyup', function (event) { + return _this2.onKeyup(event); + }); + } + /** + * Build DOM structure. + */ + + }, { + key: "build", + value: function build() { + _get$F(_getPrototypeOf$13(InputUI.prototype), "build", this).call(this); + + var priv = privatePool$f.get(this); + var icon = this.hot.rootDocument.createElement('div'); + priv.input = this._element.firstChild; + addClass(this._element, 'htUIInput'); + addClass(icon, 'htUIInputIcon'); + + this._element.appendChild(icon); + + this.update(); + } + /** + * Update element. + */ + + }, { + key: "update", + value: function update() { + if (!this.isBuilt()) { + return; + } + + var input = privatePool$f.get(this).input; + input.type = this.options.type; + input.placeholder = this.translateIfPossible(this.options.placeholder); + input.value = this.translateIfPossible(this.options.value); + } + /** + * Focus element. + */ + + }, { + key: "focus", + value: function focus() { + if (this.isBuilt()) { + privatePool$f.get(this).input.focus(); + } + } + /** + * OnClick listener. + */ + + }, { + key: "onClick", + value: function onClick() {} + /** + * OnKeyup listener. + * + * @param {Event} event The mouse event object. + */ + + }, { + key: "onKeyup", + value: function onKeyup(event) { + this.options.value = event.target.value; + } + }], [{ + key: "DEFAULTS", + get: function get() { + return clone({ + placeholder: '', + type: 'text', + tagName: 'input' + }); + } + }]); + + return InputUI; +}(BaseUI$2); + +function _typeof$1g(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1g = function _typeof(obj) { return typeof obj; }; } else { _typeof$1g = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1g(obj); } + +function _classCallCheck$2b(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$25(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); } } + +function _createClass$25(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$25(Constructor.prototype, protoProps); if (staticProps) _defineProperties$25(Constructor, staticProps); return Constructor; } + +function _get$G(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$G = Reflect.get; } else { _get$G = function _get(target, property, receiver) { var base = _superPropBase$G(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$G(target, property, receiver || target); } + +function _superPropBase$G(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$14(object); if (object === null) break; } return object; } + +function _inherits$14(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$15(subClass, superClass); } + +function _setPrototypeOf$15(o, p) { _setPrototypeOf$15 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$15(o, p); } + +function _createSuper$14(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$15(); return function _createSuperInternal() { var Super = _getPrototypeOf$14(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$14(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$14(this, result); }; } + +function _possibleConstructorReturn$14(self, call) { if (call && (_typeof$1g(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$14(self); } + +function _assertThisInitialized$14(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$15() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$14(o) { _getPrototypeOf$14 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$14(o); } +var privatePool$g = new WeakMap(); +/** + * @class SelectUI + * @util + */ + +var SelectUI = /*#__PURE__*/function (_BaseUI) { + _inherits$14(SelectUI, _BaseUI); + + var _super = _createSuper$14(SelectUI); + + function SelectUI(hotInstance, options) { + var _this; + + _classCallCheck$2b(this, SelectUI); + + _this = _super.call(this, hotInstance, extend(SelectUI.DEFAULTS, options)); + privatePool$g.set(_assertThisInitialized$14(_this), {}); + /** + * Instance of {@link Menu}. + * + * @type {Menu} + */ + + _this.menu = null; + /** + * List of available select options. + * + * @type {Array} + */ + + _this.items = []; + + _this.registerHooks(); + + return _this; + } + /** + * Register all necessary hooks. + */ + + + _createClass$25(SelectUI, [{ + key: "registerHooks", + value: function registerHooks() { + var _this2 = this; + + this.addLocalHook('click', function () { + return _this2.onClick(); + }); + } + /** + * Set options which can be selected in the list. + * + * @param {Array} items Array of objects with required keys `key` and `name`. + */ + + }, { + key: "setItems", + value: function setItems(items) { + this.items = this.translateNames(items); + + if (this.menu) { + this.menu.setMenuItems(this.items); + } + } + /** + * Translate names of menu items. + * + * @param {Array} items Array of objects with required keys `key` and `name`. + * @returns {Array} Items with translated `name` keys. + */ + + }, { + key: "translateNames", + value: function translateNames(items) { + var _this3 = this; + + arrayEach(items, function (item) { + item.name = _this3.translateIfPossible(item.name); + }); + return items; + } + /** + * Build DOM structure. + */ + + }, { + key: "build", + value: function build() { + var _this4 = this; + + _get$G(_getPrototypeOf$14(SelectUI.prototype), "build", this).call(this); + + this.menu = new Menu(this.hot, { + className: 'htSelectUI htFiltersConditionsMenu', + keepInViewport: false, + standalone: true, + container: this.options.menuContainer + }); + this.menu.setMenuItems(this.items); + var caption = new BaseUI$2(this.hot, { + className: 'htUISelectCaption' + }); + var dropdown = new BaseUI$2(this.hot, { + className: 'htUISelectDropdown' + }); + var priv = privatePool$g.get(this); + priv.caption = caption; + priv.captionElement = caption.element; + priv.dropdown = dropdown; + arrayEach([caption, dropdown], function (element) { + return _this4._element.appendChild(element.element); + }); + this.menu.addLocalHook('select', function (command) { + return _this4.onMenuSelect(command); + }); + this.menu.addLocalHook('afterClose', function () { + return _this4.onMenuClosed(); + }); + this.update(); + } + /** + * Update DOM structure. + */ + + }, { + key: "update", + value: function update() { + if (!this.isBuilt()) { + return; + } + + var conditionName; + + if (this.options.value) { + conditionName = this.options.value.name; + } else { + conditionName = this.menu.hot.getTranslatedPhrase(FILTERS_CONDITIONS_NONE); + } + + privatePool$g.get(this).captionElement.textContent = conditionName; + + _get$G(_getPrototypeOf$14(SelectUI.prototype), "update", this).call(this); + } + /** + * Open select dropdown menu with available options. + */ + + }, { + key: "openOptions", + value: function openOptions() { + var rect = this.element.getBoundingClientRect(); + + if (this.menu) { + this.menu.open(); + this.menu.setPosition({ + left: rect.left - 5, + top: rect.top, + width: rect.width, + height: rect.height + }); + } + } + /** + * Close select dropdown menu. + */ + + }, { + key: "closeOptions", + value: function closeOptions() { + if (this.menu) { + this.menu.close(); + } + } + /** + * On menu selected listener. + * + * @private + * @param {object} command Selected item. + */ + + }, { + key: "onMenuSelect", + value: function onMenuSelect(command) { + if (command.name !== KEY) { + this.options.value = command; + this.update(); + this.runLocalHooks('select', this.options.value); + } + } + /** + * On menu closed listener. + * + * @private + */ + + }, { + key: "onMenuClosed", + value: function onMenuClosed() { + this.runLocalHooks('afterClose'); + } + /** + * On element click listener. + * + * @private + */ + + }, { + key: "onClick", + value: function onClick() { + this.openOptions(); + } + /** + * Destroy instance. + */ + + }, { + key: "destroy", + value: function destroy() { + if (this.menu) { + this.menu.destroy(); + this.menu = null; + } + + var _privatePool$get = privatePool$g.get(this), + caption = _privatePool$get.caption, + dropdown = _privatePool$get.dropdown; + + if (caption) { + caption.destroy(); + } + + if (dropdown) { + dropdown.destroy(); + } + + _get$G(_getPrototypeOf$14(SelectUI.prototype), "destroy", this).call(this); + } + }], [{ + key: "DEFAULTS", + get: function get() { + return clone({ + className: 'htUISelect', + wrapIt: false + }); + } + }]); + + return SelectUI; +}(BaseUI$2); + +function _typeof$1h(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1h = function _typeof(obj) { return typeof obj; }; } else { _typeof$1h = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1h(obj); } + +function _toConsumableArray$p(arr) { return _arrayWithoutHoles$n(arr) || _iterableToArray$p(arr) || _unsupportedIterableToArray$V(arr) || _nonIterableSpread$n(); } + +function _nonIterableSpread$n() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$V(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$V(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$V(o, minLen); } + +function _iterableToArray$p(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$n(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$V(arr); } + +function _arrayLikeToArray$V(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$2c(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$26(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); } } + +function _createClass$26(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$26(Constructor.prototype, protoProps); if (staticProps) _defineProperties$26(Constructor, staticProps); return Constructor; } + +function _get$H(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$H = Reflect.get; } else { _get$H = function _get(target, property, receiver) { var base = _superPropBase$H(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$H(target, property, receiver || target); } + +function _superPropBase$H(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$15(object); if (object === null) break; } return object; } + +function _inherits$15(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$16(subClass, superClass); } + +function _setPrototypeOf$16(o, p) { _setPrototypeOf$16 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$16(o, p); } + +function _createSuper$15(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$16(); return function _createSuperInternal() { var Super = _getPrototypeOf$15(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$15(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$15(this, result); }; } + +function _possibleConstructorReturn$15(self, call) { if (call && (_typeof$1h(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$15(self); } + +function _assertThisInitialized$15(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$16() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$15(o) { _getPrototypeOf$15 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$15(o); } +/** + * @class ConditionComponent + * @plugin Filters + */ + +var ConditionComponent = /*#__PURE__*/function (_BaseComponent) { + _inherits$15(ConditionComponent, _BaseComponent); + + var _super = _createSuper$15(ConditionComponent); + + function ConditionComponent(hotInstance, options) { + var _this; + + _classCallCheck$2c(this, ConditionComponent); + + _this = _super.call(this, hotInstance, { + id: options.id, + stateless: false + }); + _this.name = options.name; + _this.addSeparator = options.addSeparator; + + _this.elements.push(new SelectUI(_this.hot, { + menuContainer: options.menuContainer + })); + + _this.elements.push(new InputUI(_this.hot, { + placeholder: FILTERS_BUTTONS_PLACEHOLDER_VALUE + })); + + _this.elements.push(new InputUI(_this.hot, { + placeholder: FILTERS_BUTTONS_PLACEHOLDER_SECOND_VALUE + })); + + _this.registerHooks(); + + return _this; + } + /** + * Register all necessary hooks. + * + * @private + */ + + + _createClass$26(ConditionComponent, [{ + key: "registerHooks", + value: function registerHooks() { + var _this2 = this; + + this.getSelectElement().addLocalHook('select', function (command) { + return _this2.onConditionSelect(command); + }); + this.getSelectElement().addLocalHook('afterClose', function () { + return _this2.onSelectUIClosed(); + }); + arrayEach(this.getInputElements(), function (input) { + input.addLocalHook('keydown', function (event) { + return _this2.onInputKeyDown(event); + }); + }); + } + /** + * Set state of the component. + * + * @param {object} value State to restore. + */ + + }, { + key: "setState", + value: function setState(value) { + var _this3 = this; + + this.reset(); + + if (!value) { + return; + } + + var copyOfCommand = clone(value.command); + + if (copyOfCommand.name.startsWith(FILTERS_CONDITIONS_NAMESPACE)) { + copyOfCommand.name = this.hot.getTranslatedPhrase(copyOfCommand.name); + } + + this.getSelectElement().setValue(copyOfCommand); + arrayEach(value.args, function (arg, index) { + if (index > copyOfCommand.inputsCount - 1) { + return false; + } + + var element = _this3.getInputElement(index); + + element.setValue(arg); + element[copyOfCommand.inputsCount > index ? 'show' : 'hide'](); + + if (!index) { + setTimeout(function () { + return element.focus(); + }, 10); + } + }); + } + /** + * Export state of the component (get selected filter and filter arguments). + * + * @returns {object} Returns object where `command` key keeps used condition filter and `args` key its arguments. + */ + + }, { + key: "getState", + value: function getState() { + var command = this.getSelectElement().getValue() || getConditionDescriptor(CONDITION_NAME); + var args = []; + arrayEach(this.getInputElements(), function (element, index) { + if (command.inputsCount > index) { + args.push(element.getValue()); + } + }); + return { + command: command, + args: args + }; + } + /** + * Update state of component. + * + * @param {object} condition The condition object. + * @param {object} condition.command The command object with condition name as `key` property. + * @param {Array} condition.args An array of values to compare. + * @param {number} column Physical column index. + */ + + }, { + key: "updateState", + value: function updateState(condition, column) { + var command = condition ? getConditionDescriptor(condition.name) : getConditionDescriptor(CONDITION_NAME); + this.state.setValueAtIndex(column, { + command: command, + args: condition ? condition.args : [] + }); + + if (!condition) { + arrayEach(this.getInputElements(), function (element) { + return element.setValue(null); + }); + } + } + /** + * Get select element. + * + * @returns {SelectUI} + */ + + }, { + key: "getSelectElement", + value: function getSelectElement() { + return this.elements.filter(function (element) { + return element instanceof SelectUI; + })[0]; + } + /** + * Get input element. + * + * @param {number} index Index an array of elements. + * @returns {InputUI} + */ + + }, { + key: "getInputElement", + value: function getInputElement() { + var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; + return this.getInputElements()[index]; + } + /** + * Get input elements. + * + * @returns {Array} + */ + + }, { + key: "getInputElements", + value: function getInputElements() { + return this.elements.filter(function (element) { + return element instanceof InputUI; + }); + } + /** + * Get menu object descriptor. + * + * @returns {object} + */ + + }, { + key: "getMenuItemDescriptor", + value: function getMenuItemDescriptor() { + var _this4 = this; + + return { + key: this.id, + name: this.name, + isCommand: false, + disableSelection: true, + hidden: function hidden() { + return _this4.isHidden(); + }, + renderer: function renderer(hot, wrapper, row, col, prop, value) { + addClass(wrapper.parentNode, 'htFiltersMenuCondition'); + + if (_this4.addSeparator) { + addClass(wrapper.parentNode, 'border'); + } + + var label = _this4.hot.rootDocument.createElement('div'); + + addClass(label, 'htFiltersMenuLabel'); + label.textContent = value; + wrapper.appendChild(label); + + if (!wrapper.parentNode.hasAttribute('ghost-table')) { + arrayEach(_this4.elements, function (ui) { + return wrapper.appendChild(ui.element); + }); + } + + return wrapper; + } + }; + } + /** + * Reset elements to their initial state. + */ + + }, { + key: "reset", + value: function reset() { + var _this$hot; + + var lastSelectedColumn = this.hot.getPlugin('filters').getSelectedColumn(); + var visualIndex = lastSelectedColumn && lastSelectedColumn.visualIndex; + + var columnType = (_this$hot = this.hot).getDataType.apply(_this$hot, _toConsumableArray$p(this.hot.getSelectedLast() || [0, visualIndex])); + + var items = getOptionsList(columnType); + arrayEach(this.getInputElements(), function (element) { + return element.hide(); + }); + this.getSelectElement().setItems(items); + + _get$H(_getPrototypeOf$15(ConditionComponent.prototype), "reset", this).call(this); // Select element as default 'None' + + + this.getSelectElement().setValue(items[0]); + } + /** + * On condition select listener. + * + * @private + * @param {object} command Menu item object (command). + */ + + }, { + key: "onConditionSelect", + value: function onConditionSelect(command) { + arrayEach(this.getInputElements(), function (element, index) { + element[command.inputsCount > index ? 'show' : 'hide'](); + + if (index === 0) { + setTimeout(function () { + return element.focus(); + }, 10); + } + }); + this.runLocalHooks('change', command); + } + /** + * On component SelectUI closed listener. + * + * @private + */ + + }, { + key: "onSelectUIClosed", + value: function onSelectUIClosed() { + this.runLocalHooks('afterClose'); + } + /** + * Key down listener. + * + * @private + * @param {Event} event The DOM event object. + */ + + }, { + key: "onInputKeyDown", + value: function onInputKeyDown(event) { + if (isKey(event.keyCode, 'ENTER')) { + this.runLocalHooks('accept'); + stopImmediatePropagation(event); + } else if (isKey(event.keyCode, 'ESCAPE')) { + this.runLocalHooks('cancel'); + stopImmediatePropagation(event); + } + } + }]); + + return ConditionComponent; +}(BaseComponent); + +function _typeof$1i(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1i = function _typeof(obj) { return typeof obj; }; } else { _typeof$1i = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1i(obj); } + +function _classCallCheck$2d(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$27(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); } } + +function _createClass$27(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$27(Constructor.prototype, protoProps); if (staticProps) _defineProperties$27(Constructor, staticProps); return Constructor; } + +function _get$I(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$I = Reflect.get; } else { _get$I = function _get(target, property, receiver) { var base = _superPropBase$I(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$I(target, property, receiver || target); } + +function _superPropBase$I(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$16(object); if (object === null) break; } return object; } + +function _inherits$16(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$17(subClass, superClass); } + +function _setPrototypeOf$17(o, p) { _setPrototypeOf$17 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$17(o, p); } + +function _createSuper$16(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$17(); return function _createSuperInternal() { var Super = _getPrototypeOf$16(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$16(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$16(this, result); }; } + +function _possibleConstructorReturn$16(self, call) { if (call && (_typeof$1i(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$16(self); } + +function _assertThisInitialized$16(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$17() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$16(o) { _getPrototypeOf$16 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$16(o); } +var privatePool$h = new WeakMap(); +/** + * @class RadioInputUI + * @util + */ + +var RadioInputUI = /*#__PURE__*/function (_BaseUI) { + _inherits$16(RadioInputUI, _BaseUI); + + var _super = _createSuper$16(RadioInputUI); + + function RadioInputUI(hotInstance, options) { + var _this; + + _classCallCheck$2d(this, RadioInputUI); + + _this = _super.call(this, hotInstance, extend(RadioInputUI.DEFAULTS, options)); + privatePool$h.set(_assertThisInitialized$16(_this), {}); + return _this; + } + /** + * Build DOM structure. + */ + + + _createClass$27(RadioInputUI, [{ + key: "build", + value: function build() { + _get$I(_getPrototypeOf$16(RadioInputUI.prototype), "build", this).call(this); + + var priv = privatePool$h.get(this); + priv.input = this._element.firstChild; + var label = this.hot.rootDocument.createElement('label'); + label.textContent = this.translateIfPossible(this.options.label.textContent); + label.htmlFor = this.translateIfPossible(this.options.label.htmlFor); + priv.label = label; + + this._element.appendChild(label); + + this.update(); + } + /** + * Update element. + */ + + }, { + key: "update", + value: function update() { + if (!this.isBuilt()) { + return; + } + + var priv = privatePool$h.get(this); + priv.input.checked = this.options.checked; + priv.label.textContent = this.translateIfPossible(this.options.label.textContent); + } + /** + * Check if radio button is checked. + * + * @returns {boolean} + */ + + }, { + key: "isChecked", + value: function isChecked() { + return this.options.checked; + } + /** + * Set input checked attribute. + * + * @param {boolean} value Set the component state. + */ + + }, { + key: "setChecked", + value: function setChecked() { + var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + this.options.checked = value; + this.update(); + } + /** + * Focus element. + */ + + }, { + key: "focus", + value: function focus() { + if (this.isBuilt()) { + privatePool$h.get(this).input.focus(); + } + } + }], [{ + key: "DEFAULTS", + get: function get() { + return clone({ + type: 'radio', + tagName: 'input', + className: 'htUIRadio', + label: {} + }); + } + }]); + + return RadioInputUI; +}(BaseUI$2); + +function _typeof$1j(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1j = function _typeof(obj) { return typeof obj; }; } else { _typeof$1j = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1j(obj); } + +var _templateObject$9; + +function _taggedTemplateLiteral$9(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _classCallCheck$2e(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$28(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); } } + +function _createClass$28(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$28(Constructor.prototype, protoProps); if (staticProps) _defineProperties$28(Constructor, staticProps); return Constructor; } + +function _inherits$17(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$18(subClass, superClass); } + +function _setPrototypeOf$18(o, p) { _setPrototypeOf$18 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$18(o, p); } + +function _createSuper$17(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$18(); return function _createSuperInternal() { var Super = _getPrototypeOf$17(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$17(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$17(this, result); }; } + +function _possibleConstructorReturn$17(self, call) { if (call && (_typeof$1j(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$17(self); } + +function _assertThisInitialized$17(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$18() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$17(o) { _getPrototypeOf$17 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$17(o); } +var SELECTED_AT_START_ELEMENT_INDEX = 0; +/** + * @class OperatorsComponent + * @plugin Filters + */ + +var OperatorsComponent = /*#__PURE__*/function (_BaseComponent) { + _inherits$17(OperatorsComponent, _BaseComponent); + + var _super = _createSuper$17(OperatorsComponent); + + function OperatorsComponent(hotInstance, options) { + var _this; + + _classCallCheck$2e(this, OperatorsComponent); + + _this = _super.call(this, hotInstance, { + id: options.id, + stateless: false + }); + _this.name = options.name; + + _this.buildOperatorsElement(); + + return _this; + } + /** + * Get menu object descriptor. + * + * @returns {object} + */ + + + _createClass$28(OperatorsComponent, [{ + key: "getMenuItemDescriptor", + value: function getMenuItemDescriptor() { + var _this2 = this; + + return { + key: this.id, + name: this.name, + isCommand: false, + disableSelection: true, + hidden: function hidden() { + return _this2.isHidden(); + }, + renderer: function renderer(hot, wrapper) { + addClass(wrapper.parentNode, 'htFiltersMenuOperators'); + + if (!wrapper.parentNode.hasAttribute('ghost-table')) { + arrayEach(_this2.elements, function (ui) { + return wrapper.appendChild(ui.element); + }); + } + + return wrapper; + } + }; + } + /** + * Add RadioInputUI elements to component. + * + * @private + */ + + }, { + key: "buildOperatorsElement", + value: function buildOperatorsElement() { + var _this3 = this; + + var operationKeys = [OPERATION_ID, OPERATION_ID$1]; + arrayEach(operationKeys, function (operation) { + var radioInput = new RadioInputUI(_this3.hot, { + name: 'operator', + label: { + htmlFor: operation, + textContent: getOperationName(operation) + }, + value: operation, + checked: operation === operationKeys[SELECTED_AT_START_ELEMENT_INDEX], + id: operation + }); + radioInput.addLocalHook('change', function (event) { + return _this3.onRadioInputChange(event); + }); + + _this3.elements.push(radioInput); + }); + } + /** + * Set state of operators component to check radio input at specific `index`. + * + * @param {number} searchedIndex Index of radio input to check. + */ + + }, { + key: "setChecked", + value: function setChecked(searchedIndex) { + if (this.elements.length < searchedIndex) { + throw Error(toSingleLine(_templateObject$9 || (_templateObject$9 = _taggedTemplateLiteral$9(["Radio button with index ", " doesn't exist."])), searchedIndex)); + } + + arrayEach(this.elements, function (element, index) { + element.setChecked(index === searchedIndex); + }); + } + /** + * Get `id` of active operator. + * + * @returns {string} + */ + + }, { + key: "getActiveOperationId", + value: function getActiveOperationId() { + var operationElement = this.elements.find(function (element) { + return element instanceof RadioInputUI && element.isChecked(); + }); + + if (operationElement) { + return operationElement.getValue(); + } + + return OPERATION_ID; + } + /** + * Export state of the component (get selected operator). + * + * @returns {string} Returns `id` of selected operator. + */ + + }, { + key: "getState", + value: function getState() { + return this.getActiveOperationId(); + } + /** + * Set state of the component. + * + * @param {object} value State to restore. + */ + + }, { + key: "setState", + value: function setState(value) { + this.reset(); + + if (value && this.getActiveOperationId() !== value) { + arrayEach(this.elements, function (element) { + element.setChecked(element.getValue() === value); + }); + } + } + /** + * Update state of component. + * + * @param {string} [operationId='conjunction'] Id of selected operation. + * @param {number} column Physical column index. + */ + + }, { + key: "updateState", + value: function updateState() { + var operationId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : OPERATION_ID; + var column = arguments.length > 1 ? arguments[1] : undefined; + var selectedOperationId = operationId; + + if (selectedOperationId === OPERATION_ID$2) { + selectedOperationId = OPERATION_ID$1; + } + + this.state.setValueAtIndex(column, selectedOperationId); + } + /** + * Reset elements to their initial state. + */ + + }, { + key: "reset", + value: function reset() { + this.setChecked(SELECTED_AT_START_ELEMENT_INDEX); + } + /** + * OnChange listener. + * + * @private + * @param {Event} event The DOM event object. + */ + + }, { + key: "onRadioInputChange", + value: function onRadioInputChange(event) { + this.setState(event.target.value); + } + }]); + + return OperatorsComponent; +}(BaseComponent); + +var quot = /"/g; + +// B.2.3.2.1 CreateHTML(string, tag, attribute, value) +// https://tc39.es/ecma262/#sec-createhtml +var createHtml = function (string, tag, attribute, value) { + var S = String(requireObjectCoercible(string)); + var p1 = '<' + tag; + if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"'; + return p1 + '>' + S + ''; +}; + +// check the existence of a method, lowercase +// of a tag and escaping quotes in arguments +var stringHtmlForced = function (METHOD_NAME) { + return fails(function () { + var test = ''[METHOD_NAME]('"'); + return test !== test.toLowerCase() || test.split('"').length > 3; + }); +}; + +// `String.prototype.link` method +// https://tc39.es/ecma262/#sec-string.prototype.link +_export({ target: 'String', proto: true, forced: stringHtmlForced('link') }, { + link: function link(url) { + return createHtml(this, 'a', 'href', url); + } +}); + +function _typeof$1k(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1k = function _typeof(obj) { return typeof obj; }; } else { _typeof$1k = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1k(obj); } + +function _classCallCheck$2f(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$29(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); } } + +function _createClass$29(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$29(Constructor.prototype, protoProps); if (staticProps) _defineProperties$29(Constructor, staticProps); return Constructor; } + +function _get$J(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$J = Reflect.get; } else { _get$J = function _get(target, property, receiver) { var base = _superPropBase$J(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$J(target, property, receiver || target); } + +function _superPropBase$J(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$18(object); if (object === null) break; } return object; } + +function _inherits$18(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$19(subClass, superClass); } + +function _setPrototypeOf$19(o, p) { _setPrototypeOf$19 = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$19(o, p); } + +function _createSuper$18(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$19(); return function _createSuperInternal() { var Super = _getPrototypeOf$18(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$18(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$18(this, result); }; } + +function _possibleConstructorReturn$18(self, call) { if (call && (_typeof$1k(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$18(self); } + +function _assertThisInitialized$18(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$19() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$18(o) { _getPrototypeOf$18 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$18(o); } +var privatePool$i = new WeakMap(); +/** + * @class LinkUI + * @util + */ + +var LinkUI = /*#__PURE__*/function (_BaseUI) { + _inherits$18(LinkUI, _BaseUI); + + var _super = _createSuper$18(LinkUI); + + function LinkUI(hotInstance, options) { + var _this; + + _classCallCheck$2f(this, LinkUI); + + _this = _super.call(this, hotInstance, extend(LinkUI.DEFAULTS, options)); + privatePool$i.set(_assertThisInitialized$18(_this), {}); + return _this; + } + /** + * Build DOM structure. + */ + + + _createClass$29(LinkUI, [{ + key: "build", + value: function build() { + _get$J(_getPrototypeOf$18(LinkUI.prototype), "build", this).call(this); + + var priv = privatePool$i.get(this); + priv.link = this._element.firstChild; + } + /** + * Update element. + */ + + }, { + key: "update", + value: function update() { + if (!this.isBuilt()) { + return; + } + + privatePool$i.get(this).link.textContent = this.translateIfPossible(this.options.textContent); + } + }], [{ + key: "DEFAULTS", + get: function get() { + return clone({ + href: '#', + tagName: 'a' + }); + } + }]); + + return LinkUI; +}(BaseUI$2); + +function _typeof$1l(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1l = function _typeof(obj) { return typeof obj; }; } else { _typeof$1l = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1l(obj); } + +function _toConsumableArray$q(arr) { return _arrayWithoutHoles$o(arr) || _iterableToArray$q(arr) || _unsupportedIterableToArray$W(arr) || _nonIterableSpread$o(); } + +function _nonIterableSpread$o() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$W(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$W(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$W(o, minLen); } + +function _iterableToArray$q(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$o(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$W(arr); } + +function _arrayLikeToArray$W(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$2g(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2a(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); } } + +function _createClass$2a(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2a(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2a(Constructor, staticProps); return Constructor; } + +function _get$K(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$K = Reflect.get; } else { _get$K = function _get(target, property, receiver) { var base = _superPropBase$K(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$K(target, property, receiver || target); } + +function _superPropBase$K(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$19(object); if (object === null) break; } return object; } + +function _inherits$19(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1a(subClass, superClass); } + +function _setPrototypeOf$1a(o, p) { _setPrototypeOf$1a = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1a(o, p); } + +function _createSuper$19(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1a(); return function _createSuperInternal() { var Super = _getPrototypeOf$19(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$19(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$19(this, result); }; } + +function _possibleConstructorReturn$19(self, call) { if (call && (_typeof$1l(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$19(self); } + +function _assertThisInitialized$19(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1a() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$19(o) { _getPrototypeOf$19 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$19(o); } +var privatePool$j = new WeakMap(); +/** + * @class MultipleSelectUI + * @util + */ + +var MultipleSelectUI = /*#__PURE__*/function (_BaseUI) { + _inherits$19(MultipleSelectUI, _BaseUI); + + var _super = _createSuper$19(MultipleSelectUI); + + function MultipleSelectUI(hotInstance, options) { + var _this; + + _classCallCheck$2g(this, MultipleSelectUI); + + _this = _super.call(this, hotInstance, extend(MultipleSelectUI.DEFAULTS, options)); + privatePool$j.set(_assertThisInitialized$19(_this), {}); + /** + * Input element. + * + * @type {InputUI} + */ + + _this.searchInput = new InputUI(_this.hot, { + placeholder: FILTERS_BUTTONS_PLACEHOLDER_SEARCH, + className: 'htUIMultipleSelectSearch' + }); + /** + * "Select all" UI element. + * + * @type {BaseUI} + */ + + _this.selectAllUI = new LinkUI(_this.hot, { + textContent: FILTERS_BUTTONS_SELECT_ALL, + className: 'htUISelectAll' + }); + /** + * "Clear" UI element. + * + * @type {BaseUI} + */ + + _this.clearAllUI = new LinkUI(_this.hot, { + textContent: FILTERS_BUTTONS_CLEAR, + className: 'htUIClearAll' + }); + /** + * List of available select options. + * + * @type {Array} + */ + + _this.items = []; + /** + * Handsontable instance used as items list element. + * + * @type {Handsontable} + */ + + _this.itemsBox = null; + + _this.registerHooks(); + + return _this; + } + /** + * Register all necessary hooks. + */ + + + _createClass$2a(MultipleSelectUI, [{ + key: "registerHooks", + value: function registerHooks() { + var _this2 = this; + + this.searchInput.addLocalHook('keydown', function (event) { + return _this2.onInputKeyDown(event); + }); + this.searchInput.addLocalHook('input', function (event) { + return _this2.onInput(event); + }); + this.selectAllUI.addLocalHook('click', function (event) { + return _this2.onSelectAllClick(event); + }); + this.clearAllUI.addLocalHook('click', function (event) { + return _this2.onClearAllClick(event); + }); + } + /** + * Set available options. + * + * @param {Array} items Array of objects with `checked` and `label` property. + */ + + }, { + key: "setItems", + value: function setItems(items) { + this.items = items; + + if (this.itemsBox) { + this.itemsBox.loadData(this.items); + } + } + /** + * Get all available options. + * + * @returns {Array} + */ + + }, { + key: "getItems", + value: function getItems() { + return _toConsumableArray$q(this.items); + } + /** + * Get element value. + * + * @returns {Array} Array of selected values. + */ + + }, { + key: "getValue", + value: function getValue() { + return itemsToValue(this.items); + } + /** + * Check if all values listed in element are selected. + * + * @returns {boolean} + */ + + }, { + key: "isSelectedAllValues", + value: function isSelectedAllValues() { + return this.items.length === this.getValue().length; + } + /** + * Build DOM structure. + */ + + }, { + key: "build", + value: function build() { + var _this3 = this; + + _get$K(_getPrototypeOf$19(MultipleSelectUI.prototype), "build", this).call(this); + + var rootDocument = this.hot.rootDocument; + var itemsBoxWrapper = rootDocument.createElement('div'); + var selectionControl = new BaseUI$2(this.hot, { + className: 'htUISelectionControls', + children: [this.selectAllUI, this.clearAllUI] + }); + + this._element.appendChild(this.searchInput.element); + + this._element.appendChild(selectionControl.element); + + this._element.appendChild(itemsBoxWrapper); + + var hotInitializer = function hotInitializer(wrapper) { + if (!_this3._element) { + return; + } + + if (_this3.itemsBox) { + _this3.itemsBox.destroy(); + } + + addClass(wrapper, 'htUIMultipleSelectHot'); // Construct and initialise a new Handsontable + + _this3.itemsBox = new _this3.hot.constructor(wrapper, { + data: _this3.items, + columns: [{ + data: 'checked', + type: 'checkbox', + label: { + property: 'visualValue', + position: 'after' + } + }], + beforeRenderer: function beforeRenderer(TD, row, col, prop, value, cellProperties) { + TD.title = cellProperties.instance.getDataAtRowProp(row, cellProperties.label.property); + }, + maxCols: 1, + autoWrapCol: true, + height: 110, + // Workaround for #151. + colWidths: function colWidths() { + return _this3.itemsBox.container.scrollWidth - getScrollbarWidth(rootDocument); + }, + copyPaste: false, + disableVisualSelection: 'area', + fillHandle: false, + fragmentSelection: 'cell', + tabMoves: { + row: 1, + col: 0 + }, + beforeKeyDown: function beforeKeyDown(event) { + return _this3.onItemsBoxBeforeKeyDown(event); + } + }); + + _this3.itemsBox.init(); + }; + + hotInitializer(itemsBoxWrapper); + setTimeout(function () { + return hotInitializer(itemsBoxWrapper); + }, 100); + } + /** + * Reset DOM structure. + */ + + }, { + key: "reset", + value: function reset() { + this.searchInput.reset(); + this.selectAllUI.reset(); + this.clearAllUI.reset(); + } + /** + * Update DOM structure. + */ + + }, { + key: "update", + value: function update() { + if (!this.isBuilt()) { + return; + } + + this.itemsBox.loadData(valueToItems(this.items, this.options.value)); + + _get$K(_getPrototypeOf$19(MultipleSelectUI.prototype), "update", this).call(this); + } + /** + * Destroy instance. + */ + + }, { + key: "destroy", + value: function destroy() { + if (this.itemsBox) { + this.itemsBox.destroy(); + } + + this.searchInput.destroy(); + this.clearAllUI.destroy(); + this.selectAllUI.destroy(); + this.searchInput = null; + this.clearAllUI = null; + this.selectAllUI = null; + this.itemsBox = null; + this.items = null; + + _get$K(_getPrototypeOf$19(MultipleSelectUI.prototype), "destroy", this).call(this); + } + /** + * 'input' event listener for input element. + * + * @private + * @param {Event} event DOM event. + */ + + }, { + key: "onInput", + value: function onInput(event) { + var value = event.target.value.toLowerCase(); + var filteredItems; + + if (value === '') { + filteredItems = _toConsumableArray$q(this.items); + } else { + filteredItems = arrayFilter(this.items, function (item) { + return "".concat(item.value).toLowerCase().indexOf(value) >= 0; + }); + } + + this.itemsBox.loadData(filteredItems); + } + /** + * 'keydown' event listener for input element. + * + * @private + * @param {Event} event DOM event. + */ + + }, { + key: "onInputKeyDown", + value: function onInputKeyDown(event) { + this.runLocalHooks('keydown', event, this); + var isKeyCode = partial(isKey, event.keyCode); + + if (isKeyCode('ARROW_DOWN|TAB') && !this.itemsBox.isListening()) { + stopImmediatePropagation(event); + this.itemsBox.listen(); + this.itemsBox.selectCell(0, 0); + } + } + /** + * On before key down listener (internal Handsontable). + * + * @private + * @param {Event} event DOM event. + */ + + }, { + key: "onItemsBoxBeforeKeyDown", + value: function onItemsBoxBeforeKeyDown(event) { + var isKeyCode = partial(isKey, event.keyCode); + + if (isKeyCode('ESCAPE')) { + this.runLocalHooks('keydown', event, this); + } // for keys different than below, unfocus Handsontable and focus search input + + + if (!isKeyCode('ARROW_UP|ARROW_DOWN|ARROW_LEFT|ARROW_RIGHT|TAB|SPACE|ENTER')) { + stopImmediatePropagation(event); + this.itemsBox.unlisten(); + this.itemsBox.deselectCell(); + this.searchInput.focus(); + } + } + /** + * On click listener for "Select all" link. + * + * @private + * @param {DOMEvent} event The mouse event object. + */ + + }, { + key: "onSelectAllClick", + value: function onSelectAllClick(event) { + var changes = []; + event.preventDefault(); + arrayEach(this.itemsBox.getSourceData(), function (row, rowIndex) { + row.checked = true; + changes.push(dataRowToChangesArray(row, rowIndex)[0]); + }); + this.itemsBox.setSourceDataAtCell(changes); + } + /** + * On click listener for "Clear" link. + * + * @private + * @param {DOMEvent} event The mouse event object. + */ + + }, { + key: "onClearAllClick", + value: function onClearAllClick(event) { + var changes = []; + event.preventDefault(); + arrayEach(this.itemsBox.getSourceData(), function (row, rowIndex) { + row.checked = false; + changes.push(dataRowToChangesArray(row, rowIndex)[0]); + }); + this.itemsBox.setSourceDataAtCell(changes); + } + }], [{ + key: "DEFAULTS", + get: function get() { + return clone({ + className: 'htUIMultipleSelect', + value: [] + }); + } + }]); + + return MultipleSelectUI; +}(BaseUI$2); +/** + * Pick up object items based on selected values. + * + * @param {Array} availableItems Base collection to compare values. + * @param {Array} selectedValue Flat array with selected values. + * @returns {Array} + */ + +function valueToItems(availableItems, selectedValue) { + var arrayAssertion = createArrayAssertion(selectedValue); + return arrayMap(availableItems, function (item) { + item.checked = arrayAssertion(item.value); + return item; + }); +} +/** + * Convert all checked items into flat array. + * + * @param {Array} availableItems Base collection. + * @returns {Array} + */ + + +function itemsToValue(availableItems) { + var items = []; + arrayEach(availableItems, function (item) { + if (item.checked) { + items.push(item.value); + } + }); + return items; +} + +function _typeof$1m(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1m = function _typeof(obj) { return typeof obj; }; } else { _typeof$1m = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1m(obj); } + +function _slicedToArray$F(arr, i) { return _arrayWithHoles$H(arr) || _iterableToArrayLimit$F(arr, i) || _unsupportedIterableToArray$X(arr, i) || _nonIterableRest$H(); } + +function _nonIterableRest$H() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$X(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$X(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$X(o, minLen); } + +function _arrayLikeToArray$X(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$F(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$H(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$2h(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2b(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); } } + +function _createClass$2b(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2b(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2b(Constructor, staticProps); return Constructor; } + +function _get$L(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$L = Reflect.get; } else { _get$L = function _get(target, property, receiver) { var base = _superPropBase$L(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$L(target, property, receiver || target); } + +function _superPropBase$L(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1a(object); if (object === null) break; } return object; } + +function _inherits$1a(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1b(subClass, superClass); } + +function _setPrototypeOf$1b(o, p) { _setPrototypeOf$1b = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1b(o, p); } + +function _createSuper$1a(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1b(); return function _createSuperInternal() { var Super = _getPrototypeOf$1a(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1a(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1a(this, result); }; } + +function _possibleConstructorReturn$1a(self, call) { if (call && (_typeof$1m(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1a(self); } + +function _assertThisInitialized$1a(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1b() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1a(o) { _getPrototypeOf$1a = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1a(o); } +/** + * @class ValueComponent + * @plugin Filters + */ + +var ValueComponent = /*#__PURE__*/function (_BaseComponent) { + _inherits$1a(ValueComponent, _BaseComponent); + + var _super = _createSuper$1a(ValueComponent); + + function ValueComponent(hotInstance, options) { + var _this; + + _classCallCheck$2h(this, ValueComponent); + + _this = _super.call(this, hotInstance, { + id: options.id, + stateless: false + }); + _this.name = options.name; + + _this.elements.push(new MultipleSelectUI(_this.hot)); + + _this.registerHooks(); + + return _this; + } + /** + * Register all necessary hooks. + * + * @private + */ + + + _createClass$2b(ValueComponent, [{ + key: "registerHooks", + value: function registerHooks() { + var _this2 = this; + + this.getMultipleSelectElement().addLocalHook('keydown', function (event) { + return _this2.onInputKeyDown(event); + }); + } + /** + * Set state of the component. + * + * @param {object} value The component value. + */ + + }, { + key: "setState", + value: function setState(value) { + this.reset(); + + if (value && value.command.key === CONDITION_NAME$k) { + var select = this.getMultipleSelectElement(); + select.setItems(value.itemsSnapshot); + select.setValue(value.args[0]); + } + } + /** + * Export state of the component (get selected filter and filter arguments). + * + * @returns {object} Returns object where `command` key keeps used condition filter and `args` key its arguments. + */ + + }, { + key: "getState", + value: function getState() { + var select = this.getMultipleSelectElement(); + var availableItems = select.getItems(); + return { + command: { + key: select.isSelectedAllValues() || !availableItems.length ? CONDITION_NAME : CONDITION_NAME$k + }, + args: [select.getValue()], + itemsSnapshot: availableItems + }; + } + /** + * Update state of component. + * + * @param {object} stateInfo Information about state containing stack of edited column, + * stack of dependent conditions, data factory and optional condition arguments change. It's described by object containing keys: + * `editedConditionStack`, `dependentConditionStacks`, `visibleDataFactory` and `conditionArgsChange`. + */ + + }, { + key: "updateState", + value: function updateState(stateInfo) { + var _this3 = this; + + var updateColumnState = function updateColumnState(physicalColumn, conditions, conditionArgsChange, filteredRowsFactory, conditionsStack) { + var _arrayFilter = arrayFilter(conditions, function (condition) { + return condition.name === CONDITION_NAME$k; + }), + _arrayFilter2 = _slicedToArray$F(_arrayFilter, 1), + firstByValueCondition = _arrayFilter2[0]; + + var state = {}; + + var defaultBlankCellValue = _this3.hot.getTranslatedPhrase(FILTERS_VALUES_BLANK_CELLS); + + if (firstByValueCondition) { + var rowValues = unifyColumnValues(arrayMap(filteredRowsFactory(physicalColumn, conditionsStack), function (row) { + return row.value; + })); + + if (conditionArgsChange) { + firstByValueCondition.args[0] = conditionArgsChange; + } + + var selectedValues = []; + var itemsSnapshot = intersectValues(rowValues, firstByValueCondition.args[0], defaultBlankCellValue, function (item) { + if (item.checked) { + selectedValues.push(item.value); + } + }); + state.args = [selectedValues]; + state.command = getConditionDescriptor(CONDITION_NAME$k); + state.itemsSnapshot = itemsSnapshot; + } else { + state.args = []; + state.command = getConditionDescriptor(CONDITION_NAME); + } + + _this3.state.setValueAtIndex(physicalColumn, state); + }; + + updateColumnState(stateInfo.editedConditionStack.column, stateInfo.editedConditionStack.conditions, stateInfo.conditionArgsChange, stateInfo.filteredRowsFactory); // Update the next "by_value" component (filter column conditions added after this condition). + // Its list of values has to be updated. As the new values by default are unchecked, + // the further component update is unnecessary. + + if (stateInfo.dependentConditionStacks.length) { + updateColumnState(stateInfo.dependentConditionStacks[0].column, stateInfo.dependentConditionStacks[0].conditions, stateInfo.conditionArgsChange, stateInfo.filteredRowsFactory, stateInfo.editedConditionStack); + } + } + /** + * Get multiple select element. + * + * @returns {MultipleSelectUI} + */ + + }, { + key: "getMultipleSelectElement", + value: function getMultipleSelectElement() { + return this.elements.filter(function (element) { + return element instanceof MultipleSelectUI; + })[0]; + } + /** + * Get object descriptor for menu item entry. + * + * @returns {object} + */ + + }, { + key: "getMenuItemDescriptor", + value: function getMenuItemDescriptor() { + var _this4 = this; + + return { + key: this.id, + name: this.name, + isCommand: false, + disableSelection: true, + hidden: function hidden() { + return _this4.isHidden(); + }, + renderer: function renderer(hot, wrapper, row, col, prop, value) { + addClass(wrapper.parentNode, 'htFiltersMenuValue'); + + var label = _this4.hot.rootDocument.createElement('div'); + + addClass(label, 'htFiltersMenuLabel'); + label.textContent = value; + wrapper.appendChild(label); + + if (!wrapper.parentNode.hasAttribute('ghost-table')) { + arrayEach(_this4.elements, function (ui) { + return wrapper.appendChild(ui.element); + }); + } + + return wrapper; + } + }; + } + /** + * Reset elements to their initial state. + */ + + }, { + key: "reset", + value: function reset() { + var defaultBlankCellValue = this.hot.getTranslatedPhrase(FILTERS_VALUES_BLANK_CELLS); + var values = unifyColumnValues(this._getColumnVisibleValues()); + var items = intersectValues(values, values, defaultBlankCellValue); + this.getMultipleSelectElement().setItems(items); + + _get$L(_getPrototypeOf$1a(ValueComponent.prototype), "reset", this).call(this); + + this.getMultipleSelectElement().setValue(values); + } + /** + * Key down listener. + * + * @private + * @param {Event} event The DOM event object. + */ + + }, { + key: "onInputKeyDown", + value: function onInputKeyDown(event) { + if (isKey(event.keyCode, 'ESCAPE')) { + this.runLocalHooks('cancel'); + stopImmediatePropagation(event); + } + } + /** + * Get data for currently selected column. + * + * @returns {Array} + * @private + */ + + }, { + key: "_getColumnVisibleValues", + value: function _getColumnVisibleValues() { + var lastSelectedColumn = this.hot.getPlugin('filters').getSelectedColumn(); + var visualIndex = lastSelectedColumn && lastSelectedColumn.visualIndex; + return arrayMap(this.hot.getDataAtCol(visualIndex), function (v) { + return toEmptyString(v); + }); + } + }]); + + return ValueComponent; +}(BaseComponent); + +function _typeof$1n(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1n = function _typeof(obj) { return typeof obj; }; } else { _typeof$1n = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1n(obj); } + +function _classCallCheck$2i(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2c(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); } } + +function _createClass$2c(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2c(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2c(Constructor, staticProps); return Constructor; } + +function _inherits$1b(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1c(subClass, superClass); } + +function _setPrototypeOf$1c(o, p) { _setPrototypeOf$1c = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1c(o, p); } + +function _createSuper$1b(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1c(); return function _createSuperInternal() { var Super = _getPrototypeOf$1b(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1b(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1b(this, result); }; } + +function _possibleConstructorReturn$1b(self, call) { if (call && (_typeof$1n(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1b(self); } + +function _assertThisInitialized$1b(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1c() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1b(o) { _getPrototypeOf$1b = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1b(o); } +/** + * @class ActionBarComponent + * @plugin Filters + */ + +var ActionBarComponent = /*#__PURE__*/function (_BaseComponent) { + _inherits$1b(ActionBarComponent, _BaseComponent); + + var _super = _createSuper$1b(ActionBarComponent); + + function ActionBarComponent(hotInstance, options) { + var _this; + + _classCallCheck$2i(this, ActionBarComponent); + + _this = _super.call(this, hotInstance, { + id: options.id, + stateless: true + }); + _this.name = options.name; + + _this.elements.push(new InputUI(_this.hot, { + type: 'button', + value: FILTERS_BUTTONS_OK, + className: 'htUIButton htUIButtonOK', + identifier: ActionBarComponent.BUTTON_OK + })); + + _this.elements.push(new InputUI(_this.hot, { + type: 'button', + value: FILTERS_BUTTONS_CANCEL, + className: 'htUIButton htUIButtonCancel', + identifier: ActionBarComponent.BUTTON_CANCEL + })); + + _this.registerHooks(); + + return _this; + } + /** + * Register all necessary hooks. + * + * @private + */ + + + _createClass$2c(ActionBarComponent, [{ + key: "registerHooks", + value: function registerHooks() { + var _this2 = this; + + arrayEach(this.elements, function (element) { + element.addLocalHook('click', function (event, button) { + return _this2.onButtonClick(event, button); + }); + }); + } + /** + * Get menu object descriptor. + * + * @returns {object} + */ + + }, { + key: "getMenuItemDescriptor", + value: function getMenuItemDescriptor() { + var _this3 = this; + + return { + key: this.id, + name: this.name, + isCommand: false, + disableSelection: true, + hidden: function hidden() { + return _this3.isHidden(); + }, + renderer: function renderer(hot, wrapper) { + addClass(wrapper.parentNode, 'htFiltersMenuActionBar'); + + if (!wrapper.parentNode.hasAttribute('ghost-table')) { + arrayEach(_this3.elements, function (ui) { + return wrapper.appendChild(ui.element); + }); + } + + return wrapper; + } + }; + } + /** + * Fire accept event. + */ + + }, { + key: "accept", + value: function accept() { + this.runLocalHooks('accept'); + } + /** + * Fire cancel event. + */ + + }, { + key: "cancel", + value: function cancel() { + this.runLocalHooks('cancel'); + } + /** + * On button click listener. + * + * @private + * @param {Event} event DOM event. + * @param {InputUI} button InputUI object. + */ + + }, { + key: "onButtonClick", + value: function onButtonClick(event, button) { + if (button.options.identifier === ActionBarComponent.BUTTON_OK) { + this.accept(); + } else { + this.cancel(); + } + } + }], [{ + key: "BUTTON_OK", + get: function get() { + return 'ok'; + } + }, { + key: "BUTTON_CANCEL", + get: function get() { + return 'cancel'; + } + }]); + + return ActionBarComponent; +}(BaseComponent); + +var _templateObject$a, _templateObject2$2; + +function _slicedToArray$G(arr, i) { return _arrayWithHoles$I(arr) || _iterableToArrayLimit$G(arr, i) || _unsupportedIterableToArray$Y(arr, i) || _nonIterableRest$I(); } + +function _nonIterableRest$I() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$Y(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$Y(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$Y(o, minLen); } + +function _arrayLikeToArray$Y(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$G(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$I(arr) { if (Array.isArray(arr)) return arr; } + +function _taggedTemplateLiteral$a(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _classCallCheck$2j(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2d(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); } } + +function _createClass$2d(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2d(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2d(Constructor, staticProps); return Constructor; } +var MAP_NAME = 'ConditionCollection.filteringStates'; +/** + * @class ConditionCollection + * @plugin Filters + */ + +var ConditionCollection = /*#__PURE__*/function () { + function ConditionCollection(hot) { + var isMapRegistrable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + + _classCallCheck$2j(this, ConditionCollection); + + /** + * Handsontable instance. + * + * @type {Core} + */ + this.hot = hot; + /** + * Indicates whether the internal IndexMap should be registered or not. Generally, + * registered Maps responds to the index changes. Within that collection, sometimes + * this is not necessary. + * + * @type {boolean} + */ + + this.isMapRegistrable = isMapRegistrable; + /** + * Index map storing filtering states for every column. ConditionCollection write and read to/from this element. + * + * @type {LinkedPhysicalIndexToValueMap} + */ + + this.filteringStates = new LinkedPhysicalIndexToValueMap(); + + if (this.isMapRegistrable === true) { + this.hot.columnIndexMapper.registerMap(MAP_NAME, this.filteringStates); + } else { + this.filteringStates.init(this.hot.columnIndexMapper.getNumberOfIndexes()); + } + } + /** + * Check if condition collection is empty (so no needed to filter data). + * + * @returns {boolean} + */ + + + _createClass$2d(ConditionCollection, [{ + key: "isEmpty", + value: function isEmpty() { + return this.getFilteredColumns().length === 0; + } + /** + * Check if value is matched to the criteria of conditions chain. + * + * @param {object} value Object with `value` and `meta` keys. + * @param {number} column The physical column index. + * @returns {boolean} + */ + + }, { + key: "isMatch", + value: function isMatch(value, column) { + var _stateForColumn$condi; + + var stateForColumn = this.filteringStates.getValueAtIndex(column); + var conditions = (_stateForColumn$condi = stateForColumn === null || stateForColumn === void 0 ? void 0 : stateForColumn.conditions) !== null && _stateForColumn$condi !== void 0 ? _stateForColumn$condi : []; + var operation = stateForColumn === null || stateForColumn === void 0 ? void 0 : stateForColumn.operation; + return this.isMatchInConditions(conditions, value, operation); + } + /** + * Check if the value is matches the conditions. + * + * @param {Array} conditions List of conditions. + * @param {object} value Object with `value` and `meta` keys. + * @param {string} [operationType='conjunction'] Type of conditions operation. + * @returns {boolean} + */ + + }, { + key: "isMatchInConditions", + value: function isMatchInConditions(conditions, value) { + var operationType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : OPERATION_ID; + + if (conditions.length) { + return getOperationFunc(operationType)(conditions, value); + } + + return true; + } + /** + * Add condition to the collection. + * + * @param {number} column The physical column index. + * @param {object} conditionDefinition Object with keys: + * * `command` Object, Command object with condition name as `key` property. + * * `args` Array, Condition arguments. + * @param {string} [operation='conjunction'] Type of conditions operation. + * @param {number} [position] Position to which condition will be added. When argument is undefined + * the condition will be processed as the last condition. + * @fires ConditionCollection#beforeAdd + * @fires ConditionCollection#afterAdd + */ + + }, { + key: "addCondition", + value: function addCondition(column, conditionDefinition) { + var operation = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : OPERATION_ID; + var position = arguments.length > 3 ? arguments[3] : undefined; + var args = arrayMap(conditionDefinition.args, function (v) { + return typeof v === 'string' ? v.toLowerCase() : v; + }); + var name = conditionDefinition.name || conditionDefinition.command.key; + this.runLocalHooks('beforeAdd', column); + var columnType = this.getOperation(column); + + if (columnType) { + if (columnType !== operation) { + throw Error(toSingleLine(_templateObject$a || (_templateObject$a = _taggedTemplateLiteral$a(["The column of index ", " has been already applied with a `", "` \n filter operation. Use `removeConditions` to clear the current conditions and then add new ones. \n Mind that you cannot mix different types of operations (for instance, if you use `conjunction`, \n use it consequently for a particular column)."], ["The column of index ", " has been already applied with a \\`", "\\`\\x20\n filter operation. Use \\`removeConditions\\` to clear the current conditions and then add new ones.\\x20\n Mind that you cannot mix different types of operations (for instance, if you use \\`conjunction\\`,\\x20\n use it consequently for a particular column)."])), column, columnType)); + } + } else if (isUndefined(operations[operation])) { + throw new Error(toSingleLine(_templateObject2$2 || (_templateObject2$2 = _taggedTemplateLiteral$a(["Unexpected operation named `", "`. Possible ones are \n `disjunction` and `conjunction`."], ["Unexpected operation named \\`", "\\`. Possible ones are\\x20\n \\`disjunction\\` and \\`conjunction\\`."])), operation)); + } + + var conditionsForColumn = this.getConditions(column); + + if (conditionsForColumn.length === 0) { + // Create first condition for particular column. + this.filteringStates.setValueAtIndex(column, { + operation: operation, + conditions: [{ + name: name, + args: args, + func: getCondition(name, args) + }] + }, position); + } else { + // Add next condition for particular column (by reference). + conditionsForColumn.push({ + name: name, + args: args, + func: getCondition(name, args) + }); + } + + this.runLocalHooks('afterAdd', column); + } + /** + * Get all added conditions from the collection at specified column index. + * + * @param {number} column The physical column index. + * @returns {Array} Returns conditions collection as an array. + */ + + }, { + key: "getConditions", + value: function getConditions(column) { + var _this$filteringStates, _this$filteringStates2; + + return (_this$filteringStates = (_this$filteringStates2 = this.filteringStates.getValueAtIndex(column)) === null || _this$filteringStates2 === void 0 ? void 0 : _this$filteringStates2.conditions) !== null && _this$filteringStates !== void 0 ? _this$filteringStates : []; + } + /** + * Get operation for particular column. + * + * @param {number} column The physical column index. + * @returns {string|undefined} + */ + + }, { + key: "getOperation", + value: function getOperation(column) { + var _this$filteringStates3; + + return (_this$filteringStates3 = this.filteringStates.getValueAtIndex(column)) === null || _this$filteringStates3 === void 0 ? void 0 : _this$filteringStates3.operation; + } + /** + * Get all filtered physical columns in the order in which actions are performed. + * + * @returns {Array} + */ + + }, { + key: "getFilteredColumns", + value: function getFilteredColumns() { + return this.filteringStates.getEntries().map(function (_ref) { + var _ref2 = _slicedToArray$G(_ref, 1), + physicalColumn = _ref2[0]; + + return physicalColumn; + }); + } + /** + * Gets position in the filtering states stack for the specific column. + * + * @param {number} column The physical column index. + * @returns {number} Returns -1 when the column doesn't exist in the stack. + */ + + }, { + key: "getColumnStackPosition", + value: function getColumnStackPosition(column) { + return this.getFilteredColumns().indexOf(column); + } + /** + * Export all previously added conditions. + * + * @returns {Array} + */ + + }, { + key: "exportAllConditions", + value: function exportAllConditions() { + return arrayReduce(this.filteringStates.getEntries(), function (allConditions, _ref3) { + var _ref4 = _slicedToArray$G(_ref3, 2), + column = _ref4[0], + _ref4$ = _ref4[1], + operation = _ref4$.operation, + conditions = _ref4$.conditions; + + allConditions.push({ + column: column, + operation: operation, + conditions: arrayMap(conditions, function (_ref5) { + var name = _ref5.name, + args = _ref5.args; + return { + name: name, + args: args + }; + }) + }); + return allConditions; + }, []); + } + /** + * Import conditions to the collection. + * + * @param {Array} conditions The collection of the conditions. + */ + + }, { + key: "importAllConditions", + value: function importAllConditions(conditions) { + var _this = this; + + this.clean(); + arrayEach(conditions, function (stack) { + arrayEach(stack.conditions, function (condition) { + return _this.addCondition(stack.column, condition); + }); + }); + } + /** + * Remove conditions at given column index. + * + * @param {number} column The physical column index. + * @fires ConditionCollection#beforeRemove + * @fires ConditionCollection#afterRemove + */ + + }, { + key: "removeConditions", + value: function removeConditions(column) { + this.runLocalHooks('beforeRemove', column); + this.filteringStates.clearValue(column); + this.runLocalHooks('afterRemove', column); + } + /** + * Clean all conditions collection and reset order stack. + * + * @fires ConditionCollection#beforeClean + * @fires ConditionCollection#afterClean + */ + + }, { + key: "clean", + value: function clean() { + this.runLocalHooks('beforeClean'); + this.filteringStates.clear(); + this.runLocalHooks('afterClean'); + } + /** + * Check if at least one condition was added at specified column index. And if second parameter is passed then additionally + * check if condition exists under its name. + * + * @param {number} column The physical column index. + * @param {string} [name] Condition name. + * @returns {boolean} + */ + + }, { + key: "hasConditions", + value: function hasConditions(column, name) { + var conditions = this.getConditions(column); + + if (name) { + return conditions.some(function (condition) { + return condition.name === name; + }); + } + + return conditions.length > 0; + } + /** + * Destroy object. + */ + + }, { + key: "destroy", + value: function destroy() { + if (this.isMapRegistrable) { + this.hot.columnIndexMapper.unregisterMap(MAP_NAME); + } + + this.filteringStates = null; + this.clearLocalHooks(); + } + }]); + + return ConditionCollection; +}(); + +mixin(ConditionCollection, localHooks); + +function _classCallCheck$2k(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2e(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); } } + +function _createClass$2e(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2e(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2e(Constructor, staticProps); return Constructor; } +/** + * @class DataFilter + * @plugin Filters + */ + +var DataFilter = /*#__PURE__*/function () { + function DataFilter(conditionCollection) { + var columnDataFactory = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () { + return []; + }; + + _classCallCheck$2k(this, DataFilter); + + /** + * Reference to the instance of {ConditionCollection}. + * + * @type {ConditionCollection} + */ + this.conditionCollection = conditionCollection; + /** + * Function which provide source data factory for specified column. + * + * @type {Function} + */ + + this.columnDataFactory = columnDataFactory; + } + /** + * Filter data based on the conditions collection. + * + * @returns {Array} + */ + + + _createClass$2e(DataFilter, [{ + key: "filter", + value: function filter() { + var _this = this; + + var filteredData = []; + arrayEach(this.conditionCollection.getFilteredColumns(), function (physicalColumn, index) { + var columnData = _this.columnDataFactory(physicalColumn); + + if (index) { + columnData = _this._getIntersectData(columnData, filteredData); + } + + filteredData = _this.filterByColumn(physicalColumn, columnData); + }); + return filteredData; + } + /** + * Filter data based on specified physical column index. + * + * @param {number} column The physical column index. + * @param {Array} [dataSource] Data source as array of objects with `value` and `meta` keys (e.g. `{value: 'foo', meta: {}}`). + * @returns {Array} Returns filtered data. + */ + + }, { + key: "filterByColumn", + value: function filterByColumn(column) { + var _this2 = this; + + var dataSource = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + var filteredData = []; + arrayEach(dataSource, function (dataRow) { + if (dataRow !== void 0 && _this2.conditionCollection.isMatch(dataRow, column)) { + filteredData.push(dataRow); + } + }); + return filteredData; + } + /** + * Intersect data. + * + * @private + * @param {Array} data The data to intersect. + * @param {Array} needles The collection intersected rows with the data. + * @returns {Array} + */ + + }, { + key: "_getIntersectData", + value: function _getIntersectData(data, needles) { + var result = []; + arrayEach(needles, function (needleRow) { + var row = needleRow.meta.visualRow; + + if (data[row] !== void 0) { + result[row] = data[row]; + } + }); + return result; + } + }]); + + return DataFilter; +}(); + +function _classCallCheck$2l(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2f(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); } } + +function _createClass$2f(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2f(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2f(Constructor, staticProps); return Constructor; } +/** + * Class which is designed for observing changes in condition collection. When condition is changed by user at specified + * column it's necessary to update all conditions defined after this edited one. + * + * Object fires `update` hook for every column conditions change. + * + * @class ConditionUpdateObserver + * @plugin Filters + */ + +var ConditionUpdateObserver = /*#__PURE__*/function () { + function ConditionUpdateObserver(hot, conditionCollection) { + var _this = this; + + var columnDataFactory = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () { + return []; + }; + + _classCallCheck$2l(this, ConditionUpdateObserver); + + /** + * Handsontable instance. + * + * @type {Core} + */ + this.hot = hot; + /** + * Reference to the instance of {@link ConditionCollection}. + * + * @type {ConditionCollection} + */ + + this.conditionCollection = conditionCollection; + /** + * Function which provide source data factory for specified column. + * + * @type {Function} + */ + + this.columnDataFactory = columnDataFactory; + /** + * Collected changes when grouping is enabled. + * + * @type {Array} + * @default [] + */ + + this.changes = []; + /** + * Flag which determines if grouping events is enabled. + * + * @type {boolean} + */ + + this.grouping = false; + /** + * The latest known position of edited conditions at specified column index. + * + * @type {number} + * @default -1 + */ + + this.latestEditedColumnPosition = -1; + /** + * The latest known order of conditions stack. + * + * @type {Array} + */ + + this.latestOrderStack = []; + this.conditionCollection.addLocalHook('beforeRemove', function (column) { + return _this._onConditionBeforeModify(column); + }); + this.conditionCollection.addLocalHook('afterRemove', function (column) { + return _this.updateStatesAtColumn(column); + }); + this.conditionCollection.addLocalHook('afterAdd', function (column) { + return _this.updateStatesAtColumn(column); + }); + this.conditionCollection.addLocalHook('beforeClean', function () { + return _this._onConditionBeforeClean(); + }); + this.conditionCollection.addLocalHook('afterClean', function () { + return _this._onConditionAfterClean(); + }); + } + /** + * Enable grouping changes. Grouping is helpful in situations when a lot of conditions is added in one moment. Instead of + * trigger `update` hook for every condition by adding/removing you can group this changes and call `flush` method to trigger + * it once. + */ + + + _createClass$2f(ConditionUpdateObserver, [{ + key: "groupChanges", + value: function groupChanges() { + this.grouping = true; + } + /** + * Flush all collected changes. This trigger `update` hook for every previously collected change from condition collection. + */ + + }, { + key: "flush", + value: function flush() { + var _this2 = this; + + this.grouping = false; + arrayEach(this.changes, function (column) { + _this2.updateStatesAtColumn(column); + }); + this.changes.length = 0; + } + /** + * On before modify condition (add or remove from collection),. + * + * @param {number} column Column index. + * @private + */ + + }, { + key: "_onConditionBeforeModify", + value: function _onConditionBeforeModify(column) { + this.latestEditedColumnPosition = this.conditionCollection.getColumnStackPosition(column); + } + /** + * Update all related states which should be changed after invoking changes applied to current column. + * + * @param {number} column The column index. + * @param {object} conditionArgsChange Object describing condition changes which can be handled by filters on `update` hook. + * It contains keys `conditionKey` and `conditionValue` which refers to change specified key of condition to specified value + * based on referred keys. + */ + + }, { + key: "updateStatesAtColumn", + value: function updateStatesAtColumn(column, conditionArgsChange) { + var _this3 = this; + + if (this.grouping) { + if (this.changes.indexOf(column) === -1) { + this.changes.push(column); + } + + return; + } + + var allConditions = this.conditionCollection.exportAllConditions(); + var editedColumnPosition = this.conditionCollection.getColumnStackPosition(column); + + if (editedColumnPosition === -1) { + editedColumnPosition = this.latestEditedColumnPosition; + } // Collection of all conditions defined before currently edited `column` (without edited one) + + + var conditionsBefore = allConditions.slice(0, editedColumnPosition); // Collection of all conditions defined after currently edited `column` (with edited one) + + var conditionsAfter = allConditions.slice(editedColumnPosition); // Make sure that conditionAfter doesn't contain edited column conditions + + if (conditionsAfter.length && conditionsAfter[0].column === column) { + conditionsAfter.shift(); + } + + var visibleDataFactory = curry(function (curriedConditionsBefore, curriedColumn) { + var conditionsStack = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; + var splitConditionCollection = new ConditionCollection(_this3.hot, false); + var curriedConditionsBeforeArray = [].concat(curriedConditionsBefore, conditionsStack); // Create new condition collection to determine what rows should be visible in "filter by value" box + // in the next conditions in the chain + + splitConditionCollection.importAllConditions(curriedConditionsBeforeArray); + + var allRows = _this3.columnDataFactory(curriedColumn); + + var visibleRows; + + if (splitConditionCollection.isEmpty()) { + visibleRows = allRows; + } else { + visibleRows = new DataFilter(splitConditionCollection, function (columnData) { + return _this3.columnDataFactory(columnData); + }).filter(); + } + + visibleRows = arrayMap(visibleRows, function (rowData) { + return rowData.meta.visualRow; + }); + var visibleRowsAssertion = createArrayAssertion(visibleRows); + splitConditionCollection.destroy(); + return arrayFilter(allRows, function (rowData) { + return visibleRowsAssertion(rowData.meta.visualRow); + }); + })(conditionsBefore); + var editedConditions = [].concat(this.conditionCollection.getConditions(column)); + this.runLocalHooks('update', { + editedConditionStack: { + column: column, + conditions: editedConditions + }, + dependentConditionStacks: conditionsAfter, + filteredRowsFactory: visibleDataFactory, + conditionArgsChange: conditionArgsChange + }); + } + /** + * On before conditions clean listener. + * + * @private + */ + + }, { + key: "_onConditionBeforeClean", + value: function _onConditionBeforeClean() { + this.latestOrderStack = this.conditionCollection.getFilteredColumns(); + } + /** + * On after conditions clean listener. + * + * @private + */ + + }, { + key: "_onConditionAfterClean", + value: function _onConditionAfterClean() { + var _this4 = this; + + arrayEach(this.latestOrderStack, function (column) { + _this4.updateStatesAtColumn(column); + }); + } + /** + * Destroy instance. + */ + + }, { + key: "destroy", + value: function destroy() { + var _this5 = this; + + this.clearLocalHooks(); + objectEach(this, function (value, property) { + _this5[property] = null; + }); + } + }]); + + return ConditionUpdateObserver; +}(); + +mixin(ConditionUpdateObserver, localHooks); + +function _typeof$1o(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1o = function _typeof(obj) { return typeof obj; }; } else { _typeof$1o = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1o(obj); } + +var _templateObject$b; + +function _taggedTemplateLiteral$b(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _slicedToArray$H(arr, i) { return _arrayWithHoles$J(arr) || _iterableToArrayLimit$H(arr, i) || _unsupportedIterableToArray$Z(arr, i) || _nonIterableRest$J(); } + +function _nonIterableRest$J() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$Z(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$Z(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$Z(o, minLen); } + +function _arrayLikeToArray$Z(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$H(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$J(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$2m(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2g(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); } } + +function _createClass$2g(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2g(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2g(Constructor, staticProps); return Constructor; } + +function _get$M(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$M = Reflect.get; } else { _get$M = function _get(target, property, receiver) { var base = _superPropBase$M(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$M(target, property, receiver || target); } + +function _superPropBase$M(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1c(object); if (object === null) break; } return object; } + +function _inherits$1c(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1d(subClass, superClass); } + +function _setPrototypeOf$1d(o, p) { _setPrototypeOf$1d = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1d(o, p); } + +function _createSuper$1c(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1d(); return function _createSuperInternal() { var Super = _getPrototypeOf$1c(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1c(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1c(this, result); }; } + +function _possibleConstructorReturn$1c(self, call) { if (call && (_typeof$1o(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1c(self); } + +function _assertThisInitialized$1c(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1d() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1c(o) { _getPrototypeOf$1c = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1c(o); } +var PLUGIN_KEY$r = 'filters'; +var PLUGIN_PRIORITY$p = 250; +/** + * @plugin Filters + * + * @description + * The plugin allows filtering the table data either by the built-in component or with the API. + * + * See [the filtering demo](https://handsontable.com/docs/demo-filtering.html) for examples. + * + * @example + * ``` + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData(), + * colHeaders: true, + * rowHeaders: true, + * dropdownMenu: true, + * filters: true + * }); + * ``` + */ + +var Filters = /*#__PURE__*/function (_BasePlugin) { + _inherits$1c(Filters, _BasePlugin); + + var _super = _createSuper$1c(Filters); + + function Filters(hotInstance) { + var _this; + + _classCallCheck$2m(this, Filters); + + _this = _super.call(this, hotInstance); + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + _this.eventManager = new EventManager(_assertThisInitialized$1c(_this)); + /** + * Instance of {@link DropdownMenu}. + * + * @private + * @type {DropdownMenu} + */ + + _this.dropdownMenuPlugin = null; + /** + * Instance of {@link ConditionCollection}. + * + * @private + * @type {ConditionCollection} + */ + + _this.conditionCollection = null; + /** + * Instance of {@link ConditionUpdateObserver}. + * + * @private + * @type {ConditionUpdateObserver} + */ + + _this.conditionUpdateObserver = null; + /** + * Map, where key is component identifier and value represent `BaseComponent` element or it derivatives. + * + * @private + * @type {Map} + */ + + _this.components = new Map([['filter_by_condition', null], ['filter_operators', null], ['filter_by_condition2', null], ['filter_by_value', null], ['filter_action_bar', null]]); + /** + * Object containing information about last selected column physical and visual index for added filter conditions. + * + * @private + * @type {object} + * @default null + */ + + _this.lastSelectedColumn = null; + /** + * Map of skipped rows by plugin. + * + * @private + * @type {null|TrimmingMap} + */ + + _this.filtersRowsMap = null; // One listener for the enable/disable functionality + + _this.hot.addHook('afterGetColHeader', function (col, TH) { + return _this.onAfterGetColHeader(col, TH); + }); + + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link Filters#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$2g(Filters, [{ + key: "isEnabled", + value: function isEnabled() { + /* eslint-disable no-unneeded-ternary */ + return this.hot.getSettings()[PLUGIN_KEY$r] ? true : false; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.filtersRowsMap = this.hot.rowIndexMapper.registerMap(this.pluginName, new TrimmingMap()); + this.dropdownMenuPlugin = this.hot.getPlugin('dropdownMenu'); + var dropdownSettings = this.hot.getSettings().dropdownMenu; + var menuContainer = dropdownSettings && dropdownSettings.uiContainer || this.hot.rootDocument.body; + + var addConfirmationHooks = function addConfirmationHooks(component) { + component.addLocalHook('accept', function () { + return _this2.onActionBarSubmit('accept'); + }); + component.addLocalHook('cancel', function () { + return _this2.onActionBarSubmit('cancel'); + }); + component.addLocalHook('change', function (command) { + return _this2.onComponentChange(component, command); + }); + return component; + }; + + var filterByConditionLabel = function filterByConditionLabel() { + return "".concat(_this2.hot.getTranslatedPhrase(FILTERS_DIVS_FILTER_BY_CONDITION), ":"); + }; + + var filterValueLabel = function filterValueLabel() { + return "".concat(_this2.hot.getTranslatedPhrase(FILTERS_DIVS_FILTER_BY_VALUE), ":"); + }; + + if (!this.components.get('filter_by_condition')) { + var conditionComponent = new ConditionComponent(this.hot, { + id: 'filter_by_condition', + name: filterByConditionLabel, + addSeparator: false, + menuContainer: menuContainer + }); + conditionComponent.addLocalHook('afterClose', function () { + return _this2.onSelectUIClosed(); + }); + this.components.set('filter_by_condition', addConfirmationHooks(conditionComponent)); + } + + if (!this.components.get('filter_operators')) { + this.components.set('filter_operators', new OperatorsComponent(this.hot, { + id: 'filter_operators', + name: 'Operators' + })); + } + + if (!this.components.get('filter_by_condition2')) { + var _conditionComponent = new ConditionComponent(this.hot, { + id: 'filter_by_condition2', + name: '', + addSeparator: true, + menuContainer: menuContainer + }); + + _conditionComponent.addLocalHook('afterClose', function () { + return _this2.onSelectUIClosed(); + }); + + this.components.set('filter_by_condition2', addConfirmationHooks(_conditionComponent)); + } + + if (!this.components.get('filter_by_value')) { + this.components.set('filter_by_value', addConfirmationHooks(new ValueComponent(this.hot, { + id: 'filter_by_value', + name: filterValueLabel + }))); + } + + if (!this.components.get('filter_action_bar')) { + this.components.set('filter_action_bar', addConfirmationHooks(new ActionBarComponent(this.hot, { + id: 'filter_action_bar', + name: 'Action bar' + }))); + } + + if (!this.conditionCollection) { + this.conditionCollection = new ConditionCollection(this.hot); + } + + if (!this.conditionUpdateObserver) { + this.conditionUpdateObserver = new ConditionUpdateObserver(this.hot, this.conditionCollection, function (physicalColumn) { + return _this2.getDataMapAtColumn(physicalColumn); + }); + this.conditionUpdateObserver.addLocalHook('update', function (conditionState) { + return _this2.updateComponents(conditionState); + }); + } + + this.components.forEach(function (component) { + return component.show(); + }); + this.registerEvents(); + this.addHook('beforeDropdownMenuSetItems', function (items) { + return _this2.onBeforeDropdownMenuSetItems(items); + }); + this.addHook('afterDropdownMenuDefaultOptions', function (defaultOptions) { + return _this2.onAfterDropdownMenuDefaultOptions(defaultOptions); + }); + this.addHook('afterDropdownMenuShow', function () { + return _this2.onAfterDropdownMenuShow(); + }); + this.addHook('afterDropdownMenuHide', function () { + return _this2.onAfterDropdownMenuHide(); + }); + this.addHook('afterChange', function (changes) { + return _this2.onAfterChange(changes); + }); // Temp. solution (extending menu items bug in contextMenu/dropdownMenu) + + if (this.hot.getSettings().dropdownMenu && this.dropdownMenuPlugin) { + this.dropdownMenuPlugin.disablePlugin(); + this.dropdownMenuPlugin.enablePlugin(); + } + + _get$M(_getPrototypeOf$1c(Filters.prototype), "enablePlugin", this).call(this); + } + /** + * Registers the DOM listeners. + * + * @private + */ + + }, { + key: "registerEvents", + value: function registerEvents() { + var _this3 = this; + + this.eventManager.addEventListener(this.hot.rootElement, 'click', function (event) { + return _this3.onTableClick(event); + }); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + var _this4 = this; + + if (this.enabled) { + var _this$dropdownMenuPlu; + + if ((_this$dropdownMenuPlu = this.dropdownMenuPlugin) !== null && _this$dropdownMenuPlu !== void 0 && _this$dropdownMenuPlu.enabled) { + this.dropdownMenuPlugin.menu.clearLocalHooks(); + } + + this.components.forEach(function (component, key) { + component.destroy(); + + _this4.components.set(key, null); + }); + this.conditionCollection.destroy(); + this.conditionCollection = null; + this.hot.rowIndexMapper.unregisterMap(this.pluginName); + } + + _get$M(_getPrototypeOf$1c(Filters.prototype), "disablePlugin", this).call(this); + } + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * @memberof Filters# + * @function addCondition + * @description + * Adds condition to the conditions collection at specified column index. + * + * Possible predefined conditions: + * * `begins_with` - Begins with + * * `between` - Between + * * `by_value` - By value + * * `contains` - Contains + * * `empty` - Empty + * * `ends_with` - Ends with + * * `eq` - Equal + * * `gt` - Greater than + * * `gte` - Greater than or equal + * * `lt` - Less than + * * `lte` - Less than or equal + * * `none` - None (no filter) + * * `not_between` - Not between + * * `not_contains` - Not contains + * * `not_empty` - Not empty + * * `neq` - Not equal. + * + * Possible operations on collection of conditions: + * * `conjunction` - [**Conjunction**](https://en.wikipedia.org/wiki/Logical_conjunction) on conditions collection (by default), i.e. for such operation: c1 AND c2 AND c3 AND c4 ... AND cn === TRUE, where c1 ... cn are conditions. + * * `disjunction` - [**Disjunction**](https://en.wikipedia.org/wiki/Logical_disjunction) on conditions collection, i.e. for such operation: `c1 OR c2 OR c3 OR c4 ... OR cn` === TRUE, where c1, c2, c3, c4 ... cn are conditions. + * * `disjunctionWithExtraCondition` - **Disjunction** on first `n - 1`\* conditions from collection with an extra requirement computed from the last condition, i.e. for such operation: `c1 OR c2 OR c3 OR c4 ... OR cn-1 AND cn` === TRUE, where c1, c2, c3, c4 ... cn are conditions. + * + * \* when `n` is collection size; it's used i.e. for one operation introduced from UI (when choosing from filter's drop-down menu two conditions with OR operator between them, mixed with choosing values from the multiple choice select) + * + * **Note**: Mind that you cannot mix different types of operations (for instance, if you use `conjunction`, use it consequently for a particular column). + * + * @example + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData(), + * filters: true + * }); + * + * // access to filters plugin instance + * const filtersPlugin = hot.getPlugin('filters'); + * + * // add filter "Greater than" 95 to column at index 1 + * filtersPlugin.addCondition(1, 'gt', [95]); + * filtersPlugin.filter(); + * + * // add filter "By value" to column at index 1 + * // in this case all value's that don't match will be filtered. + * filtersPlugin.addCondition(1, 'by_value', [['ing', 'ed', 'as', 'on']]); + * filtersPlugin.filter(); + * + * // add filter "Begins with" with value "de" AND "Not contains" with value "ing" + * filtersPlugin.addCondition(1, 'begins_with', ['de'], 'conjunction'); + * filtersPlugin.addCondition(1, 'not_contains', ['ing'], 'conjunction'); + * filtersPlugin.filter(); + * + * // add filter "Begins with" with value "de" OR "Not contains" with value "ing" + * filtersPlugin.addCondition(1, 'begins_with', ['de'], 'disjunction'); + * filtersPlugin.addCondition(1, 'not_contains', ['ing'], 'disjunction'); + * filtersPlugin.filter(); + * ``` + * @param {number} column Visual column index. + * @param {string} name Condition short name. + * @param {Array} args Condition arguments. + * @param {string} [operationId=conjunction] `id` of operation which is performed on the column. + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + }, { + key: "addCondition", + value: function addCondition(column, name, args) { + var operationId = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : OPERATION_ID; + var physicalColumn = this.hot.toPhysicalColumn(column); + this.conditionCollection.addCondition(physicalColumn, { + command: { + key: name + }, + args: args + }, operationId); + } + /** + * Removes conditions at specified column index. + * + * @param {number} column Visual column index. + */ + + }, { + key: "removeConditions", + value: function removeConditions(column) { + var physicalColumn = this.hot.toPhysicalColumn(column); + this.conditionCollection.removeConditions(physicalColumn); + } + /** + * Clears all conditions previously added to the collection for the specified column index or, if the column index + * was not passed, clear the conditions for all columns. + * + * @param {number} [column] Visual column index. + */ + + }, { + key: "clearConditions", + value: function clearConditions(column) { + if (column === void 0) { + this.conditionCollection.clean(); + } else { + var physicalColumn = this.hot.toPhysicalColumn(column); + this.conditionCollection.removeConditions(physicalColumn); + } + } + /** + * Filters data based on added filter conditions. + * + * @fires Hooks#beforeFilter + * @fires Hooks#afterFilter + */ + + }, { + key: "filter", + value: function filter() { + var _this5 = this; + + var dataFilter = this._createDataFilter(); + + var needToFilter = !this.conditionCollection.isEmpty(); + var visibleVisualRows = []; + var conditions = this.conditionCollection.exportAllConditions(); + var allowFiltering = this.hot.runHooks('beforeFilter', conditions); + + if (allowFiltering !== false) { + if (needToFilter) { + var trimmedRows = []; + this.hot.batchExecution(function () { + _this5.filtersRowsMap.clear(); + + visibleVisualRows = arrayMap(dataFilter.filter(), function (rowData) { + return rowData.meta.visualRow; + }); + var visibleVisualRowsAssertion = createArrayAssertion(visibleVisualRows); + rangeEach(_this5.hot.countSourceRows() - 1, function (row) { + if (!visibleVisualRowsAssertion(row)) { + trimmedRows.push(row); + } + }); + arrayEach(trimmedRows, function (physicalRow) { + _this5.filtersRowsMap.setValueAtIndex(physicalRow, true); + }); + }, true); + + if (!visibleVisualRows.length) { + this.hot.deselectCell(); + } + } else { + this.filtersRowsMap.clear(); + } + } + + this.hot.runHooks('afterFilter', conditions); + this.hot.view.adjustElementsSize(true); + this.hot.render(); + this.clearColumnSelection(); + } + /** + * Gets last selected column index. + * + * @returns {object|null} Return `null` when column isn't selected otherwise + * object containing information about selected column with keys `visualIndex` and `physicalIndex`. + */ + + }, { + key: "getSelectedColumn", + value: function getSelectedColumn() { + return this.lastSelectedColumn; + } + /** + * Clears column selection. + * + * @private + */ + + }, { + key: "clearColumnSelection", + value: function clearColumnSelection() { + var _this$hot$getSelected; + + var coords = (_this$hot$getSelected = this.hot.getSelectedRangeLast()) === null || _this$hot$getSelected === void 0 ? void 0 : _this$hot$getSelected.getTopLeftCorner(); + + if (coords !== void 0) { + this.hot.selectCell(coords.row, coords.col); + } + } + /** + * Returns handsontable source data with cell meta based on current selection. + * + * @param {number} [column] The physical column index. By default column index accept the value of the selected column. + * @returns {Array} Returns array of objects where keys as row index. + */ + + }, { + key: "getDataMapAtColumn", + value: function getDataMapAtColumn(column) { + var _this6 = this; + + var visualIndex = this.hot.toVisualColumn(column); + var data = []; + arrayEach(this.hot.getSourceDataAtCol(visualIndex), function (value, rowIndex) { + var _this6$hot$getCellMet = _this6.hot.getCellMeta(rowIndex, visualIndex), + row = _this6$hot$getCellMet.row, + col = _this6$hot$getCellMet.col, + visualCol = _this6$hot$getCellMet.visualCol, + visualRow = _this6$hot$getCellMet.visualRow, + type = _this6$hot$getCellMet.type, + instance = _this6$hot$getCellMet.instance, + dateFormat = _this6$hot$getCellMet.dateFormat; + + data.push({ + meta: { + row: row, + col: col, + visualCol: visualCol, + visualRow: visualRow, + type: type, + instance: instance, + dateFormat: dateFormat + }, + value: toEmptyString(value) + }); + }); + return data; + } + /** + * `afterChange` listener. + * + * @private + * @param {Array} changes Array of changes. + */ + + }, { + key: "onAfterChange", + value: function onAfterChange(changes) { + var _this7 = this; + + if (changes) { + arrayEach(changes, function (change) { + var _change = _slicedToArray$H(change, 2), + prop = _change[1]; + + var columnIndex = _this7.hot.propToCol(prop); + + if (_this7.conditionCollection.hasConditions(columnIndex)) { + _this7.updateValueComponentCondition(columnIndex); + } + }); + } + } + /** + * Update condition of ValueComponent basing on handled changes. + * + * @private + * @param {number} columnIndex Column index of handled ValueComponent condition. + */ + + }, { + key: "updateValueComponentCondition", + value: function updateValueComponentCondition(columnIndex) { + var dataAtCol = this.hot.getDataAtCol(columnIndex); + var selectedValues = unifyColumnValues(dataAtCol); + this.conditionUpdateObserver.updateStatesAtColumn(columnIndex, selectedValues); + } + /** + * Restores components to its saved state. + * + * @private + * @param {Array} components List of components. + */ + + }, { + key: "restoreComponents", + value: function restoreComponents(components) { + var _this$getSelectedColu; + + var physicalIndex = (_this$getSelectedColu = this.getSelectedColumn()) === null || _this$getSelectedColu === void 0 ? void 0 : _this$getSelectedColu.physicalIndex; + components.forEach(function (component) { + if (component.isHidden()) { + return; + } + + component.restoreState(physicalIndex); + }); + this.updateDependentComponentsVisibility(); + } + /** + * After dropdown menu show listener. + * + * @private + */ + + }, { + key: "onAfterDropdownMenuShow", + value: function onAfterDropdownMenuShow() { + this.restoreComponents(Array.from(this.components.values())); + } + /** + * After dropdown menu hide listener. + * + * @private + */ + + }, { + key: "onAfterDropdownMenuHide", + value: function onAfterDropdownMenuHide() { + this.components.get('filter_by_condition').getSelectElement().closeOptions(); + this.components.get('filter_by_condition2').getSelectElement().closeOptions(); + } + /** + * Before dropdown menu set menu items listener. + * + * @private + */ + + }, { + key: "onBeforeDropdownMenuSetItems", + value: function onBeforeDropdownMenuSetItems() { + var _this8 = this; + + if (this.dropdownMenuPlugin) { + this.dropdownMenuPlugin.menu.addLocalHook('afterOpen', function () { + _this8.dropdownMenuPlugin.menu.hotMenu.updateSettings({ + hiddenRows: true + }); + }); + } + } + /** + * After dropdown menu default options listener. + * + * @private + * @param {object} defaultOptions ContextMenu default item options. + */ + + }, { + key: "onAfterDropdownMenuDefaultOptions", + value: function onAfterDropdownMenuDefaultOptions(defaultOptions) { + defaultOptions.items.push({ + name: KEY + }); + this.components.forEach(function (component) { + defaultOptions.items.push(component.getMenuItemDescriptor()); + }); + } + /** + * Get operation basing on number and type of arguments (where arguments are states of components). + * + * @param {string} suggestedOperation Operation which was chosen by user from UI. + * @param {object} byConditionState1 State of first condition component. + * @param {object} byConditionState2 State of second condition component. + * @param {object} byValueState State of value component. + * @private + * @returns {string} + */ + + }, { + key: "getOperationBasedOnArguments", + value: function getOperationBasedOnArguments(suggestedOperation, byConditionState1, byConditionState2, byValueState) { + var operation = suggestedOperation; + + if (operation === OPERATION_ID$1 && byConditionState1.command.key !== CONDITION_NAME && byConditionState2.command.key !== CONDITION_NAME && byValueState.command.key !== CONDITION_NAME) { + operation = OPERATION_ID$2; + } else if (byValueState.command.key !== CONDITION_NAME) { + if (byConditionState1.command.key === CONDITION_NAME || byConditionState2.command.key === CONDITION_NAME) { + operation = OPERATION_ID; + } + } + + return operation; + } + /** + * On action bar submit listener. + * + * @private + * @param {string} submitType The submit type. + */ + + }, { + key: "onActionBarSubmit", + value: function onActionBarSubmit(submitType) { + if (submitType === 'accept') { + var _this$getSelectedColu2; + + var physicalIndex = (_this$getSelectedColu2 = this.getSelectedColumn()) === null || _this$getSelectedColu2 === void 0 ? void 0 : _this$getSelectedColu2.physicalIndex; + var byConditionState1 = this.components.get('filter_by_condition').getState(); + var byConditionState2 = this.components.get('filter_by_condition2').getState(); + var byValueState = this.components.get('filter_by_value').getState(); + var operation = this.getOperationBasedOnArguments(this.components.get('filter_operators').getActiveOperationId(), byConditionState1, byConditionState2, byValueState); + this.conditionUpdateObserver.groupChanges(); + var columnStackPosition = this.conditionCollection.getColumnStackPosition(physicalIndex); + + if (columnStackPosition === -1) { + columnStackPosition = void 0; + } + + this.conditionCollection.removeConditions(physicalIndex); + + if (byConditionState1.command.key !== CONDITION_NAME) { + this.conditionCollection.addCondition(physicalIndex, byConditionState1, operation, columnStackPosition); + + if (byConditionState2.command.key !== CONDITION_NAME) { + this.conditionCollection.addCondition(physicalIndex, byConditionState2, operation, columnStackPosition); + } + } + + if (byValueState.command.key !== CONDITION_NAME) { + this.conditionCollection.addCondition(physicalIndex, byValueState, operation, columnStackPosition); + } + + this.conditionUpdateObserver.flush(); + this.components.forEach(function (component) { + return component.saveState(physicalIndex); + }); + this.filtersRowsMap.clear(); + this.filter(); + } + + if (this.dropdownMenuPlugin) { + this.dropdownMenuPlugin.close(); + } + } + /** + * On component change listener. + * + * @private + * @param {BaseComponent} component Component inheriting BaseComponent. + * @param {object} command Menu item object (command). + */ + + }, { + key: "onComponentChange", + value: function onComponentChange(component, command) { + this.updateDependentComponentsVisibility(); + + if (component.constructor === ConditionComponent && !command.inputsCount) { + this.setListeningDropdownMenu(); + } + } + /** + * On component SelectUI closed listener. + * + * @private + */ + + }, { + key: "onSelectUIClosed", + value: function onSelectUIClosed() { + this.setListeningDropdownMenu(); + } + /** + * Listen to the keyboard input on document body and forward events to instance of Handsontable + * created by DropdownMenu plugin. + * + * @private + */ + + }, { + key: "setListeningDropdownMenu", + value: function setListeningDropdownMenu() { + if (this.dropdownMenuPlugin) { + this.dropdownMenuPlugin.setListening(); + } + } + /** + * Updates visibility of the some of the components based on the state of the parent component. + * + * @private + */ + + }, { + key: "updateDependentComponentsVisibility", + value: function updateDependentComponentsVisibility() { + var component = this.components.get('filter_by_condition'); + + var _component$getState = component.getState(), + command = _component$getState.command; + + var componentsToShow = [this.components.get('filter_by_condition2'), this.components.get('filter_operators')]; + + if (command.showOperators) { + this.showComponents.apply(this, componentsToShow); + } else { + this.hideComponents.apply(this, componentsToShow); + } + } + /** + * On after get column header listener. + * + * @private + * @param {number} col Visual column index. + * @param {HTMLTableCellElement} TH Header's TH element. + */ + + }, { + key: "onAfterGetColHeader", + value: function onAfterGetColHeader(col, TH) { + var physicalColumn = this.hot.toPhysicalColumn(col); + + if (this.enabled && this.conditionCollection.hasConditions(physicalColumn)) { + addClass(TH, 'htFiltersActive'); + } else { + removeClass(TH, 'htFiltersActive'); + } + } + /** + * On table click listener. + * + * @private + * @param {Event} event DOM Event. + */ + + }, { + key: "onTableClick", + value: function onTableClick(event) { + var th = closest(event.target, 'TH'); + + if (th) { + var visualIndex = this.hot.getCoords(th).col; + var physicalIndex = this.hot.toPhysicalColumn(visualIndex); + this.lastSelectedColumn = { + visualIndex: visualIndex, + physicalIndex: physicalIndex + }; + } + } + /** + * Creates DataFilter instance based on condition collection. + * + * @private + * @param {ConditionCollection} conditionCollection Condition collection object. + * @returns {DataFilter} + */ + + }, { + key: "_createDataFilter", + value: function _createDataFilter() { + var _this9 = this; + + var conditionCollection = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.conditionCollection; + return new DataFilter(conditionCollection, function (physicalColumn) { + return _this9.getDataMapAtColumn(physicalColumn); + }); + } + /** + * It updates the components state. The state is triggered by ConditionUpdateObserver, which + * reacts to any condition added to the condition collection. It may be added through the UI + * components or by API call. + * + * @private + * @param {object} conditionsState An object with the state generated by UI components. + */ + + }, { + key: "updateComponents", + value: function updateComponents(conditionsState) { + var _this$dropdownMenuPlu2; + + if (!((_this$dropdownMenuPlu2 = this.dropdownMenuPlugin) !== null && _this$dropdownMenuPlu2 !== void 0 && _this$dropdownMenuPlu2.enabled)) { + return; + } + + var _conditionsState$edit = conditionsState.editedConditionStack, + conditions = _conditionsState$edit.conditions, + column = _conditionsState$edit.column; + var conditionsByValue = conditions.filter(function (condition) { + return condition.name === CONDITION_NAME$k; + }); + var conditionsWithoutByValue = conditions.filter(function (condition) { + return condition.name !== CONDITION_NAME$k; + }); + + if (conditionsByValue.length >= 2 || conditionsWithoutByValue.length >= 3) { + warn(toSingleLine(_templateObject$b || (_templateObject$b = _taggedTemplateLiteral$b(["The filter conditions have been applied properly, but couldn\u2019t be displayed visually. \n The overall amount of conditions exceed the capability of the dropdown menu. \n For more details see the documentation."], ["The filter conditions have been applied properly, but couldn\u2019t be displayed visually.\\x20\n The overall amount of conditions exceed the capability of the dropdown menu.\\x20\n For more details see the documentation."])))); + } else { + var operationType = this.conditionCollection.getOperation(column); + this.components.get('filter_by_condition').updateState(conditionsWithoutByValue[0], column); + this.components.get('filter_by_condition2').updateState(conditionsWithoutByValue[1], column); + this.components.get('filter_operators').updateState(operationType, column); + this.components.get('filter_by_value').updateState(conditionsState); + } + } + /** + * Returns indexes of passed components inside list of `dropdownMenu` items. + * + * @private + * @param {...BaseComponent} components List of components. + * @returns {Array} + */ + + }, { + key: "getIndexesOfComponents", + value: function getIndexesOfComponents() { + var indexes = []; + + if (!this.dropdownMenuPlugin) { + return indexes; + } + + var menu = this.dropdownMenuPlugin.menu; + + for (var _len = arguments.length, components = new Array(_len), _key = 0; _key < _len; _key++) { + components[_key] = arguments[_key]; + } + + arrayEach(components, function (component) { + arrayEach(menu.menuItems, function (item, index) { + if (item.key === component.getMenuItemDescriptor().key) { + indexes.push(index); + } + }); + }); + return indexes; + } + /** + * Changes visibility of component. + * + * @private + * @param {boolean} visible Determine if components should be visible. + * @param {...BaseComponent} components List of components. + */ + + }, { + key: "changeComponentsVisibility", + value: function changeComponentsVisibility() { + var visible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + if (!this.dropdownMenuPlugin) { + return; + } + + var menu = this.dropdownMenuPlugin.menu; + var hotMenu = menu.hotMenu; + var hiddenRows = hotMenu.getPlugin('hiddenRows'); + + for (var _len2 = arguments.length, components = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + components[_key2 - 1] = arguments[_key2]; + } + + var indexes = this.getIndexesOfComponents.apply(this, components); + + if (visible) { + hiddenRows.showRows(indexes); + } else { + hiddenRows.hideRows(indexes); + } + + hotMenu.render(); + } + /** + * Hides components of filters `dropdownMenu`. + * + * @private + * @param {...BaseComponent} components List of components. + */ + + }, { + key: "hideComponents", + value: function hideComponents() { + for (var _len3 = arguments.length, components = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + components[_key3] = arguments[_key3]; + } + + this.changeComponentsVisibility.apply(this, [false].concat(components)); + } + /** + * Shows components of filters `dropdownMenu`. + * + * @private + * @param {...BaseComponent} components List of components. + */ + + }, { + key: "showComponents", + value: function showComponents() { + for (var _len4 = arguments.length, components = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { + components[_key4] = arguments[_key4]; + } + + this.changeComponentsVisibility.apply(this, [true].concat(components)); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + var _this10 = this; + + if (this.enabled) { + this.components.forEach(function (component, key) { + if (component !== null) { + component.destroy(); + + _this10.components.set(key, null); + } + }); + this.conditionCollection.destroy(); + this.conditionUpdateObserver.destroy(); + this.hot.rowIndexMapper.unregisterMap(this.pluginName); + } + + _get$M(_getPrototypeOf$1c(Filters.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$r; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$p; + } + }, { + key: "PLUGIN_DEPS", + get: function get() { + return ['plugin:DropdownMenu', 'plugin:HiddenRows', 'cell-type:checkbox']; + } + }]); + + return Filters; +}(BasePlugin); + +/** + * Check if provided expression is valid formula expression. + * + * @param {*} expression Expression to check. + * @returns {boolean} + */ +function isFormulaExpression(expression) { + return typeof expression === 'string' && expression.length >= 2 && expression.charAt(0) === '='; +} +/** + * Check if provided formula expression is escaped. + * + * @param {*} expression Expression to check. + * @returns {boolean} + */ + +function isFormulaExpressionEscaped(expression) { + return typeof expression === 'string' && expression.charAt(0) === '\'' && expression.charAt(1) === '='; +} +/** + * Replace escaped formula expression into valid string. + * + * @param {string} expression Expression to process. + * @returns {string} + */ + +function unescapeFormulaExpression(expression) { + return isFormulaExpressionEscaped(expression) ? expression.substr(1) : expression; +} +/** + * Upper case formula expression. + * + * @param {string} expression Formula expression. + * @returns {string} + */ + +function toUpperCaseFormula(expression) { + var PATTERN = /(\\"|"(?:\\"|[^"])*"|(\+))|(\\'|'(?:\\'|[^'])*'|(\+))/g; + var strings = expression.match(PATTERN) || []; + var index = -1; + return expression.toUpperCase().replace(PATTERN, function () { + index += 1; + return strings[index]; + }); +} +/** + * Cell coordinates function factory. + * + * @param {string} axis An axis name (`row` or `column`) which default index will be applied to. + * @param {number} defaultIndex Default index. + * @returns {Function} + */ + +function cellCoordFactory(axis, defaultIndex) { + return function (cell) { + return { + row: axis === 'row' ? defaultIndex : cell.row, + column: axis === 'column' ? defaultIndex : cell.column + }; + }; +} + +function E () { + // Keep this empty so it's easier to inherit from + // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3) +} + +E.prototype = { + on: function (name, callback, ctx) { + var e = this.e || (this.e = {}); + + (e[name] || (e[name] = [])).push({ + fn: callback, + ctx: ctx + }); + + return this; + }, + + once: function (name, callback, ctx) { + var self = this; + function listener () { + self.off(name, listener); + callback.apply(ctx, arguments); + } + listener._ = callback; + return this.on(name, listener, ctx); + }, + + emit: function (name) { + var data = [].slice.call(arguments, 1); + var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); + var i = 0; + var len = evtArr.length; + + for (i; i < len; i++) { + evtArr[i].fn.apply(evtArr[i].ctx, data); + } + + return this; + }, + + off: function (name, callback) { + var e = this.e || (this.e = {}); + var evts = e[name]; + var liveEvents = []; + + if (evts && callback) { + for (var i = 0, len = evts.length; i < len; i++) { + if (evts[i].fn !== callback && evts[i].fn._ !== callback) + liveEvents.push(evts[i]); + } + } + + // Remove event from queue to prevent memory leak + // Suggested by https://github.com/lazd + // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910 + + (liveEvents.length) + ? e[name] = liveEvents + : delete e[name]; + + return this; + } +}; + +var tinyEmitter = E; +var TinyEmitter = E; +tinyEmitter.TinyEmitter = TinyEmitter; + +var number = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.toNumber = toNumber; +exports.invertNumber = invertNumber; + +/** + * Convert value into number. + * + * @param {String|Number} number + * @returns {*} + */ +function toNumber(number) { + var result; + + if (typeof number === 'number') { + result = number; + } else if (typeof number === 'string') { + result = number.indexOf('.') > -1 ? parseFloat(number) : parseInt(number, 10); + } + + return result; +} +/** + * Invert provided number. + * + * @param {Number} number + * @returns {Number} Returns inverted number. + */ + + +function invertNumber(number) { + return -1 * toNumber(number); +} +}); + +var error_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = error; +exports.isValidStrict = isValidStrict; +exports.ERROR_VALUE = exports.ERROR_REF = exports.ERROR_NUM = exports.ERROR_NULL = exports.ERROR_NOT_AVAILABLE = exports.ERROR_NAME = exports.ERROR_DIV_ZERO = exports.ERROR = void 0; + +var _errors; + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var ERROR = 'ERROR'; +exports.ERROR = ERROR; +var ERROR_DIV_ZERO = 'DIV/0'; +exports.ERROR_DIV_ZERO = ERROR_DIV_ZERO; +var ERROR_NAME = 'NAME'; +exports.ERROR_NAME = ERROR_NAME; +var ERROR_NOT_AVAILABLE = 'N/A'; +exports.ERROR_NOT_AVAILABLE = ERROR_NOT_AVAILABLE; +var ERROR_NULL = 'NULL'; +exports.ERROR_NULL = ERROR_NULL; +var ERROR_NUM = 'NUM'; +exports.ERROR_NUM = ERROR_NUM; +var ERROR_REF = 'REF'; +exports.ERROR_REF = ERROR_REF; +var ERROR_VALUE = 'VALUE'; +exports.ERROR_VALUE = ERROR_VALUE; +var errors = (_errors = {}, _defineProperty(_errors, ERROR, '#ERROR!'), _defineProperty(_errors, ERROR_DIV_ZERO, '#DIV/0!'), _defineProperty(_errors, ERROR_NAME, '#NAME?'), _defineProperty(_errors, ERROR_NOT_AVAILABLE, '#N/A'), _defineProperty(_errors, ERROR_NULL, '#NULL!'), _defineProperty(_errors, ERROR_NUM, '#NUM!'), _defineProperty(_errors, ERROR_REF, '#REF!'), _defineProperty(_errors, ERROR_VALUE, '#VALUE!'), _errors); +/** + * Return error type based on provided error id. + * + * @param {String} type Error type. + * @returns {String|null} Returns error id. + */ + +function error(type) { + var result; + type = (type + '').replace(/#|!|\?/g, ''); + + if (errors[type]) { + result = errors[type]; + } + + return result ? result : null; +} +/** + * Check if error type is strict valid with knows errors. + * + * @param {String} Error type. + * @return {Boolean} + */ + + +function isValidStrict(type) { + var valid = false; + + for (var i in errors) { + if (Object.prototype.hasOwnProperty.call(errors, i) && errors[i] === type) { + valid = true; + break; + } + } + + return valid; +} +}); + +var add = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; + + + + + +var SYMBOL = '+'; +exports.SYMBOL = SYMBOL; + +function func(first) { + for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + rest[_key - 1] = arguments[_key]; + } + + var result = rest.reduce(function (acc, value) { + return acc + (0, number.toNumber)(value); + }, (0, number.toNumber)(first)); + + if (isNaN(result)) { + throw Error(error_1.ERROR_VALUE); + } + + return result; +} + +func.SYMBOL = SYMBOL; +}); + +var ampersand = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; +var SYMBOL = '&'; +exports.SYMBOL = SYMBOL; + +function func() { + for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) { + params[_key] = arguments[_key]; + } + + return params.reduce(function (acc, value) { + return acc + value.toString(); + }, ''); +} + +func.SYMBOL = SYMBOL; +}); + +var divide$1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; + + + + + +var SYMBOL = '/'; +exports.SYMBOL = SYMBOL; + +function func(first) { + for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + rest[_key - 1] = arguments[_key]; + } + + var result = rest.reduce(function (acc, value) { + return acc / (0, number.toNumber)(value); + }, (0, number.toNumber)(first)); + + if (result === Infinity) { + throw Error(error_1.ERROR_DIV_ZERO); + } + + if (isNaN(result)) { + throw Error(error_1.ERROR_VALUE); + } + + return result; +} + +func.SYMBOL = SYMBOL; +}); + +var equal = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; +var SYMBOL = '='; +exports.SYMBOL = SYMBOL; + +function func(exp1, exp2) { + return exp1 === exp2; +} + +func.SYMBOL = SYMBOL; +}); + +var nil = new Error('#NULL!'); +var div0 = new Error('#DIV/0!'); +var value = new Error('#VALUE!'); +var ref = new Error('#REF!'); +var name = new Error('#NAME?'); +var num = new Error('#NUM!'); +var na = new Error('#N/A'); +var error_1$1 = new Error('#ERROR!'); +var data$1 = new Error('#GETTING_DATA'); + +var error$1 = { + nil: nil, + div0: div0, + value: value, + ref: ref, + name: name, + num: num, + na: na, + error: error_1$1, + data: data$1 +}; + +var common = createCommonjsModule(function (module, exports) { +exports.flattenShallow = function(array) { + if (!array || !array.reduce) { + return array; + } + + return array.reduce(function(a, b) { + var aIsArray = Array.isArray(a); + var bIsArray = Array.isArray(b); + + if (aIsArray && bIsArray ) { + return a.concat(b); + } + if (aIsArray) { + a.push(b); + + return a; + } + if (bIsArray) { + return [a].concat(b); + } + + return [a, b]; + }); +}; + +exports.isFlat = function(array) { + if (!array) { + return false; + } + + for (var i = 0; i < array.length; ++i) { + if (Array.isArray(array[i])) { + return false; + } + } + + return true; +}; + +exports.flatten = function() { + var result = exports.argsToArray.apply(null, arguments); + + while (!exports.isFlat(result)) { + result = exports.flattenShallow(result); + } + + return result; +}; + +exports.argsToArray = function(args) { + var result = []; + + exports.arrayEach(args, function(value) { + result.push(value); + }); + + return result; +}; + +exports.numbers = function() { + var possibleNumbers = this.flatten.apply(null, arguments); + return possibleNumbers.filter(function(el) { + return typeof el === 'number'; + }); +}; + +exports.cleanFloat = function(number) { + var power = 1e14; + return Math.round(number * power) / power; +}; + +exports.parseBool = function(bool) { + if (typeof bool === 'boolean') { + return bool; + } + + if (bool instanceof Error) { + return bool; + } + + if (typeof bool === 'number') { + return bool !== 0; + } + + if (typeof bool === 'string') { + var up = bool.toUpperCase(); + if (up === 'TRUE') { + return true; + } + + if (up === 'FALSE') { + return false; + } + } + + if (bool instanceof Date && !isNaN(bool)) { + return true; + } + + return error$1.value; +}; + +exports.parseNumber = function(string) { + if (string === undefined || string === '') { + return error$1.value; + } + if (!isNaN(string)) { + return parseFloat(string); + } + + return error$1.value; +}; + +exports.parseNumberArray = function(arr) { + var len; + + if (!arr || (len = arr.length) === 0) { + return error$1.value; + } + + var parsed; + + while (len--) { + parsed = exports.parseNumber(arr[len]); + if (parsed === error$1.value) { + return parsed; + } + arr[len] = parsed; + } + + return arr; +}; + +exports.parseMatrix = function(matrix) { + + if (!matrix || (matrix.length) === 0) { + return error$1.value; + } + var pnarr; + + for (var i = 0; i < matrix.length; i++) { + pnarr = exports.parseNumberArray(matrix[i]); + matrix[i] = pnarr; + + if (pnarr instanceof Error) { + return pnarr; + } + } + + return matrix; +}; + +var d1900 = new Date(Date.UTC(1900, 0, 1)); +exports.parseDate = function(date) { + if (!isNaN(date)) { + if (date instanceof Date) { + return new Date(date); + } + var d = parseInt(date, 10); + if (d < 0) { + return error$1.num; + } + if (d <= 60) { + return new Date(d1900.getTime() + (d - 1) * 86400000); + } + return new Date(d1900.getTime() + (d - 2) * 86400000); + } + if (typeof date === 'string') { + date = new Date(date); + if (!isNaN(date)) { + return date; + } + } + return error$1.value; +}; + +exports.parseDateArray = function(arr) { + var len = arr.length; + var parsed; + while (len--) { + parsed = this.parseDate(arr[len]); + if (parsed === error$1.value) { + return parsed; + } + arr[len] = parsed; + } + return arr; +}; + +exports.anyIsError = function() { + var n = arguments.length; + while (n--) { + if (arguments[n] instanceof Error) { + return true; + } + } + return false; +}; + +exports.arrayValuesToNumbers = function(arr) { + var n = arr.length; + var el; + while (n--) { + el = arr[n]; + if (typeof el === 'number') { + continue; + } + if (el === true) { + arr[n] = 1; + continue; + } + if (el === false) { + arr[n] = 0; + continue; + } + if (typeof el === 'string') { + var number = this.parseNumber(el); + if (number instanceof Error) { + arr[n] = 0; + } else { + arr[n] = number; + } + } + } + return arr; +}; + +exports.rest = function(array, idx) { + idx = idx || 1; + if (!array || typeof array.slice !== 'function') { + return array; + } + return array.slice(idx); +}; + +exports.initial = function(array, idx) { + idx = idx || 1; + if (!array || typeof array.slice !== 'function') { + return array; + } + return array.slice(0, array.length - idx); +}; + +exports.arrayEach = function(array, iteratee) { + var index = -1, length = array.length; + + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + + return array; +}; + +exports.transpose = function(matrix) { + if(!matrix) { + return error$1.value; + } + + return matrix[0].map(function(col, i) { + return matrix.map(function(row) { + return row[i]; + }); + }); +}; +}); + +var text$1 = createCommonjsModule(function (module, exports) { +//TODO +exports.ASC = function() { + throw new Error('ASC is not implemented'); +}; + +//TODO +exports.BAHTTEXT = function() { + throw new Error('BAHTTEXT is not implemented'); +}; + +exports.CHAR = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return String.fromCharCode(number); +}; + +exports.CLEAN = function(text) { + text = text || ''; + var re = /[\0-\x1F]/g; + return text.replace(re, ""); +}; + +exports.CODE = function(text) { + text = text || ''; + var result = text.charCodeAt(0); + + if (isNaN(result)) { + result = error$1.na; + } + return result; +}; + +exports.CONCATENATE = function() { + var args = common.flatten(arguments); + + var trueFound = 0; + while ((trueFound = args.indexOf(true)) > -1) { + args[trueFound] = 'TRUE'; + } + + var falseFound = 0; + while ((falseFound = args.indexOf(false)) > -1) { + args[falseFound] = 'FALSE'; + } + + return args.join(''); +}; + +//TODO +exports.DBCS = function() { + throw new Error('DBCS is not implemented'); +}; + +//TODO +exports.DOLLAR = function() { + throw new Error('DOLLAR is not implemented'); +}; + +exports.EXACT = function(text1, text2) { + if (arguments.length !== 2) { + return error$1.na; + } + return text1 === text2; +}; + +exports.FIND = function(find_text, within_text, position) { + if (arguments.length < 2) { + return error$1.na; + } + position = (position === undefined) ? 0 : position; + return within_text ? within_text.indexOf(find_text, position - 1) + 1 : null; +}; + +//TODO +exports.FIXED = function() { + throw new Error('FIXED is not implemented'); +}; + +exports.HTML2TEXT = function (value) { + var result = ''; + + if (value) { + if (value instanceof Array) { + value.forEach(function (line) { + if (result !== '') { + result += '\n'; + } + result += (line.replace(/<(?:.|\n)*?>/gm, '')); + }); + } else { + result = value.replace(/<(?:.|\n)*?>/gm, ''); + } + } + + return result; +}; + +exports.LEFT = function(text, number) { + number = (number === undefined) ? 1 : number; + number = common.parseNumber(number); + if (number instanceof Error || typeof text !== 'string') { + return error$1.value; + } + return text ? text.substring(0, number) : null; +}; + +exports.LEN = function(text) { + if (arguments.length === 0) { + return error$1.error; + } + + if (typeof text === 'string') { + return text ? text.length : 0; + } + + if (text.length) { + return text.length; + } + + return error$1.value; +}; + +exports.LOWER = function(text) { + if (typeof text !== 'string') { + return error$1.value; + } + return text ? text.toLowerCase() : text; +}; + +exports.MID = function(text, start, number) { + start = common.parseNumber(start); + number = common.parseNumber(number); + if (common.anyIsError(start, number) || typeof text !== 'string') { + return number; + } + + var begin = start - 1; + var end = begin + number; + + return text.substring(begin, end); +}; + +// TODO +exports.NUMBERVALUE = function (text, decimal_separator, group_separator) { + decimal_separator = (typeof decimal_separator === 'undefined') ? '.' : decimal_separator; + group_separator = (typeof group_separator === 'undefined') ? ',' : group_separator; + return Number(text.replace(decimal_separator, '.').replace(group_separator, '')); +}; + +// TODO +exports.PRONETIC = function() { + throw new Error('PRONETIC is not implemented'); +}; + +exports.PROPER = function(text) { + if (text === undefined || text.length === 0) { + return error$1.value; + } + if (text === true) { + text = 'TRUE'; + } + if (text === false) { + text = 'FALSE'; + } + if (isNaN(text) && typeof text === 'number') { + return error$1.value; + } + if (typeof text === 'number') { + text = '' + text; + } + + return text.replace(/\w\S*/g, function(txt) { + return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase(); + }); +}; + +exports.REGEXEXTRACT = function (text, regular_expression) { + if (arguments.length < 2) { + return error$1.na; + } + var match = text.match(new RegExp(regular_expression)); + return match ? (match[match.length > 1 ? match.length - 1 : 0]) : null; +}; + +exports.REGEXMATCH = function (text, regular_expression, full) { + if (arguments.length < 2) { + return error$1.na; + } + var match = text.match(new RegExp(regular_expression)); + return full ? match : !!match; +}; + +exports.REGEXREPLACE = function (text, regular_expression, replacement) { + if (arguments.length < 3) { + return error$1.na; + } + return text.replace(new RegExp(regular_expression), replacement); +}; + +exports.REPLACE = function(text, position, length, new_text) { + position = common.parseNumber(position); + length = common.parseNumber(length); + if (common.anyIsError(position, length) || + typeof text !== 'string' || + typeof new_text !== 'string') { + return error$1.value; + } + return text.substr(0, position - 1) + new_text + text.substr(position - 1 + length); +}; + +exports.REPT = function(text, number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return new Array(number + 1).join(text); +}; + +exports.RIGHT = function(text, number) { + number = (number === undefined) ? 1 : number; + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return text ? text.substring(text.length - number) : error$1.na; +}; + +exports.SEARCH = function(find_text, within_text, position) { + var foundAt; + if (typeof find_text !== 'string' || typeof within_text !== 'string') { + return error$1.value; + } + position = (position === undefined) ? 0 : position; + foundAt = within_text.toLowerCase().indexOf(find_text.toLowerCase(), position - 1)+1; + return (foundAt === 0)?error$1.value:foundAt; +}; + +exports.SPLIT = function (text, separator) { + return text.split(separator); +}; + +exports.SUBSTITUTE = function(text, old_text, new_text, occurrence) { + if (arguments.length < 2) { + return error$1.na; + } + if (!text || !old_text || !new_text) { + return text; + } else if (occurrence === undefined) { + return text.replace(new RegExp(old_text, 'g'), new_text); + } else { + var index = 0; + var i = 0; + while (text.indexOf(old_text, index) > 0) { + index = text.indexOf(old_text, index + 1); + i++; + if (i === occurrence) { + return text.substring(0, index) + new_text + text.substring(index + old_text.length); + } + } + } +}; + +exports.T = function(value) { + return (typeof value === "string") ? value : ''; +}; + +// TODO incomplete implementation +exports.TEXT = function() { + throw new Error('TEXT is not implemented'); +}; + +exports.TRIM = function(text) { + if (typeof text !== 'string') { + return error$1.value; + } + return text.replace(/ +/g, ' ').trim(); +}; + +exports.UNICHAR = exports.CHAR; + +exports.UNICODE = exports.CODE; + +exports.UPPER = function(text) { + if (typeof text !== 'string') { + return error$1.value; + } + return text.toUpperCase(); +}; + +//TODO +exports.VALUE = function() { + throw new Error('VALUE is not implemented'); +}; +}); + +var jstat = createCommonjsModule(function (module, exports) { +(function (window, factory) { + { + module.exports = factory(); + } +})(commonjsGlobal, function () { +var jStat = (function(Math, undefined$1) { + +// For quick reference. +var concat = Array.prototype.concat; +var slice = Array.prototype.slice; +var toString = Object.prototype.toString; + +// Calculate correction for IEEE error +// TODO: This calculation can be improved. +function calcRdx(n, m) { + var val = n > m ? n : m; + return Math.pow(10, + 17 - ~~(Math.log(((val > 0) ? val : -val)) * Math.LOG10E)); +} + + +var isArray = Array.isArray || function isArray(arg) { + return toString.call(arg) === '[object Array]'; +}; + + +function isFunction(arg) { + return toString.call(arg) === '[object Function]'; +} + + +function isNumber(num) { + return (typeof num === 'number') ? num - num === 0 : false; +} + + +// Converts the jStat matrix to vector. +function toVector(arr) { + return concat.apply([], arr); +} + + +// The one and only jStat constructor. +function jStat() { + return new jStat._init(arguments); +} + + +// TODO: Remove after all references in src files have been removed. +jStat.fn = jStat.prototype; + + +// By separating the initializer from the constructor it's easier to handle +// always returning a new instance whether "new" was used or not. +jStat._init = function _init(args) { + // If first argument is an array, must be vector or matrix. + if (isArray(args[0])) { + // Check if matrix. + if (isArray(args[0][0])) { + // See if a mapping function was also passed. + if (isFunction(args[1])) + args[0] = jStat.map(args[0], args[1]); + // Iterate over each is faster than this.push.apply(this, args[0]. + for (var i = 0; i < args[0].length; i++) + this[i] = args[0][i]; + this.length = args[0].length; + + // Otherwise must be a vector. + } else { + this[0] = isFunction(args[1]) ? jStat.map(args[0], args[1]) : args[0]; + this.length = 1; + } + + // If first argument is number, assume creation of sequence. + } else if (isNumber(args[0])) { + this[0] = jStat.seq.apply(null, args); + this.length = 1; + + // Handle case when jStat object is passed to jStat. + } else if (args[0] instanceof jStat) { + // Duplicate the object and pass it back. + return jStat(args[0].toArray()); + + // Unexpected argument value, return empty jStat object. + // TODO: This is strange behavior. Shouldn't this throw or some such to let + // the user know they had bad arguments? + } else { + this[0] = []; + this.length = 1; + } + + return this; +}; +jStat._init.prototype = jStat.prototype; +jStat._init.constructor = jStat; + + +// Utility functions. +// TODO: for internal use only? +jStat.utils = { + calcRdx: calcRdx, + isArray: isArray, + isFunction: isFunction, + isNumber: isNumber, + toVector: toVector +}; + + +jStat._random_fn = Math.random; +jStat.setRandom = function setRandom(fn) { + if (typeof fn !== 'function') + throw new TypeError('fn is not a function'); + jStat._random_fn = fn; +}; + + +// Easily extend the jStat object. +// TODO: is this seriously necessary? +jStat.extend = function extend(obj) { + var i, j; + + if (arguments.length === 1) { + for (j in obj) + jStat[j] = obj[j]; + return this; + } + + for (i = 1; i < arguments.length; i++) { + for (j in arguments[i]) + obj[j] = arguments[i][j]; + } + + return obj; +}; + + +// Returns the number of rows in the matrix. +jStat.rows = function rows(arr) { + return arr.length || 1; +}; + + +// Returns the number of columns in the matrix. +jStat.cols = function cols(arr) { + return arr[0].length || 1; +}; + + +// Returns the dimensions of the object { rows: i, cols: j } +jStat.dimensions = function dimensions(arr) { + return { + rows: jStat.rows(arr), + cols: jStat.cols(arr) + }; +}; + + +// Returns a specified row as a vector or return a sub matrix by pick some rows +jStat.row = function row(arr, index) { + if (isArray(index)) { + return index.map(function(i) { + return jStat.row(arr, i); + }) + } + return arr[index]; +}; + + +// return row as array +// rowa([[1,2],[3,4]],0) -> [1,2] +jStat.rowa = function rowa(arr, i) { + return jStat.row(arr, i); +}; + + +// Returns the specified column as a vector or return a sub matrix by pick some +// columns +jStat.col = function col(arr, index) { + if (isArray(index)) { + var submat = jStat.arange(arr.length).map(function() { + return new Array(index.length); + }); + index.forEach(function(ind, i){ + jStat.arange(arr.length).forEach(function(j) { + submat[j][i] = arr[j][ind]; + }); + }); + return submat; + } + var column = new Array(arr.length); + for (var i = 0; i < arr.length; i++) + column[i] = [arr[i][index]]; + return column; +}; + + +// return column as array +// cola([[1,2],[3,4]],0) -> [1,3] +jStat.cola = function cola(arr, i) { + return jStat.col(arr, i).map(function(a){ return a[0] }); +}; + + +// Returns the diagonal of the matrix +jStat.diag = function diag(arr) { + var nrow = jStat.rows(arr); + var res = new Array(nrow); + for (var row = 0; row < nrow; row++) + res[row] = [arr[row][row]]; + return res; +}; + + +// Returns the anti-diagonal of the matrix +jStat.antidiag = function antidiag(arr) { + var nrow = jStat.rows(arr) - 1; + var res = new Array(nrow); + for (var i = 0; nrow >= 0; nrow--, i++) + res[i] = [arr[i][nrow]]; + return res; +}; + +// Transpose a matrix or array. +jStat.transpose = function transpose(arr) { + var obj = []; + var objArr, rows, cols, j, i; + + // Make sure arr is in matrix format. + if (!isArray(arr[0])) + arr = [arr]; + + rows = arr.length; + cols = arr[0].length; + + for (i = 0; i < cols; i++) { + objArr = new Array(rows); + for (j = 0; j < rows; j++) + objArr[j] = arr[j][i]; + obj.push(objArr); + } + + // If obj is vector, return only single array. + return obj.length === 1 ? obj[0] : obj; +}; + + +// Map a function to an array or array of arrays. +// "toAlter" is an internal variable. +jStat.map = function map(arr, func, toAlter) { + var row, nrow, ncol, res, col; + + if (!isArray(arr[0])) + arr = [arr]; + + nrow = arr.length; + ncol = arr[0].length; + res = toAlter ? arr : new Array(nrow); + + for (row = 0; row < nrow; row++) { + // if the row doesn't exist, create it + if (!res[row]) + res[row] = new Array(ncol); + for (col = 0; col < ncol; col++) + res[row][col] = func(arr[row][col], row, col); + } + + return res.length === 1 ? res[0] : res; +}; + + +// Cumulatively combine the elements of an array or array of arrays using a function. +jStat.cumreduce = function cumreduce(arr, func, toAlter) { + var row, nrow, ncol, res, col; + + if (!isArray(arr[0])) + arr = [arr]; + + nrow = arr.length; + ncol = arr[0].length; + res = toAlter ? arr : new Array(nrow); + + for (row = 0; row < nrow; row++) { + // if the row doesn't exist, create it + if (!res[row]) + res[row] = new Array(ncol); + if (ncol > 0) + res[row][0] = arr[row][0]; + for (col = 1; col < ncol; col++) + res[row][col] = func(res[row][col-1], arr[row][col]); + } + return res.length === 1 ? res[0] : res; +}; + + +// Destructively alter an array. +jStat.alter = function alter(arr, func) { + return jStat.map(arr, func, true); +}; + + +// Generate a rows x cols matrix according to the supplied function. +jStat.create = function create(rows, cols, func) { + var res = new Array(rows); + var i, j; + + if (isFunction(cols)) { + func = cols; + cols = rows; + } + + for (i = 0; i < rows; i++) { + res[i] = new Array(cols); + for (j = 0; j < cols; j++) + res[i][j] = func(i, j); + } + + return res; +}; + + +function retZero() { return 0; } + + +// Generate a rows x cols matrix of zeros. +jStat.zeros = function zeros(rows, cols) { + if (!isNumber(cols)) + cols = rows; + return jStat.create(rows, cols, retZero); +}; + + +function retOne() { return 1; } + + +// Generate a rows x cols matrix of ones. +jStat.ones = function ones(rows, cols) { + if (!isNumber(cols)) + cols = rows; + return jStat.create(rows, cols, retOne); +}; + + +// Generate a rows x cols matrix of uniformly random numbers. +jStat.rand = function rand(rows, cols) { + if (!isNumber(cols)) + cols = rows; + return jStat.create(rows, cols, jStat._random_fn); +}; + + +function retIdent(i, j) { return i === j ? 1 : 0; } + + +// Generate an identity matrix of size row x cols. +jStat.identity = function identity(rows, cols) { + if (!isNumber(cols)) + cols = rows; + return jStat.create(rows, cols, retIdent); +}; + + +// Tests whether a matrix is symmetric +jStat.symmetric = function symmetric(arr) { + var size = arr.length; + var row, col; + + if (arr.length !== arr[0].length) + return false; + + for (row = 0; row < size; row++) { + for (col = 0; col < size; col++) + if (arr[col][row] !== arr[row][col]) + return false; + } + + return true; +}; + + +// Set all values to zero. +jStat.clear = function clear(arr) { + return jStat.alter(arr, retZero); +}; + + +// Generate sequence. +jStat.seq = function seq(min, max, length, func) { + if (!isFunction(func)) + func = false; + + var arr = []; + var hival = calcRdx(min, max); + var step = (max * hival - min * hival) / ((length - 1) * hival); + var current = min; + var cnt; + + // Current is assigned using a technique to compensate for IEEE error. + // TODO: Needs better implementation. + for (cnt = 0; + current <= max && cnt < length; + cnt++, current = (min * hival + step * hival * cnt) / hival) { + arr.push((func ? func(current, cnt) : current)); + } + + return arr; +}; + + +// arange(5) -> [0,1,2,3,4] +// arange(1,5) -> [1,2,3,4] +// arange(5,1,-1) -> [5,4,3,2] +jStat.arange = function arange(start, end, step) { + var rl = []; + var i; + step = step || 1; + if (end === undefined$1) { + end = start; + start = 0; + } + if (start === end || step === 0) { + return []; + } + if (start < end && step < 0) { + return []; + } + if (start > end && step > 0) { + return []; + } + if (step > 0) { + for (i = start; i < end; i += step) { + rl.push(i); + } + } else { + for (i = start; i > end; i += step) { + rl.push(i); + } + } + return rl; +}; + + +// A=[[1,2,3],[4,5,6],[7,8,9]] +// slice(A,{row:{end:2},col:{start:1}}) -> [[2,3],[5,6]] +// slice(A,1,{start:1}) -> [5,6] +// as numpy code A[:2,1:] +jStat.slice = (function(){ + function _slice(list, start, end, step) { + // note it's not equal to range.map mode it's a bug + var i; + var rl = []; + var length = list.length; + if (start === undefined$1 && end === undefined$1 && step === undefined$1) { + return jStat.copy(list); + } + + start = start || 0; + end = end || list.length; + start = start >= 0 ? start : length + start; + end = end >= 0 ? end : length + end; + step = step || 1; + if (start === end || step === 0) { + return []; + } + if (start < end && step < 0) { + return []; + } + if (start > end && step > 0) { + return []; + } + if (step > 0) { + for (i = start; i < end; i += step) { + rl.push(list[i]); + } + } else { + for (i = start; i > end;i += step) { + rl.push(list[i]); + } + } + return rl; + } + + function slice(list, rcSlice) { + var colSlice, rowSlice; + rcSlice = rcSlice || {}; + if (isNumber(rcSlice.row)) { + if (isNumber(rcSlice.col)) + return list[rcSlice.row][rcSlice.col]; + var row = jStat.rowa(list, rcSlice.row); + colSlice = rcSlice.col || {}; + return _slice(row, colSlice.start, colSlice.end, colSlice.step); + } + + if (isNumber(rcSlice.col)) { + var col = jStat.cola(list, rcSlice.col); + rowSlice = rcSlice.row || {}; + return _slice(col, rowSlice.start, rowSlice.end, rowSlice.step); + } + + rowSlice = rcSlice.row || {}; + colSlice = rcSlice.col || {}; + var rows = _slice(list, rowSlice.start, rowSlice.end, rowSlice.step); + return rows.map(function(row) { + return _slice(row, colSlice.start, colSlice.end, colSlice.step); + }); + } + + return slice; +}()); + + +// A=[[1,2,3],[4,5,6],[7,8,9]] +// sliceAssign(A,{row:{start:1},col:{start:1}},[[0,0],[0,0]]) +// A=[[1,2,3],[4,0,0],[7,0,0]] +jStat.sliceAssign = function sliceAssign(A, rcSlice, B) { + var nl, ml; + if (isNumber(rcSlice.row)) { + if (isNumber(rcSlice.col)) + return A[rcSlice.row][rcSlice.col] = B; + rcSlice.col = rcSlice.col || {}; + rcSlice.col.start = rcSlice.col.start || 0; + rcSlice.col.end = rcSlice.col.end || A[0].length; + rcSlice.col.step = rcSlice.col.step || 1; + nl = jStat.arange(rcSlice.col.start, + Math.min(A.length, rcSlice.col.end), + rcSlice.col.step); + var m = rcSlice.row; + nl.forEach(function(n, i) { + A[m][n] = B[i]; + }); + return A; + } + + if (isNumber(rcSlice.col)) { + rcSlice.row = rcSlice.row || {}; + rcSlice.row.start = rcSlice.row.start || 0; + rcSlice.row.end = rcSlice.row.end || A.length; + rcSlice.row.step = rcSlice.row.step || 1; + ml = jStat.arange(rcSlice.row.start, + Math.min(A[0].length, rcSlice.row.end), + rcSlice.row.step); + var n = rcSlice.col; + ml.forEach(function(m, j) { + A[m][n] = B[j]; + }); + return A; + } + + if (B[0].length === undefined$1) { + B = [B]; + } + rcSlice.row.start = rcSlice.row.start || 0; + rcSlice.row.end = rcSlice.row.end || A.length; + rcSlice.row.step = rcSlice.row.step || 1; + rcSlice.col.start = rcSlice.col.start || 0; + rcSlice.col.end = rcSlice.col.end || A[0].length; + rcSlice.col.step = rcSlice.col.step || 1; + ml = jStat.arange(rcSlice.row.start, + Math.min(A.length, rcSlice.row.end), + rcSlice.row.step); + nl = jStat.arange(rcSlice.col.start, + Math.min(A[0].length, rcSlice.col.end), + rcSlice.col.step); + ml.forEach(function(m, i) { + nl.forEach(function(n, j) { + A[m][n] = B[i][j]; + }); + }); + return A; +}; + + +// [1,2,3] -> +// [[1,0,0],[0,2,0],[0,0,3]] +jStat.diagonal = function diagonal(diagArray) { + var mat = jStat.zeros(diagArray.length, diagArray.length); + diagArray.forEach(function(t, i) { + mat[i][i] = t; + }); + return mat; +}; + + +// return copy of A +jStat.copy = function copy(A) { + return A.map(function(row) { + if (isNumber(row)) + return row; + return row.map(function(t) { + return t; + }); + }); +}; + + +// TODO: Go over this entire implementation. Seems a tragic waste of resources +// doing all this work. Instead, and while ugly, use new Function() to generate +// a custom function for each static method. + +// Quick reference. +var jProto = jStat.prototype; + +// Default length. +jProto.length = 0; + +// For internal use only. +// TODO: Check if they're actually used, and if they are then rename them +// to _* +jProto.push = Array.prototype.push; +jProto.sort = Array.prototype.sort; +jProto.splice = Array.prototype.splice; +jProto.slice = Array.prototype.slice; + + +// Return a clean array. +jProto.toArray = function toArray() { + return this.length > 1 ? slice.call(this) : slice.call(this)[0]; +}; + + +// Map a function to a matrix or vector. +jProto.map = function map(func, toAlter) { + return jStat(jStat.map(this, func, toAlter)); +}; + + +// Cumulatively combine the elements of a matrix or vector using a function. +jProto.cumreduce = function cumreduce(func, toAlter) { + return jStat(jStat.cumreduce(this, func, toAlter)); +}; + + +// Destructively alter an array. +jProto.alter = function alter(func) { + jStat.alter(this, func); + return this; +}; + + +// Extend prototype with methods that have no argument. +(function(funcs) { + for (var i = 0; i < funcs.length; i++) (function(passfunc) { + jProto[passfunc] = function(func) { + var self = this, + results; + // Check for callback. + if (func) { + setTimeout(function() { + func.call(self, jProto[passfunc].call(self)); + }); + return this; + } + results = jStat[passfunc](this); + return isArray(results) ? jStat(results) : results; + }; + })(funcs[i]); +})('transpose clear symmetric rows cols dimensions diag antidiag'.split(' ')); + + +// Extend prototype with methods that have one argument. +(function(funcs) { + for (var i = 0; i < funcs.length; i++) (function(passfunc) { + jProto[passfunc] = function(index, func) { + var self = this; + // check for callback + if (func) { + setTimeout(function() { + func.call(self, jProto[passfunc].call(self, index)); + }); + return this; + } + return jStat(jStat[passfunc](this, index)); + }; + })(funcs[i]); +})('row col'.split(' ')); + + +// Extend prototype with simple shortcut methods. +(function(funcs) { + for (var i = 0; i < funcs.length; i++) (function(passfunc) { + jProto[passfunc] = function() { + return jStat(jStat[passfunc].apply(null, arguments)); + }; + })(funcs[i]); +})('create zeros ones rand identity'.split(' ')); + + +// Exposing jStat. +return jStat; + +}(Math)); +(function(jStat, Math) { + +var isFunction = jStat.utils.isFunction; + +// Ascending functions for sort +function ascNum(a, b) { return a - b; } + +function clip(arg, min, max) { + return Math.max(min, Math.min(arg, max)); +} + + +// sum of an array +jStat.sum = function sum(arr) { + var sum = 0; + var i = arr.length; + while (--i >= 0) + sum += arr[i]; + return sum; +}; + + +// sum squared +jStat.sumsqrd = function sumsqrd(arr) { + var sum = 0; + var i = arr.length; + while (--i >= 0) + sum += arr[i] * arr[i]; + return sum; +}; + + +// sum of squared errors of prediction (SSE) +jStat.sumsqerr = function sumsqerr(arr) { + var mean = jStat.mean(arr); + var sum = 0; + var i = arr.length; + var tmp; + while (--i >= 0) { + tmp = arr[i] - mean; + sum += tmp * tmp; + } + return sum; +}; + +// sum of an array in each row +jStat.sumrow = function sumrow(arr) { + var sum = 0; + var i = arr.length; + while (--i >= 0) + sum += arr[i]; + return sum; +}; + +// product of an array +jStat.product = function product(arr) { + var prod = 1; + var i = arr.length; + while (--i >= 0) + prod *= arr[i]; + return prod; +}; + + +// minimum value of an array +jStat.min = function min(arr) { + var low = arr[0]; + var i = 0; + while (++i < arr.length) + if (arr[i] < low) + low = arr[i]; + return low; +}; + + +// maximum value of an array +jStat.max = function max(arr) { + var high = arr[0]; + var i = 0; + while (++i < arr.length) + if (arr[i] > high) + high = arr[i]; + return high; +}; + + +// unique values of an array +jStat.unique = function unique(arr) { + var hash = {}, _arr = []; + for(var i = 0; i < arr.length; i++) { + if (!hash[arr[i]]) { + hash[arr[i]] = true; + _arr.push(arr[i]); + } + } + return _arr; +}; + + +// mean value of an array +jStat.mean = function mean(arr) { + return jStat.sum(arr) / arr.length; +}; + + +// mean squared error (MSE) +jStat.meansqerr = function meansqerr(arr) { + return jStat.sumsqerr(arr) / arr.length; +}; + + +// geometric mean of an array +jStat.geomean = function geomean(arr) { + return Math.pow(jStat.product(arr), 1 / arr.length); +}; + + +// median of an array +jStat.median = function median(arr) { + var arrlen = arr.length; + var _arr = arr.slice().sort(ascNum); + // check if array is even or odd, then return the appropriate + return !(arrlen & 1) + ? (_arr[(arrlen / 2) - 1 ] + _arr[(arrlen / 2)]) / 2 + : _arr[(arrlen / 2) | 0 ]; +}; + + +// cumulative sum of an array +jStat.cumsum = function cumsum(arr) { + return jStat.cumreduce(arr, function (a, b) { return a + b; }); +}; + + +// cumulative product of an array +jStat.cumprod = function cumprod(arr) { + return jStat.cumreduce(arr, function (a, b) { return a * b; }); +}; + + +// successive differences of a sequence +jStat.diff = function diff(arr) { + var diffs = []; + var arrLen = arr.length; + var i; + for (i = 1; i < arrLen; i++) + diffs.push(arr[i] - arr[i - 1]); + return diffs; +}; + + +// ranks of an array +jStat.rank = function (arr) { + var i; + var distinctNumbers = []; + var numberCounts = {}; + for (i = 0; i < arr.length; i++) { + var number = arr[i]; + if (numberCounts[number]) { + numberCounts[number]++; + } else { + numberCounts[number] = 1; + distinctNumbers.push(number); + } + } + + var sortedDistinctNumbers = distinctNumbers.sort(ascNum); + var numberRanks = {}; + var currentRank = 1; + for (i = 0; i < sortedDistinctNumbers.length; i++) { + var number = sortedDistinctNumbers[i]; + var count = numberCounts[number]; + var first = currentRank; + var last = currentRank + count - 1; + var rank = (first + last) / 2; + numberRanks[number] = rank; + currentRank += count; + } + + return arr.map(function (number) { + return numberRanks[number]; + }); +}; + + +// mode of an array +// if there are multiple modes of an array, return all of them +// is this the appropriate way of handling it? +jStat.mode = function mode(arr) { + var arrLen = arr.length; + var _arr = arr.slice().sort(ascNum); + var count = 1; + var maxCount = 0; + var numMaxCount = 0; + var mode_arr = []; + var i; + + for (i = 0; i < arrLen; i++) { + if (_arr[i] === _arr[i + 1]) { + count++; + } else { + if (count > maxCount) { + mode_arr = [_arr[i]]; + maxCount = count; + numMaxCount = 0; + } + // are there multiple max counts + else if (count === maxCount) { + mode_arr.push(_arr[i]); + numMaxCount++; + } + // resetting count for new value in array + count = 1; + } + } + + return numMaxCount === 0 ? mode_arr[0] : mode_arr; +}; + + +// range of an array +jStat.range = function range(arr) { + return jStat.max(arr) - jStat.min(arr); +}; + +// variance of an array +// flag = true indicates sample instead of population +jStat.variance = function variance(arr, flag) { + return jStat.sumsqerr(arr) / (arr.length - (flag ? 1 : 0)); +}; + +// pooled variance of an array of arrays +jStat.pooledvariance = function pooledvariance(arr) { + var sumsqerr = arr.reduce(function (a, samples) {return a + jStat.sumsqerr(samples);}, 0); + var count = arr.reduce(function (a, samples) {return a + samples.length;}, 0); + return sumsqerr / (count - arr.length); +}; + +// deviation of an array +jStat.deviation = function (arr) { + var mean = jStat.mean(arr); + var arrlen = arr.length; + var dev = new Array(arrlen); + for (var i = 0; i < arrlen; i++) { + dev[i] = arr[i] - mean; + } + return dev; +}; + +// standard deviation of an array +// flag = true indicates sample instead of population +jStat.stdev = function stdev(arr, flag) { + return Math.sqrt(jStat.variance(arr, flag)); +}; + +// pooled standard deviation of an array of arrays +jStat.pooledstdev = function pooledstdev(arr) { + return Math.sqrt(jStat.pooledvariance(arr)); +}; + +// mean deviation (mean absolute deviation) of an array +jStat.meandev = function meandev(arr) { + var mean = jStat.mean(arr); + var a = []; + for (var i = arr.length - 1; i >= 0; i--) { + a.push(Math.abs(arr[i] - mean)); + } + return jStat.mean(a); +}; + + +// median deviation (median absolute deviation) of an array +jStat.meddev = function meddev(arr) { + var median = jStat.median(arr); + var a = []; + for (var i = arr.length - 1; i >= 0; i--) { + a.push(Math.abs(arr[i] - median)); + } + return jStat.median(a); +}; + + +// coefficient of variation +jStat.coeffvar = function coeffvar(arr) { + return jStat.stdev(arr) / jStat.mean(arr); +}; + + +// quartiles of an array +jStat.quartiles = function quartiles(arr) { + var arrlen = arr.length; + var _arr = arr.slice().sort(ascNum); + return [ + _arr[ Math.round((arrlen) / 4) - 1 ], + _arr[ Math.round((arrlen) / 2) - 1 ], + _arr[ Math.round((arrlen) * 3 / 4) - 1 ] + ]; +}; + + +// Arbitary quantiles of an array. Direct port of the scipy.stats +// implementation by Pierre GF Gerard-Marchant. +jStat.quantiles = function quantiles(arr, quantilesArray, alphap, betap) { + var sortedArray = arr.slice().sort(ascNum); + var quantileVals = [quantilesArray.length]; + var n = arr.length; + var i, p, m, aleph, k, gamma; + + if (typeof alphap === 'undefined') + alphap = 3 / 8; + if (typeof betap === 'undefined') + betap = 3 / 8; + + for (i = 0; i < quantilesArray.length; i++) { + p = quantilesArray[i]; + m = alphap + p * (1 - alphap - betap); + aleph = n * p + m; + k = Math.floor(clip(aleph, 1, n - 1)); + gamma = clip(aleph - k, 0, 1); + quantileVals[i] = (1 - gamma) * sortedArray[k - 1] + gamma * sortedArray[k]; + } + + return quantileVals; +}; + +// Return the k-th percentile of values in a range, where k is in the range 0..1, inclusive. +// Passing true for the exclusive parameter excludes both endpoints of the range. +jStat.percentile = function percentile(arr, k, exclusive) { + var _arr = arr.slice().sort(ascNum); + var realIndex = k * (_arr.length + (exclusive ? 1 : -1)) + (exclusive ? 0 : 1); + var index = parseInt(realIndex); + var frac = realIndex - index; + if (index + 1 < _arr.length) { + return _arr[index - 1] + frac * (_arr[index] - _arr[index - 1]); + } else { + return _arr[index - 1]; + } +}; + +// The percentile rank of score in a given array. Returns the percentage +// of all values in the input array that are less than (kind='strict') or +// less or equal than (kind='weak') score. Default is weak. +jStat.percentileOfScore = function percentileOfScore(arr, score, kind) { + var counter = 0; + var len = arr.length; + var strict = false; + var value, i; + + if (kind === 'strict') + strict = true; + + for (i = 0; i < len; i++) { + value = arr[i]; + if ((strict && value < score) || + (!strict && value <= score)) { + counter++; + } + } + + return counter / len; +}; + + +// Histogram (bin count) data +jStat.histogram = function histogram(arr, binCnt) { + binCnt = binCnt || 4; + var first = jStat.min(arr); + var binWidth = (jStat.max(arr) - first) / binCnt; + var len = arr.length; + var bins = []; + var i; + + for (i = 0; i < binCnt; i++) + bins[i] = 0; + for (i = 0; i < len; i++) + bins[Math.min(Math.floor(((arr[i] - first) / binWidth)), binCnt - 1)] += 1; + + return bins; +}; + + +// covariance of two arrays +jStat.covariance = function covariance(arr1, arr2) { + var u = jStat.mean(arr1); + var v = jStat.mean(arr2); + var arr1Len = arr1.length; + var sq_dev = new Array(arr1Len); + var i; + + for (i = 0; i < arr1Len; i++) + sq_dev[i] = (arr1[i] - u) * (arr2[i] - v); + + return jStat.sum(sq_dev) / (arr1Len - 1); +}; + + +// (pearson's) population correlation coefficient, rho +jStat.corrcoeff = function corrcoeff(arr1, arr2) { + return jStat.covariance(arr1, arr2) / + jStat.stdev(arr1, 1) / + jStat.stdev(arr2, 1); +}; + + // (spearman's) rank correlation coefficient, sp +jStat.spearmancoeff = function (arr1, arr2) { + arr1 = jStat.rank(arr1); + arr2 = jStat.rank(arr2); + //return pearson's correlation of the ranks: + return jStat.corrcoeff(arr1, arr2); +}; + + +// statistical standardized moments (general form of skew/kurt) +jStat.stanMoment = function stanMoment(arr, n) { + var mu = jStat.mean(arr); + var sigma = jStat.stdev(arr); + var len = arr.length; + var skewSum = 0; + + for (var i = 0; i < len; i++) + skewSum += Math.pow((arr[i] - mu) / sigma, n); + + return skewSum / arr.length; +}; + +// (pearson's) moment coefficient of skewness +jStat.skewness = function skewness(arr) { + return jStat.stanMoment(arr, 3); +}; + +// (pearson's) (excess) kurtosis +jStat.kurtosis = function kurtosis(arr) { + return jStat.stanMoment(arr, 4) - 3; +}; + + +var jProto = jStat.prototype; + + +// Extend jProto with method for calculating cumulative sums and products. +// This differs from the similar extension below as cumsum and cumprod should +// not be run again in the case fullbool === true. +// If a matrix is passed, automatically assume operation should be done on the +// columns. +(function(funcs) { + for (var i = 0; i < funcs.length; i++) (function(passfunc) { + // If a matrix is passed, automatically assume operation should be done on + // the columns. + jProto[passfunc] = function(fullbool, func) { + var arr = []; + var i = 0; + var tmpthis = this; + // Assignment reassignation depending on how parameters were passed in. + if (isFunction(fullbool)) { + func = fullbool; + fullbool = false; + } + // Check if a callback was passed with the function. + if (func) { + setTimeout(function() { + func.call(tmpthis, jProto[passfunc].call(tmpthis, fullbool)); + }); + return this; + } + // Check if matrix and run calculations. + if (this.length > 1) { + tmpthis = fullbool === true ? this : this.transpose(); + for (; i < tmpthis.length; i++) + arr[i] = jStat[passfunc](tmpthis[i]); + return arr; + } + // Pass fullbool if only vector, not a matrix. for variance and stdev. + return jStat[passfunc](this[0], fullbool); + }; + })(funcs[i]); +})(('cumsum cumprod').split(' ')); + + +// Extend jProto with methods which don't require arguments and work on columns. +(function(funcs) { + for (var i = 0; i < funcs.length; i++) (function(passfunc) { + // If a matrix is passed, automatically assume operation should be done on + // the columns. + jProto[passfunc] = function(fullbool, func) { + var arr = []; + var i = 0; + var tmpthis = this; + // Assignment reassignation depending on how parameters were passed in. + if (isFunction(fullbool)) { + func = fullbool; + fullbool = false; + } + // Check if a callback was passed with the function. + if (func) { + setTimeout(function() { + func.call(tmpthis, jProto[passfunc].call(tmpthis, fullbool)); + }); + return this; + } + // Check if matrix and run calculations. + if (this.length > 1) { + if (passfunc !== 'sumrow') + tmpthis = fullbool === true ? this : this.transpose(); + for (; i < tmpthis.length; i++) + arr[i] = jStat[passfunc](tmpthis[i]); + return fullbool === true + ? jStat[passfunc](jStat.utils.toVector(arr)) + : arr; + } + // Pass fullbool if only vector, not a matrix. for variance and stdev. + return jStat[passfunc](this[0], fullbool); + }; + })(funcs[i]); +})(('sum sumsqrd sumsqerr sumrow product min max unique mean meansqerr ' + + 'geomean median diff rank mode range variance deviation stdev meandev ' + + 'meddev coeffvar quartiles histogram skewness kurtosis').split(' ')); + + +// Extend jProto with functions that take arguments. Operations on matrices are +// done on columns. +(function(funcs) { + for (var i = 0; i < funcs.length; i++) (function(passfunc) { + jProto[passfunc] = function() { + var arr = []; + var i = 0; + var tmpthis = this; + var args = Array.prototype.slice.call(arguments); + var callbackFunction; + + // If the last argument is a function, we assume it's a callback; we + // strip the callback out and call the function again. + if (isFunction(args[args.length - 1])) { + callbackFunction = args[args.length - 1]; + var argsToPass = args.slice(0, args.length - 1); + + setTimeout(function() { + callbackFunction.call(tmpthis, + jProto[passfunc].apply(tmpthis, argsToPass)); + }); + return this; + + // Otherwise we curry the function args and call normally. + } else { + callbackFunction = undefined; + var curriedFunction = function curriedFunction(vector) { + return jStat[passfunc].apply(tmpthis, [vector].concat(args)); + }; + } + + // If this is a matrix, run column-by-column. + if (this.length > 1) { + tmpthis = tmpthis.transpose(); + for (; i < tmpthis.length; i++) + arr[i] = curriedFunction(tmpthis[i]); + return arr; + } + + // Otherwise run on the vector. + return curriedFunction(this[0]); + }; + })(funcs[i]); +})('quantiles percentileOfScore'.split(' ')); + +}(jStat, Math)); +// Special functions // +(function(jStat, Math) { + +// Log-gamma function +jStat.gammaln = function gammaln(x) { + var j = 0; + var cof = [ + 76.18009172947146, -86.50532032941677, 24.01409824083091, + -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5 + ]; + var ser = 1.000000000190015; + var xx, y, tmp; + tmp = (y = xx = x) + 5.5; + tmp -= (xx + 0.5) * Math.log(tmp); + for (; j < 6; j++) + ser += cof[j] / ++y; + return Math.log(2.5066282746310005 * ser / xx) - tmp; +}; + +/* + * log-gamma function to support poisson distribution sampling. The + * algorithm comes from SPECFUN by Shanjie Zhang and Jianming Jin and their + * book "Computation of Special Functions", 1996, John Wiley & Sons, Inc. + */ +jStat.loggam = function loggam(x) { + var x0, x2, xp, gl, gl0; + var k, n; + + var a = [8.333333333333333e-02, -2.777777777777778e-03, + 7.936507936507937e-04, -5.952380952380952e-04, + 8.417508417508418e-04, -1.917526917526918e-03, + 6.410256410256410e-03, -2.955065359477124e-02, + 1.796443723688307e-01, -1.39243221690590e+00]; + x0 = x; + n = 0; + if ((x == 1.0) || (x == 2.0)) { + return 0.0; + } + if (x <= 7.0) { + n = Math.floor(7 - x); + x0 = x + n; + } + x2 = 1.0 / (x0 * x0); + xp = 2 * Math.PI; + gl0 = a[9]; + for (k = 8; k >= 0; k--) { + gl0 *= x2; + gl0 += a[k]; + } + gl = gl0 / x0 + 0.5 * Math.log(xp) + (x0 - 0.5) * Math.log(x0) - x0; + if (x <= 7.0) { + for (k = 1; k <= n; k++) { + gl -= Math.log(x0 - 1.0); + x0 -= 1.0; + } + } + return gl; +}; + +// gamma of x +jStat.gammafn = function gammafn(x) { + var p = [-1.716185138865495, 24.76565080557592, -379.80425647094563, + 629.3311553128184, 866.9662027904133, -31451.272968848367, + -36144.413418691176, 66456.14382024054 + ]; + var q = [-30.8402300119739, 315.35062697960416, -1015.1563674902192, + -3107.771671572311, 22538.118420980151, 4755.8462775278811, + -134659.9598649693, -115132.2596755535]; + var fact = false; + var n = 0; + var xden = 0; + var xnum = 0; + var y = x; + var i, z, yi, res; + if (x > 171.6243769536076) { + return Infinity; + } + if (y <= 0) { + res = y % 1 + 3.6e-16; + if (res) { + fact = (!(y & 1) ? 1 : -1) * Math.PI / Math.sin(Math.PI * res); + y = 1 - y; + } else { + return Infinity; + } + } + yi = y; + if (y < 1) { + z = y++; + } else { + z = (y -= n = (y | 0) - 1) - 1; + } + for (i = 0; i < 8; ++i) { + xnum = (xnum + p[i]) * z; + xden = xden * z + q[i]; + } + res = xnum / xden + 1; + if (yi < y) { + res /= yi; + } else if (yi > y) { + for (i = 0; i < n; ++i) { + res *= y; + y++; + } + } + if (fact) { + res = fact / res; + } + return res; +}; + + +// lower incomplete gamma function, which is usually typeset with a +// lower-case greek gamma as the function symbol +jStat.gammap = function gammap(a, x) { + return jStat.lowRegGamma(a, x) * jStat.gammafn(a); +}; + + +// The lower regularized incomplete gamma function, usually written P(a,x) +jStat.lowRegGamma = function lowRegGamma(a, x) { + var aln = jStat.gammaln(a); + var ap = a; + var sum = 1 / a; + var del = sum; + var b = x + 1 - a; + var c = 1 / 1.0e-30; + var d = 1 / b; + var h = d; + var i = 1; + // calculate maximum number of itterations required for a + var ITMAX = -~(Math.log((a >= 1) ? a : 1 / a) * 8.5 + a * 0.4 + 17); + var an; + + if (x < 0 || a <= 0) { + return NaN; + } else if (x < a + 1) { + for (; i <= ITMAX; i++) { + sum += del *= x / ++ap; + } + return (sum * Math.exp(-x + a * Math.log(x) - (aln))); + } + + for (; i <= ITMAX; i++) { + an = -i * (i - a); + b += 2; + d = an * d + b; + c = b + an / c; + d = 1 / d; + h *= d * c; + } + + return (1 - h * Math.exp(-x + a * Math.log(x) - (aln))); +}; + +// natural log factorial of n +jStat.factorialln = function factorialln(n) { + return n < 0 ? NaN : jStat.gammaln(n + 1); +}; + +// factorial of n +jStat.factorial = function factorial(n) { + return n < 0 ? NaN : jStat.gammafn(n + 1); +}; + +// combinations of n, m +jStat.combination = function combination(n, m) { + // make sure n or m don't exceed the upper limit of usable values + return (n > 170 || m > 170) + ? Math.exp(jStat.combinationln(n, m)) + : (jStat.factorial(n) / jStat.factorial(m)) / jStat.factorial(n - m); +}; + + +jStat.combinationln = function combinationln(n, m){ + return jStat.factorialln(n) - jStat.factorialln(m) - jStat.factorialln(n - m); +}; + + +// permutations of n, m +jStat.permutation = function permutation(n, m) { + return jStat.factorial(n) / jStat.factorial(n - m); +}; + + +// beta function +jStat.betafn = function betafn(x, y) { + // ensure arguments are positive + if (x <= 0 || y <= 0) + return undefined; + // make sure x + y doesn't exceed the upper limit of usable values + return (x + y > 170) + ? Math.exp(jStat.betaln(x, y)) + : jStat.gammafn(x) * jStat.gammafn(y) / jStat.gammafn(x + y); +}; + + +// natural logarithm of beta function +jStat.betaln = function betaln(x, y) { + return jStat.gammaln(x) + jStat.gammaln(y) - jStat.gammaln(x + y); +}; + + +// Evaluates the continued fraction for incomplete beta function by modified +// Lentz's method. +jStat.betacf = function betacf(x, a, b) { + var fpmin = 1e-30; + var m = 1; + var qab = a + b; + var qap = a + 1; + var qam = a - 1; + var c = 1; + var d = 1 - qab * x / qap; + var m2, aa, del, h; + + // These q's will be used in factors that occur in the coefficients + if (Math.abs(d) < fpmin) + d = fpmin; + d = 1 / d; + h = d; + + for (; m <= 100; m++) { + m2 = 2 * m; + aa = m * (b - m) * x / ((qam + m2) * (a + m2)); + // One step (the even one) of the recurrence + d = 1 + aa * d; + if (Math.abs(d) < fpmin) + d = fpmin; + c = 1 + aa / c; + if (Math.abs(c) < fpmin) + c = fpmin; + d = 1 / d; + h *= d * c; + aa = -(a + m) * (qab + m) * x / ((a + m2) * (qap + m2)); + // Next step of the recurrence (the odd one) + d = 1 + aa * d; + if (Math.abs(d) < fpmin) + d = fpmin; + c = 1 + aa / c; + if (Math.abs(c) < fpmin) + c = fpmin; + d = 1 / d; + del = d * c; + h *= del; + if (Math.abs(del - 1.0) < 3e-7) + break; + } + + return h; +}; + + +// Returns the inverse of the lower regularized inomplete gamma function +jStat.gammapinv = function gammapinv(p, a) { + var j = 0; + var a1 = a - 1; + var EPS = 1e-8; + var gln = jStat.gammaln(a); + var x, err, t, u, pp, lna1, afac; + + if (p >= 1) + return Math.max(100, a + 100 * Math.sqrt(a)); + if (p <= 0) + return 0; + if (a > 1) { + lna1 = Math.log(a1); + afac = Math.exp(a1 * (lna1 - 1) - gln); + pp = (p < 0.5) ? p : 1 - p; + t = Math.sqrt(-2 * Math.log(pp)); + x = (2.30753 + t * 0.27061) / (1 + t * (0.99229 + t * 0.04481)) - t; + if (p < 0.5) + x = -x; + x = Math.max(1e-3, + a * Math.pow(1 - 1 / (9 * a) - x / (3 * Math.sqrt(a)), 3)); + } else { + t = 1 - a * (0.253 + a * 0.12); + if (p < t) + x = Math.pow(p / t, 1 / a); + else + x = 1 - Math.log(1 - (p - t) / (1 - t)); + } + + for(; j < 12; j++) { + if (x <= 0) + return 0; + err = jStat.lowRegGamma(a, x) - p; + if (a > 1) + t = afac * Math.exp(-(x - a1) + a1 * (Math.log(x) - lna1)); + else + t = Math.exp(-x + a1 * Math.log(x) - gln); + u = err / t; + x -= (t = u / (1 - 0.5 * Math.min(1, u * ((a - 1) / x - 1)))); + if (x <= 0) + x = 0.5 * (x + t); + if (Math.abs(t) < EPS * x) + break; + } + + return x; +}; + + +// Returns the error function erf(x) +jStat.erf = function erf(x) { + var cof = [-1.3026537197817094, 6.4196979235649026e-1, 1.9476473204185836e-2, + -9.561514786808631e-3, -9.46595344482036e-4, 3.66839497852761e-4, + 4.2523324806907e-5, -2.0278578112534e-5, -1.624290004647e-6, + 1.303655835580e-6, 1.5626441722e-8, -8.5238095915e-8, + 6.529054439e-9, 5.059343495e-9, -9.91364156e-10, + -2.27365122e-10, 9.6467911e-11, 2.394038e-12, + -6.886027e-12, 8.94487e-13, 3.13092e-13, + -1.12708e-13, 3.81e-16, 7.106e-15, + -1.523e-15, -9.4e-17, 1.21e-16, + -2.8e-17]; + var j = cof.length - 1; + var isneg = false; + var d = 0; + var dd = 0; + var t, ty, tmp, res; + + if (x < 0) { + x = -x; + isneg = true; + } + + t = 2 / (2 + x); + ty = 4 * t - 2; + + for(; j > 0; j--) { + tmp = d; + d = ty * d - dd + cof[j]; + dd = tmp; + } + + res = t * Math.exp(-x * x + 0.5 * (cof[0] + ty * d) - dd); + return isneg ? res - 1 : 1 - res; +}; + + +// Returns the complmentary error function erfc(x) +jStat.erfc = function erfc(x) { + return 1 - jStat.erf(x); +}; + + +// Returns the inverse of the complementary error function +jStat.erfcinv = function erfcinv(p) { + var j = 0; + var x, err, t, pp; + if (p >= 2) + return -100; + if (p <= 0) + return 100; + pp = (p < 1) ? p : 2 - p; + t = Math.sqrt(-2 * Math.log(pp / 2)); + x = -0.70711 * ((2.30753 + t * 0.27061) / + (1 + t * (0.99229 + t * 0.04481)) - t); + for (; j < 2; j++) { + err = jStat.erfc(x) - pp; + x += err / (1.12837916709551257 * Math.exp(-x * x) - x * err); + } + return (p < 1) ? x : -x; +}; + + +// Returns the inverse of the incomplete beta function +jStat.ibetainv = function ibetainv(p, a, b) { + var EPS = 1e-8; + var a1 = a - 1; + var b1 = b - 1; + var j = 0; + var lna, lnb, pp, t, u, err, x, al, h, w, afac; + if (p <= 0) + return 0; + if (p >= 1) + return 1; + if (a >= 1 && b >= 1) { + pp = (p < 0.5) ? p : 1 - p; + t = Math.sqrt(-2 * Math.log(pp)); + x = (2.30753 + t * 0.27061) / (1 + t* (0.99229 + t * 0.04481)) - t; + if (p < 0.5) + x = -x; + al = (x * x - 3) / 6; + h = 2 / (1 / (2 * a - 1) + 1 / (2 * b - 1)); + w = (x * Math.sqrt(al + h) / h) - (1 / (2 * b - 1) - 1 / (2 * a - 1)) * + (al + 5 / 6 - 2 / (3 * h)); + x = a / (a + b * Math.exp(2 * w)); + } else { + lna = Math.log(a / (a + b)); + lnb = Math.log(b / (a + b)); + t = Math.exp(a * lna) / a; + u = Math.exp(b * lnb) / b; + w = t + u; + if (p < t / w) + x = Math.pow(a * w * p, 1 / a); + else + x = 1 - Math.pow(b * w * (1 - p), 1 / b); + } + afac = -jStat.gammaln(a) - jStat.gammaln(b) + jStat.gammaln(a + b); + for(; j < 10; j++) { + if (x === 0 || x === 1) + return x; + err = jStat.ibeta(x, a, b) - p; + t = Math.exp(a1 * Math.log(x) + b1 * Math.log(1 - x) + afac); + u = err / t; + x -= (t = u / (1 - 0.5 * Math.min(1, u * (a1 / x - b1 / (1 - x))))); + if (x <= 0) + x = 0.5 * (x + t); + if (x >= 1) + x = 0.5 * (x + t + 1); + if (Math.abs(t) < EPS * x && j > 0) + break; + } + return x; +}; + + +// Returns the incomplete beta function I_x(a,b) +jStat.ibeta = function ibeta(x, a, b) { + // Factors in front of the continued fraction. + var bt = (x === 0 || x === 1) ? 0 : + Math.exp(jStat.gammaln(a + b) - jStat.gammaln(a) - + jStat.gammaln(b) + a * Math.log(x) + b * + Math.log(1 - x)); + if (x < 0 || x > 1) + return false; + if (x < (a + 1) / (a + b + 2)) + // Use continued fraction directly. + return bt * jStat.betacf(x, a, b) / a; + // else use continued fraction after making the symmetry transformation. + return 1 - bt * jStat.betacf(1 - x, b, a) / b; +}; + + +// Returns a normal deviate (mu=0, sigma=1). +// If n and m are specified it returns a object of normal deviates. +jStat.randn = function randn(n, m) { + var u, v, x, y, q; + if (!m) + m = n; + if (n) + return jStat.create(n, m, function() { return jStat.randn(); }); + do { + u = jStat._random_fn(); + v = 1.7156 * (jStat._random_fn() - 0.5); + x = u - 0.449871; + y = Math.abs(v) + 0.386595; + q = x * x + y * (0.19600 * y - 0.25472 * x); + } while (q > 0.27597 && (q > 0.27846 || v * v > -4 * Math.log(u) * u * u)); + return v / u; +}; + + +// Returns a gamma deviate by the method of Marsaglia and Tsang. +jStat.randg = function randg(shape, n, m) { + var oalph = shape; + var a1, a2, u, v, x, mat; + if (!m) + m = n; + if (!shape) + shape = 1; + if (n) { + mat = jStat.zeros(n,m); + mat.alter(function() { return jStat.randg(shape); }); + return mat; + } + if (shape < 1) + shape += 1; + a1 = shape - 1 / 3; + a2 = 1 / Math.sqrt(9 * a1); + do { + do { + x = jStat.randn(); + v = 1 + a2 * x; + } while(v <= 0); + v = v * v * v; + u = jStat._random_fn(); + } while(u > 1 - 0.331 * Math.pow(x, 4) && + Math.log(u) > 0.5 * x*x + a1 * (1 - v + Math.log(v))); + // alpha > 1 + if (shape == oalph) + return a1 * v; + // alpha < 1 + do { + u = jStat._random_fn(); + } while(u === 0); + return Math.pow(u, 1 / oalph) * a1 * v; +}; + + +// making use of static methods on the instance +(function(funcs) { + for (var i = 0; i < funcs.length; i++) (function(passfunc) { + jStat.fn[passfunc] = function() { + return jStat( + jStat.map(this, function(value) { return jStat[passfunc](value); })); + }; + })(funcs[i]); +})('gammaln gammafn factorial factorialln'.split(' ')); + + +(function(funcs) { + for (var i = 0; i < funcs.length; i++) (function(passfunc) { + jStat.fn[passfunc] = function() { + return jStat(jStat[passfunc].apply(null, arguments)); + }; + })(funcs[i]); +})('randn'.split(' ')); + +}(jStat, Math)); +(function(jStat, Math) { + +// generate all distribution instance methods +(function(list) { + for (var i = 0; i < list.length; i++) (function(func) { + // distribution instance method + jStat[func] = function f(a, b, c) { + if (!(this instanceof f)) + return new f(a, b, c); + this._a = a; + this._b = b; + this._c = c; + return this; + }; + // distribution method to be used on a jStat instance + jStat.fn[func] = function(a, b, c) { + var newthis = jStat[func](a, b, c); + newthis.data = this; + return newthis; + }; + // sample instance method + jStat[func].prototype.sample = function(arr) { + var a = this._a; + var b = this._b; + var c = this._c; + if (arr) + return jStat.alter(arr, function() { + return jStat[func].sample(a, b, c); + }); + else + return jStat[func].sample(a, b, c); + }; + // generate the pdf, cdf and inv instance methods + (function(vals) { + for (var i = 0; i < vals.length; i++) (function(fnfunc) { + jStat[func].prototype[fnfunc] = function(x) { + var a = this._a; + var b = this._b; + var c = this._c; + if (!x && x !== 0) + x = this.data; + if (typeof x !== 'number') { + return jStat.fn.map.call(x, function(x) { + return jStat[func][fnfunc](x, a, b, c); + }); + } + return jStat[func][fnfunc](x, a, b, c); + }; + })(vals[i]); + })('pdf cdf inv'.split(' ')); + // generate the mean, median, mode and variance instance methods + (function(vals) { + for (var i = 0; i < vals.length; i++) (function(fnfunc) { + jStat[func].prototype[fnfunc] = function() { + return jStat[func][fnfunc](this._a, this._b, this._c); + }; + })(vals[i]); + })('mean median mode variance'.split(' ')); + })(list[i]); +})(( + 'beta centralF cauchy chisquare exponential gamma invgamma kumaraswamy ' + + 'laplace lognormal noncentralt normal pareto studentt weibull uniform ' + + 'binomial negbin hypgeom poisson triangular tukey arcsine' +).split(' ')); + + + +// extend beta function with static methods +jStat.extend(jStat.beta, { + pdf: function pdf(x, alpha, beta) { + // PDF is zero outside the support + if (x > 1 || x < 0) + return 0; + // PDF is one for the uniform case + if (alpha == 1 && beta == 1) + return 1; + + if (alpha < 512 && beta < 512) { + return (Math.pow(x, alpha - 1) * Math.pow(1 - x, beta - 1)) / + jStat.betafn(alpha, beta); + } else { + return Math.exp((alpha - 1) * Math.log(x) + + (beta - 1) * Math.log(1 - x) - + jStat.betaln(alpha, beta)); + } + }, + + cdf: function cdf(x, alpha, beta) { + return (x > 1 || x < 0) ? (x > 1) * 1 : jStat.ibeta(x, alpha, beta); + }, + + inv: function inv(x, alpha, beta) { + return jStat.ibetainv(x, alpha, beta); + }, + + mean: function mean(alpha, beta) { + return alpha / (alpha + beta); + }, + + median: function median(alpha, beta) { + return jStat.ibetainv(0.5, alpha, beta); + }, + + mode: function mode(alpha, beta) { + return (alpha - 1 ) / ( alpha + beta - 2); + }, + + // return a random sample + sample: function sample(alpha, beta) { + var u = jStat.randg(alpha); + return u / (u + jStat.randg(beta)); + }, + + variance: function variance(alpha, beta) { + return (alpha * beta) / (Math.pow(alpha + beta, 2) * (alpha + beta + 1)); + } +}); + +// extend F function with static methods +jStat.extend(jStat.centralF, { + // This implementation of the pdf function avoids float overflow + // See the way that R calculates this value: + // https://svn.r-project.org/R/trunk/src/nmath/df.c + pdf: function pdf(x, df1, df2) { + var p, q, f; + + if (x < 0) + return 0; + + if (df1 <= 2) { + if (x === 0 && df1 < 2) { + return Infinity; + } + if (x === 0 && df1 === 2) { + return 1; + } + return (1 / jStat.betafn(df1 / 2, df2 / 2)) * + Math.pow(df1 / df2, df1 / 2) * + Math.pow(x, (df1/2) - 1) * + Math.pow((1 + (df1 / df2) * x), -(df1 + df2) / 2); + } + + p = (df1 * x) / (df2 + x * df1); + q = df2 / (df2 + x * df1); + f = df1 * q / 2.0; + return f * jStat.binomial.pdf((df1 - 2) / 2, (df1 + df2 - 2) / 2, p); + }, + + cdf: function cdf(x, df1, df2) { + if (x < 0) + return 0; + return jStat.ibeta((df1 * x) / (df1 * x + df2), df1 / 2, df2 / 2); + }, + + inv: function inv(x, df1, df2) { + return df2 / (df1 * (1 / jStat.ibetainv(x, df1 / 2, df2 / 2) - 1)); + }, + + mean: function mean(df1, df2) { + return (df2 > 2) ? df2 / (df2 - 2) : undefined; + }, + + mode: function mode(df1, df2) { + return (df1 > 2) ? (df2 * (df1 - 2)) / (df1 * (df2 + 2)) : undefined; + }, + + // return a random sample + sample: function sample(df1, df2) { + var x1 = jStat.randg(df1 / 2) * 2; + var x2 = jStat.randg(df2 / 2) * 2; + return (x1 / df1) / (x2 / df2); + }, + + variance: function variance(df1, df2) { + if (df2 <= 4) + return undefined; + return 2 * df2 * df2 * (df1 + df2 - 2) / + (df1 * (df2 - 2) * (df2 - 2) * (df2 - 4)); + } +}); + + +// extend cauchy function with static methods +jStat.extend(jStat.cauchy, { + pdf: function pdf(x, local, scale) { + if (scale < 0) { return 0; } + + return (scale / (Math.pow(x - local, 2) + Math.pow(scale, 2))) / Math.PI; + }, + + cdf: function cdf(x, local, scale) { + return Math.atan((x - local) / scale) / Math.PI + 0.5; + }, + + inv: function(p, local, scale) { + return local + scale * Math.tan(Math.PI * (p - 0.5)); + }, + + median: function median(local/*, scale*/) { + return local; + }, + + mode: function mode(local/*, scale*/) { + return local; + }, + + sample: function sample(local, scale) { + return jStat.randn() * + Math.sqrt(1 / (2 * jStat.randg(0.5))) * scale + local; + } +}); + + + +// extend chisquare function with static methods +jStat.extend(jStat.chisquare, { + pdf: function pdf(x, dof) { + if (x < 0) + return 0; + return (x === 0 && dof === 2) ? 0.5 : + Math.exp((dof / 2 - 1) * Math.log(x) - x / 2 - (dof / 2) * + Math.log(2) - jStat.gammaln(dof / 2)); + }, + + cdf: function cdf(x, dof) { + if (x < 0) + return 0; + return jStat.lowRegGamma(dof / 2, x / 2); + }, + + inv: function(p, dof) { + return 2 * jStat.gammapinv(p, 0.5 * dof); + }, + + mean : function(dof) { + return dof; + }, + + // TODO: this is an approximation (is there a better way?) + median: function median(dof) { + return dof * Math.pow(1 - (2 / (9 * dof)), 3); + }, + + mode: function mode(dof) { + return (dof - 2 > 0) ? dof - 2 : 0; + }, + + sample: function sample(dof) { + return jStat.randg(dof / 2) * 2; + }, + + variance: function variance(dof) { + return 2 * dof; + } +}); + + + +// extend exponential function with static methods +jStat.extend(jStat.exponential, { + pdf: function pdf(x, rate) { + return x < 0 ? 0 : rate * Math.exp(-rate * x); + }, + + cdf: function cdf(x, rate) { + return x < 0 ? 0 : 1 - Math.exp(-rate * x); + }, + + inv: function(p, rate) { + return -Math.log(1 - p) / rate; + }, + + mean : function(rate) { + return 1 / rate; + }, + + median: function (rate) { + return (1 / rate) * Math.log(2); + }, + + mode: function mode(/*rate*/) { + return 0; + }, + + sample: function sample(rate) { + return -1 / rate * Math.log(jStat._random_fn()); + }, + + variance : function(rate) { + return Math.pow(rate, -2); + } +}); + + + +// extend gamma function with static methods +jStat.extend(jStat.gamma, { + pdf: function pdf(x, shape, scale) { + if (x < 0) + return 0; + return (x === 0 && shape === 1) ? 1 / scale : + Math.exp((shape - 1) * Math.log(x) - x / scale - + jStat.gammaln(shape) - shape * Math.log(scale)); + }, + + cdf: function cdf(x, shape, scale) { + if (x < 0) + return 0; + return jStat.lowRegGamma(shape, x / scale); + }, + + inv: function(p, shape, scale) { + return jStat.gammapinv(p, shape) * scale; + }, + + mean : function(shape, scale) { + return shape * scale; + }, + + mode: function mode(shape, scale) { + if(shape > 1) return (shape - 1) * scale; + return undefined; + }, + + sample: function sample(shape, scale) { + return jStat.randg(shape) * scale; + }, + + variance: function variance(shape, scale) { + return shape * scale * scale; + } +}); + +// extend inverse gamma function with static methods +jStat.extend(jStat.invgamma, { + pdf: function pdf(x, shape, scale) { + if (x <= 0) + return 0; + return Math.exp(-(shape + 1) * Math.log(x) - scale / x - + jStat.gammaln(shape) + shape * Math.log(scale)); + }, + + cdf: function cdf(x, shape, scale) { + if (x <= 0) + return 0; + return 1 - jStat.lowRegGamma(shape, scale / x); + }, + + inv: function(p, shape, scale) { + return scale / jStat.gammapinv(1 - p, shape); + }, + + mean : function(shape, scale) { + return (shape > 1) ? scale / (shape - 1) : undefined; + }, + + mode: function mode(shape, scale) { + return scale / (shape + 1); + }, + + sample: function sample(shape, scale) { + return scale / jStat.randg(shape); + }, + + variance: function variance(shape, scale) { + if (shape <= 2) + return undefined; + return scale * scale / ((shape - 1) * (shape - 1) * (shape - 2)); + } +}); + + +// extend kumaraswamy function with static methods +jStat.extend(jStat.kumaraswamy, { + pdf: function pdf(x, alpha, beta) { + if (x === 0 && alpha === 1) + return beta; + else if (x === 1 && beta === 1) + return alpha; + return Math.exp(Math.log(alpha) + Math.log(beta) + (alpha - 1) * + Math.log(x) + (beta - 1) * + Math.log(1 - Math.pow(x, alpha))); + }, + + cdf: function cdf(x, alpha, beta) { + if (x < 0) + return 0; + else if (x > 1) + return 1; + return (1 - Math.pow(1 - Math.pow(x, alpha), beta)); + }, + + inv: function inv(p, alpha, beta) { + return Math.pow(1 - Math.pow(1 - p, 1 / beta), 1 / alpha); + }, + + mean : function(alpha, beta) { + return (beta * jStat.gammafn(1 + 1 / alpha) * + jStat.gammafn(beta)) / (jStat.gammafn(1 + 1 / alpha + beta)); + }, + + median: function median(alpha, beta) { + return Math.pow(1 - Math.pow(2, -1 / beta), 1 / alpha); + }, + + mode: function mode(alpha, beta) { + if (!(alpha >= 1 && beta >= 1 && (alpha !== 1 && beta !== 1))) + return undefined; + return Math.pow((alpha - 1) / (alpha * beta - 1), 1 / alpha); + }, + + variance: function variance(/*alpha, beta*/) { + throw new Error('variance not yet implemented'); + // TODO: complete this + } +}); + + + +// extend lognormal function with static methods +jStat.extend(jStat.lognormal, { + pdf: function pdf(x, mu, sigma) { + if (x <= 0) + return 0; + return Math.exp(-Math.log(x) - 0.5 * Math.log(2 * Math.PI) - + Math.log(sigma) - Math.pow(Math.log(x) - mu, 2) / + (2 * sigma * sigma)); + }, + + cdf: function cdf(x, mu, sigma) { + if (x < 0) + return 0; + return 0.5 + + (0.5 * jStat.erf((Math.log(x) - mu) / Math.sqrt(2 * sigma * sigma))); + }, + + inv: function(p, mu, sigma) { + return Math.exp(-1.41421356237309505 * sigma * jStat.erfcinv(2 * p) + mu); + }, + + mean: function mean(mu, sigma) { + return Math.exp(mu + sigma * sigma / 2); + }, + + median: function median(mu/*, sigma*/) { + return Math.exp(mu); + }, + + mode: function mode(mu, sigma) { + return Math.exp(mu - sigma * sigma); + }, + + sample: function sample(mu, sigma) { + return Math.exp(jStat.randn() * sigma + mu); + }, + + variance: function variance(mu, sigma) { + return (Math.exp(sigma * sigma) - 1) * Math.exp(2 * mu + sigma * sigma); + } +}); + + + +// extend noncentralt function with static methods +jStat.extend(jStat.noncentralt, { + pdf: function pdf(x, dof, ncp) { + var tol = 1e-14; + if (Math.abs(ncp) < tol) // ncp approx 0; use student-t + return jStat.studentt.pdf(x, dof) + + if (Math.abs(x) < tol) { // different formula for x == 0 + return Math.exp(jStat.gammaln((dof + 1) / 2) - ncp * ncp / 2 - + 0.5 * Math.log(Math.PI * dof) - jStat.gammaln(dof / 2)); + } + + // formula for x != 0 + return dof / x * + (jStat.noncentralt.cdf(x * Math.sqrt(1 + 2 / dof), dof+2, ncp) - + jStat.noncentralt.cdf(x, dof, ncp)); + }, + + cdf: function cdf(x, dof, ncp) { + var tol = 1e-14; + var min_iterations = 200; + + if (Math.abs(ncp) < tol) // ncp approx 0; use student-t + return jStat.studentt.cdf(x, dof); + + // turn negative x into positive and flip result afterwards + var flip = false; + if (x < 0) { + flip = true; + ncp = -ncp; + } + + var prob = jStat.normal.cdf(-ncp, 0, 1); + var value = tol + 1; + // use value at last two steps to determine convergence + var lastvalue = value; + var y = x * x / (x * x + dof); + var j = 0; + var p = Math.exp(-ncp * ncp / 2); + var q = Math.exp(-ncp * ncp / 2 - 0.5 * Math.log(2) - + jStat.gammaln(3 / 2)) * ncp; + while (j < min_iterations || lastvalue > tol || value > tol) { + lastvalue = value; + if (j > 0) { + p *= (ncp * ncp) / (2 * j); + q *= (ncp * ncp) / (2 * (j + 1 / 2)); + } + value = p * jStat.beta.cdf(y, j + 0.5, dof / 2) + + q * jStat.beta.cdf(y, j+1, dof/2); + prob += 0.5 * value; + j++; + } + + return flip ? (1 - prob) : prob; + } +}); + + +// extend normal function with static methods +jStat.extend(jStat.normal, { + pdf: function pdf(x, mean, std) { + return Math.exp(-0.5 * Math.log(2 * Math.PI) - + Math.log(std) - Math.pow(x - mean, 2) / (2 * std * std)); + }, + + cdf: function cdf(x, mean, std) { + return 0.5 * (1 + jStat.erf((x - mean) / Math.sqrt(2 * std * std))); + }, + + inv: function(p, mean, std) { + return -1.41421356237309505 * std * jStat.erfcinv(2 * p) + mean; + }, + + mean : function(mean/*, std*/) { + return mean; + }, + + median: function median(mean/*, std*/) { + return mean; + }, + + mode: function (mean/*, std*/) { + return mean; + }, + + sample: function sample(mean, std) { + return jStat.randn() * std + mean; + }, + + variance : function(mean, std) { + return std * std; + } +}); + + + +// extend pareto function with static methods +jStat.extend(jStat.pareto, { + pdf: function pdf(x, scale, shape) { + if (x < scale) + return 0; + return (shape * Math.pow(scale, shape)) / Math.pow(x, shape + 1); + }, + + cdf: function cdf(x, scale, shape) { + if (x < scale) + return 0; + return 1 - Math.pow(scale / x, shape); + }, + + inv: function inv(p, scale, shape) { + return scale / Math.pow(1 - p, 1 / shape); + }, + + mean: function mean(scale, shape) { + if (shape <= 1) + return undefined; + return (shape * Math.pow(scale, shape)) / (shape - 1); + }, + + median: function median(scale, shape) { + return scale * (shape * Math.SQRT2); + }, + + mode: function mode(scale/*, shape*/) { + return scale; + }, + + variance : function(scale, shape) { + if (shape <= 2) + return undefined; + return (scale*scale * shape) / (Math.pow(shape - 1, 2) * (shape - 2)); + } +}); + + + +// extend studentt function with static methods +jStat.extend(jStat.studentt, { + pdf: function pdf(x, dof) { + dof = dof > 1e100 ? 1e100 : dof; + return (1/(Math.sqrt(dof) * jStat.betafn(0.5, dof/2))) * + Math.pow(1 + ((x * x) / dof), -((dof + 1) / 2)); + }, + + cdf: function cdf(x, dof) { + var dof2 = dof / 2; + return jStat.ibeta((x + Math.sqrt(x * x + dof)) / + (2 * Math.sqrt(x * x + dof)), dof2, dof2); + }, + + inv: function(p, dof) { + var x = jStat.ibetainv(2 * Math.min(p, 1 - p), 0.5 * dof, 0.5); + x = Math.sqrt(dof * (1 - x) / x); + return (p > 0.5) ? x : -x; + }, + + mean: function mean(dof) { + return (dof > 1) ? 0 : undefined; + }, + + median: function median(/*dof*/) { + return 0; + }, + + mode: function mode(/*dof*/) { + return 0; + }, + + sample: function sample(dof) { + return jStat.randn() * Math.sqrt(dof / (2 * jStat.randg(dof / 2))); + }, + + variance: function variance(dof) { + return (dof > 2) ? dof / (dof - 2) : (dof > 1) ? Infinity : undefined; + } +}); + + + +// extend weibull function with static methods +jStat.extend(jStat.weibull, { + pdf: function pdf(x, scale, shape) { + if (x < 0 || scale < 0 || shape < 0) + return 0; + return (shape / scale) * Math.pow((x / scale), (shape - 1)) * + Math.exp(-(Math.pow((x / scale), shape))); + }, + + cdf: function cdf(x, scale, shape) { + return x < 0 ? 0 : 1 - Math.exp(-Math.pow((x / scale), shape)); + }, + + inv: function(p, scale, shape) { + return scale * Math.pow(-Math.log(1 - p), 1 / shape); + }, + + mean : function(scale, shape) { + return scale * jStat.gammafn(1 + 1 / shape); + }, + + median: function median(scale, shape) { + return scale * Math.pow(Math.log(2), 1 / shape); + }, + + mode: function mode(scale, shape) { + if (shape <= 1) + return 0; + return scale * Math.pow((shape - 1) / shape, 1 / shape); + }, + + sample: function sample(scale, shape) { + return scale * Math.pow(-Math.log(jStat._random_fn()), 1 / shape); + }, + + variance: function variance(scale, shape) { + return scale * scale * jStat.gammafn(1 + 2 / shape) - + Math.pow(jStat.weibull.mean(scale, shape), 2); + } +}); + + + +// extend uniform function with static methods +jStat.extend(jStat.uniform, { + pdf: function pdf(x, a, b) { + return (x < a || x > b) ? 0 : 1 / (b - a); + }, + + cdf: function cdf(x, a, b) { + if (x < a) + return 0; + else if (x < b) + return (x - a) / (b - a); + return 1; + }, + + inv: function(p, a, b) { + return a + (p * (b - a)); + }, + + mean: function mean(a, b) { + return 0.5 * (a + b); + }, + + median: function median(a, b) { + return jStat.mean(a, b); + }, + + mode: function mode(/*a, b*/) { + throw new Error('mode is not yet implemented'); + }, + + sample: function sample(a, b) { + return (a / 2 + b / 2) + (b / 2 - a / 2) * (2 * jStat._random_fn() - 1); + }, + + variance: function variance(a, b) { + return Math.pow(b - a, 2) / 12; + } +}); + + +// Got this from http://www.math.ucla.edu/~tom/distributions/binomial.html +function betinc(x, a, b, eps) { + var a0 = 0; + var b0 = 1; + var a1 = 1; + var b1 = 1; + var m9 = 0; + var a2 = 0; + var c9; + + while (Math.abs((a1 - a2) / a1) > eps) { + a2 = a1; + c9 = -(a + m9) * (a + b + m9) * x / (a + 2 * m9) / (a + 2 * m9 + 1); + a0 = a1 + c9 * a0; + b0 = b1 + c9 * b0; + m9 = m9 + 1; + c9 = m9 * (b - m9) * x / (a + 2 * m9 - 1) / (a + 2 * m9); + a1 = a0 + c9 * a1; + b1 = b0 + c9 * b1; + a0 = a0 / b1; + b0 = b0 / b1; + a1 = a1 / b1; + b1 = 1; + } + + return a1 / a; +} + + +// extend uniform function with static methods +jStat.extend(jStat.binomial, { + pdf: function pdf(k, n, p) { + return (p === 0 || p === 1) ? + ((n * p) === k ? 1 : 0) : + jStat.combination(n, k) * Math.pow(p, k) * Math.pow(1 - p, n - k); + }, + + cdf: function cdf(x, n, p) { + var betacdf; + var eps = 1e-10; + + if (x < 0) + return 0; + if (x >= n) + return 1; + if (p < 0 || p > 1 || n <= 0) + return NaN; + + x = Math.floor(x); + var z = p; + var a = x + 1; + var b = n - x; + var s = a + b; + var bt = Math.exp(jStat.gammaln(s) - jStat.gammaln(b) - + jStat.gammaln(a) + a * Math.log(z) + b * Math.log(1 - z)); + + if (z < (a + 1) / (s + 2)) + betacdf = bt * betinc(z, a, b, eps); + else + betacdf = 1 - bt * betinc(1 - z, b, a, eps); + + return Math.round((1 - betacdf) * (1 / eps)) / (1 / eps); + } +}); + + + +// extend uniform function with static methods +jStat.extend(jStat.negbin, { + pdf: function pdf(k, r, p) { + if (k !== k >>> 0) + return false; + if (k < 0) + return 0; + return jStat.combination(k + r - 1, r - 1) * + Math.pow(1 - p, k) * Math.pow(p, r); + }, + + cdf: function cdf(x, r, p) { + var sum = 0, + k = 0; + if (x < 0) return 0; + for (; k <= x; k++) { + sum += jStat.negbin.pdf(k, r, p); + } + return sum; + } +}); + + + +// extend uniform function with static methods +jStat.extend(jStat.hypgeom, { + pdf: function pdf(k, N, m, n) { + // Hypergeometric PDF. + + // A simplification of the CDF algorithm below. + + // k = number of successes drawn + // N = population size + // m = number of successes in population + // n = number of items drawn from population + + if(k !== k | 0) { + return false; + } else if(k < 0 || k < m - (N - n)) { + // It's impossible to have this few successes drawn. + return 0; + } else if(k > n || k > m) { + // It's impossible to have this many successes drawn. + return 0; + } else if (m * 2 > N) { + // More than half the population is successes. + + if(n * 2 > N) { + // More than half the population is sampled. + + return jStat.hypgeom.pdf(N - m - n + k, N, N - m, N - n) + } else { + // Half or less of the population is sampled. + + return jStat.hypgeom.pdf(n - k, N, N - m, n); + } + + } else if(n * 2 > N) { + // Half or less is successes. + + return jStat.hypgeom.pdf(m - k, N, m, N - n); + + } else if(m < n) { + // We want to have the number of things sampled to be less than the + // successes available. So swap the definitions of successful and sampled. + return jStat.hypgeom.pdf(k, N, n, m); + } else { + // If we get here, half or less of the population was sampled, half or + // less of it was successes, and we had fewer sampled things than + // successes. Now we can do this complicated iterative algorithm in an + // efficient way. + + // The basic premise of the algorithm is that we partially normalize our + // intermediate product to keep it in a numerically good region, and then + // finish the normalization at the end. + + // This variable holds the scaled probability of the current number of + // successes. + var scaledPDF = 1; + + // This keeps track of how much we have normalized. + var samplesDone = 0; + + for(var i = 0; i < k; i++) { + // For every possible number of successes up to that observed... + + while(scaledPDF > 1 && samplesDone < n) { + // Intermediate result is growing too big. Apply some of the + // normalization to shrink everything. + + scaledPDF *= 1 - (m / (N - samplesDone)); + + // Say we've normalized by this sample already. + samplesDone++; + } + + // Work out the partially-normalized hypergeometric PDF for the next + // number of successes + scaledPDF *= (n - i) * (m - i) / ((i + 1) * (N - m - n + i + 1)); + } + + for(; samplesDone < n; samplesDone++) { + // Apply all the rest of the normalization + scaledPDF *= 1 - (m / (N - samplesDone)); + } + + // Bound answer sanely before returning. + return Math.min(1, Math.max(0, scaledPDF)); + } + }, + + cdf: function cdf(x, N, m, n) { + // Hypergeometric CDF. + + // This algorithm is due to Prof. Thomas S. Ferguson, , + // and comes from his hypergeometric test calculator at + // . + + // x = number of successes drawn + // N = population size + // m = number of successes in population + // n = number of items drawn from population + + if(x < 0 || x < m - (N - n)) { + // It's impossible to have this few successes drawn or fewer. + return 0; + } else if(x >= n || x >= m) { + // We will always have this many successes or fewer. + return 1; + } else if (m * 2 > N) { + // More than half the population is successes. + + if(n * 2 > N) { + // More than half the population is sampled. + + return jStat.hypgeom.cdf(N - m - n + x, N, N - m, N - n) + } else { + // Half or less of the population is sampled. + + return 1 - jStat.hypgeom.cdf(n - x - 1, N, N - m, n); + } + + } else if(n * 2 > N) { + // Half or less is successes. + + return 1 - jStat.hypgeom.cdf(m - x - 1, N, m, N - n); + + } else if(m < n) { + // We want to have the number of things sampled to be less than the + // successes available. So swap the definitions of successful and sampled. + return jStat.hypgeom.cdf(x, N, n, m); + } else { + // If we get here, half or less of the population was sampled, half or + // less of it was successes, and we had fewer sampled things than + // successes. Now we can do this complicated iterative algorithm in an + // efficient way. + + // The basic premise of the algorithm is that we partially normalize our + // intermediate sum to keep it in a numerically good region, and then + // finish the normalization at the end. + + // Holds the intermediate, scaled total CDF. + var scaledCDF = 1; + + // This variable holds the scaled probability of the current number of + // successes. + var scaledPDF = 1; + + // This keeps track of how much we have normalized. + var samplesDone = 0; + + for(var i = 0; i < x; i++) { + // For every possible number of successes up to that observed... + + while(scaledCDF > 1 && samplesDone < n) { + // Intermediate result is growing too big. Apply some of the + // normalization to shrink everything. + + var factor = 1 - (m / (N - samplesDone)); + + scaledPDF *= factor; + scaledCDF *= factor; + + // Say we've normalized by this sample already. + samplesDone++; + } + + // Work out the partially-normalized hypergeometric PDF for the next + // number of successes + scaledPDF *= (n - i) * (m - i) / ((i + 1) * (N - m - n + i + 1)); + + // Add to the CDF answer. + scaledCDF += scaledPDF; + } + + for(; samplesDone < n; samplesDone++) { + // Apply all the rest of the normalization + scaledCDF *= 1 - (m / (N - samplesDone)); + } + + // Bound answer sanely before returning. + return Math.min(1, Math.max(0, scaledCDF)); + } + } +}); + + + +// extend uniform function with static methods +jStat.extend(jStat.poisson, { + pdf: function pdf(k, l) { + if (l < 0 || (k % 1) !== 0 || k < 0) { + return 0; + } + + return Math.pow(l, k) * Math.exp(-l) / jStat.factorial(k); + }, + + cdf: function cdf(x, l) { + var sumarr = [], + k = 0; + if (x < 0) return 0; + for (; k <= x; k++) { + sumarr.push(jStat.poisson.pdf(k, l)); + } + return jStat.sum(sumarr); + }, + + mean : function(l) { + return l; + }, + + variance : function(l) { + return l; + }, + + sampleSmall: function sampleSmall(l) { + var p = 1, k = 0, L = Math.exp(-l); + do { + k++; + p *= jStat._random_fn(); + } while (p > L); + return k - 1; + }, + + sampleLarge: function sampleLarge(l) { + var lam = l; + var k; + var U, V, slam, loglam, a, b, invalpha, vr, us; + + slam = Math.sqrt(lam); + loglam = Math.log(lam); + b = 0.931 + 2.53 * slam; + a = -0.059 + 0.02483 * b; + invalpha = 1.1239 + 1.1328 / (b - 3.4); + vr = 0.9277 - 3.6224 / (b - 2); + + while (1) { + U = Math.random() - 0.5; + V = Math.random(); + us = 0.5 - Math.abs(U); + k = Math.floor((2 * a / us + b) * U + lam + 0.43); + if ((us >= 0.07) && (V <= vr)) { + return k; + } + if ((k < 0) || ((us < 0.013) && (V > us))) { + continue; + } + /* log(V) == log(0.0) ok here */ + /* if U==0.0 so that us==0.0, log is ok since always returns */ + if ((Math.log(V) + Math.log(invalpha) - Math.log(a / (us * us) + b)) <= (-lam + k * loglam - jStat.loggam(k + 1))) { + return k; + } + } + }, + + sample: function sample(l) { + if (l < 10) + return this.sampleSmall(l); + else + return this.sampleLarge(l); + } +}); + +// extend triangular function with static methods +jStat.extend(jStat.triangular, { + pdf: function pdf(x, a, b, c) { + if (b <= a || c < a || c > b) { + return NaN; + } else { + if (x < a || x > b) { + return 0; + } else if (x < c) { + return (2 * (x - a)) / ((b - a) * (c - a)); + } else if (x === c) { + return (2 / (b - a)); + } else { // x > c + return (2 * (b - x)) / ((b - a) * (b - c)); + } + } + }, + + cdf: function cdf(x, a, b, c) { + if (b <= a || c < a || c > b) + return NaN; + if (x <= a) + return 0; + else if (x >= b) + return 1; + if (x <= c) + return Math.pow(x - a, 2) / ((b - a) * (c - a)); + else // x > c + return 1 - Math.pow(b - x, 2) / ((b - a) * (b - c)); + }, + + inv: function inv(p, a, b, c) { + if (b <= a || c < a || c > b) { + return NaN; + } else { + if (p <= ((c - a) / (b - a))) { + return a + (b - a) * Math.sqrt(p * ((c - a) / (b - a))); + } else { // p > ((c - a) / (b - a)) + return a + (b - a) * (1 - Math.sqrt((1 - p) * (1 - ((c - a) / (b - a))))); + } + } + }, + + mean: function mean(a, b, c) { + return (a + b + c) / 3; + }, + + median: function median(a, b, c) { + if (c <= (a + b) / 2) { + return b - Math.sqrt((b - a) * (b - c)) / Math.sqrt(2); + } else if (c > (a + b) / 2) { + return a + Math.sqrt((b - a) * (c - a)) / Math.sqrt(2); + } + }, + + mode: function mode(a, b, c) { + return c; + }, + + sample: function sample(a, b, c) { + var u = jStat._random_fn(); + if (u < ((c - a) / (b - a))) + return a + Math.sqrt(u * (b - a) * (c - a)) + return b - Math.sqrt((1 - u) * (b - a) * (b - c)); + }, + + variance: function variance(a, b, c) { + return (a * a + b * b + c * c - a * b - a * c - b * c) / 18; + } +}); + + +// extend arcsine function with static methods +jStat.extend(jStat.arcsine, { + pdf: function pdf(x, a, b) { + if (b <= a) return NaN; + + return (x <= a || x >= b) ? 0 : + (2 / Math.PI) * + Math.pow(Math.pow(b - a, 2) - + Math.pow(2 * x - a - b, 2), -0.5); + }, + + cdf: function cdf(x, a, b) { + if (x < a) + return 0; + else if (x < b) + return (2 / Math.PI) * Math.asin(Math.sqrt((x - a)/(b - a))); + return 1; + }, + + inv: function(p, a, b) { + return a + (0.5 - 0.5 * Math.cos(Math.PI * p)) * (b - a); + }, + + mean: function mean(a, b) { + if (b <= a) return NaN; + return (a + b) / 2; + }, + + median: function median(a, b) { + if (b <= a) return NaN; + return (a + b) / 2; + }, + + mode: function mode(/*a, b*/) { + throw new Error('mode is not yet implemented'); + }, + + sample: function sample(a, b) { + return ((a + b) / 2) + ((b - a) / 2) * + Math.sin(2 * Math.PI * jStat.uniform.sample(0, 1)); + }, + + variance: function variance(a, b) { + if (b <= a) return NaN; + return Math.pow(b - a, 2) / 8; + } +}); + + +function laplaceSign(x) { return x / Math.abs(x); } + +jStat.extend(jStat.laplace, { + pdf: function pdf(x, mu, b) { + return (b <= 0) ? 0 : (Math.exp(-Math.abs(x - mu) / b)) / (2 * b); + }, + + cdf: function cdf(x, mu, b) { + if (b <= 0) { return 0; } + + if(x < mu) { + return 0.5 * Math.exp((x - mu) / b); + } else { + return 1 - 0.5 * Math.exp(- (x - mu) / b); + } + }, + + mean: function(mu/*, b*/) { + return mu; + }, + + median: function(mu/*, b*/) { + return mu; + }, + + mode: function(mu/*, b*/) { + return mu; + }, + + variance: function(mu, b) { + return 2 * b * b; + }, + + sample: function sample(mu, b) { + var u = jStat._random_fn() - 0.5; + + return mu - (b * laplaceSign(u) * Math.log(1 - (2 * Math.abs(u)))); + } +}); + +function tukeyWprob(w, rr, cc) { + var nleg = 12; + var ihalf = 6; + + var C1 = -30; + var C2 = -50; + var C3 = 60; + var bb = 8; + var wlar = 3; + var wincr1 = 2; + var wincr2 = 3; + var xleg = [ + 0.981560634246719250690549090149, + 0.904117256370474856678465866119, + 0.769902674194304687036893833213, + 0.587317954286617447296702418941, + 0.367831498998180193752691536644, + 0.125233408511468915472441369464 + ]; + var aleg = [ + 0.047175336386511827194615961485, + 0.106939325995318430960254718194, + 0.160078328543346226334652529543, + 0.203167426723065921749064455810, + 0.233492536538354808760849898925, + 0.249147045813402785000562436043 + ]; + + var qsqz = w * 0.5; + + // if w >= 16 then the integral lower bound (occurs for c=20) + // is 0.99999999999995 so return a value of 1. + + if (qsqz >= bb) + return 1.0; + + // find (f(w/2) - 1) ^ cc + // (first term in integral of hartley's form). + + var pr_w = 2 * jStat.normal.cdf(qsqz, 0, 1, 1, 0) - 1; // erf(qsqz / M_SQRT2) + // if pr_w ^ cc < 2e-22 then set pr_w = 0 + if (pr_w >= Math.exp(C2 / cc)) + pr_w = Math.pow(pr_w, cc); + else + pr_w = 0.0; + + // if w is large then the second component of the + // integral is small, so fewer intervals are needed. + + var wincr; + if (w > wlar) + wincr = wincr1; + else + wincr = wincr2; + + // find the integral of second term of hartley's form + // for the integral of the range for equal-length + // intervals using legendre quadrature. limits of + // integration are from (w/2, 8). two or three + // equal-length intervals are used. + + // blb and bub are lower and upper limits of integration. + + var blb = qsqz; + var binc = (bb - qsqz) / wincr; + var bub = blb + binc; + var einsum = 0.0; + + // integrate over each interval + + var cc1 = cc - 1.0; + for (var wi = 1; wi <= wincr; wi++) { + var elsum = 0.0; + var a = 0.5 * (bub + blb); + + // legendre quadrature with order = nleg + + var b = 0.5 * (bub - blb); + + for (var jj = 1; jj <= nleg; jj++) { + var j, xx; + if (ihalf < jj) { + j = (nleg - jj) + 1; + xx = xleg[j-1]; + } else { + j = jj; + xx = -xleg[j-1]; + } + var c = b * xx; + var ac = a + c; + + // if exp(-qexpo/2) < 9e-14, + // then doesn't contribute to integral + + var qexpo = ac * ac; + if (qexpo > C3) + break; + + var pplus = 2 * jStat.normal.cdf(ac, 0, 1, 1, 0); + var pminus= 2 * jStat.normal.cdf(ac, w, 1, 1, 0); + + // if rinsum ^ (cc-1) < 9e-14, + // then doesn't contribute to integral + + var rinsum = (pplus * 0.5) - (pminus * 0.5); + if (rinsum >= Math.exp(C1 / cc1)) { + rinsum = (aleg[j-1] * Math.exp(-(0.5 * qexpo))) * Math.pow(rinsum, cc1); + elsum += rinsum; + } + } + elsum *= (((2.0 * b) * cc) / Math.sqrt(2 * Math.PI)); + einsum += elsum; + blb = bub; + bub += binc; + } + + // if pr_w ^ rr < 9e-14, then return 0 + pr_w += einsum; + if (pr_w <= Math.exp(C1 / rr)) + return 0; + + pr_w = Math.pow(pr_w, rr); + if (pr_w >= 1) // 1 was iMax was eps + return 1; + return pr_w; +} + +function tukeyQinv(p, c, v) { + var p0 = 0.322232421088; + var q0 = 0.993484626060e-01; + var p1 = -1.0; + var q1 = 0.588581570495; + var p2 = -0.342242088547; + var q2 = 0.531103462366; + var p3 = -0.204231210125; + var q3 = 0.103537752850; + var p4 = -0.453642210148e-04; + var q4 = 0.38560700634e-02; + var c1 = 0.8832; + var c2 = 0.2368; + var c3 = 1.214; + var c4 = 1.208; + var c5 = 1.4142; + var vmax = 120.0; + + var ps = 0.5 - 0.5 * p; + var yi = Math.sqrt(Math.log(1.0 / (ps * ps))); + var t = yi + (((( yi * p4 + p3) * yi + p2) * yi + p1) * yi + p0) + / (((( yi * q4 + q3) * yi + q2) * yi + q1) * yi + q0); + if (v < vmax) t += (t * t * t + t) / v / 4.0; + var q = c1 - c2 * t; + if (v < vmax) q += -c3 / v + c4 * t / v; + return t * (q * Math.log(c - 1.0) + c5); +} + +jStat.extend(jStat.tukey, { + cdf: function cdf(q, nmeans, df) { + // Identical implementation as the R ptukey() function as of commit 68947 + var rr = 1; + var cc = nmeans; + + var nlegq = 16; + var ihalfq = 8; + + var eps1 = -30.0; + var eps2 = 1.0e-14; + var dhaf = 100.0; + var dquar = 800.0; + var deigh = 5000.0; + var dlarg = 25000.0; + var ulen1 = 1.0; + var ulen2 = 0.5; + var ulen3 = 0.25; + var ulen4 = 0.125; + var xlegq = [ + 0.989400934991649932596154173450, + 0.944575023073232576077988415535, + 0.865631202387831743880467897712, + 0.755404408355003033895101194847, + 0.617876244402643748446671764049, + 0.458016777657227386342419442984, + 0.281603550779258913230460501460, + 0.950125098376374401853193354250e-1 + ]; + var alegq = [ + 0.271524594117540948517805724560e-1, + 0.622535239386478928628438369944e-1, + 0.951585116824927848099251076022e-1, + 0.124628971255533872052476282192, + 0.149595988816576732081501730547, + 0.169156519395002538189312079030, + 0.182603415044923588866763667969, + 0.189450610455068496285396723208 + ]; + + if (q <= 0) + return 0; + + // df must be > 1 + // there must be at least two values + + if (df < 2 || rr < 1 || cc < 2) return NaN; + + if (!Number.isFinite(q)) + return 1; + + if (df > dlarg) + return tukeyWprob(q, rr, cc); + + // calculate leading constant + + var f2 = df * 0.5; + var f2lf = ((f2 * Math.log(df)) - (df * Math.log(2))) - jStat.gammaln(f2); + var f21 = f2 - 1.0; + + // integral is divided into unit, half-unit, quarter-unit, or + // eighth-unit length intervals depending on the value of the + // degrees of freedom. + + var ff4 = df * 0.25; + var ulen; + if (df <= dhaf) ulen = ulen1; + else if (df <= dquar) ulen = ulen2; + else if (df <= deigh) ulen = ulen3; + else ulen = ulen4; + + f2lf += Math.log(ulen); + + // integrate over each subinterval + + var ans = 0.0; + + for (var i = 1; i <= 50; i++) { + var otsum = 0.0; + + // legendre quadrature with order = nlegq + // nodes (stored in xlegq) are symmetric around zero. + + var twa1 = (2 * i - 1) * ulen; + + for (var jj = 1; jj <= nlegq; jj++) { + var j, t1; + if (ihalfq < jj) { + j = jj - ihalfq - 1; + t1 = (f2lf + (f21 * Math.log(twa1 + (xlegq[j] * ulen)))) + - (((xlegq[j] * ulen) + twa1) * ff4); + } else { + j = jj - 1; + t1 = (f2lf + (f21 * Math.log(twa1 - (xlegq[j] * ulen)))) + + (((xlegq[j] * ulen) - twa1) * ff4); + } + + // if exp(t1) < 9e-14, then doesn't contribute to integral + var qsqz; + if (t1 >= eps1) { + if (ihalfq < jj) { + qsqz = q * Math.sqrt(((xlegq[j] * ulen) + twa1) * 0.5); + } else { + qsqz = q * Math.sqrt(((-(xlegq[j] * ulen)) + twa1) * 0.5); + } + + // call wprob to find integral of range portion + + var wprb = tukeyWprob(qsqz, rr, cc); + var rotsum = (wprb * alegq[j]) * Math.exp(t1); + otsum += rotsum; + } + // end legendre integral for interval i + // L200: + } + + // if integral for interval i < 1e-14, then stop. + // However, in order to avoid small area under left tail, + // at least 1 / ulen intervals are calculated. + if (i * ulen >= 1.0 && otsum <= eps2) + break; + + // end of interval i + // L330: + + ans += otsum; + } + + if (otsum > eps2) { // not converged + throw new Error('tukey.cdf failed to converge'); + } + if (ans > 1) + ans = 1; + return ans; + }, + + inv: function(p, nmeans, df) { + // Identical implementation as the R qtukey() function as of commit 68947 + var rr = 1; + var cc = nmeans; + + var eps = 0.0001; + var maxiter = 50; + + // df must be > 1 ; there must be at least two values + if (df < 2 || rr < 1 || cc < 2) return NaN; + + if (p < 0 || p > 1) return NaN; + if (p === 0) return 0; + if (p === 1) return Infinity; + + // Initial value + + var x0 = tukeyQinv(p, cc, df); + + // Find prob(value < x0) + + var valx0 = jStat.tukey.cdf(x0, nmeans, df) - p; + + // Find the second iterate and prob(value < x1). + // If the first iterate has probability value + // exceeding p then second iterate is 1 less than + // first iterate; otherwise it is 1 greater. + + var x1; + if (valx0 > 0.0) + x1 = Math.max(0.0, x0 - 1.0); + else + x1 = x0 + 1.0; + var valx1 = jStat.tukey.cdf(x1, nmeans, df) - p; + + // Find new iterate + + var ans; + for(var iter = 1; iter < maxiter; iter++) { + ans = x1 - ((valx1 * (x1 - x0)) / (valx1 - valx0)); + valx0 = valx1; + + // New iterate must be >= 0 + + x0 = x1; + if (ans < 0.0) { + ans = 0.0; + valx1 = -p; + } + // Find prob(value < new iterate) + + valx1 = jStat.tukey.cdf(ans, nmeans, df) - p; + x1 = ans; + + // If the difference between two successive + // iterates is less than eps, stop + + var xabs = Math.abs(x1 - x0); + if (xabs < eps) + return ans; + } + + throw new Error('tukey.inv failed to converge'); + } +}); + +}(jStat, Math)); +/* Provides functions for the solution of linear system of equations, integration, extrapolation, + * interpolation, eigenvalue problems, differential equations and PCA analysis. */ + +(function(jStat, Math) { + +var push = Array.prototype.push; +var isArray = jStat.utils.isArray; + +function isUsable(arg) { + return isArray(arg) || arg instanceof jStat; +} + +jStat.extend({ + + // add a vector/matrix to a vector/matrix or scalar + add: function add(arr, arg) { + // check if arg is a vector or scalar + if (isUsable(arg)) { + if (!isUsable(arg[0])) arg = [ arg ]; + return jStat.map(arr, function(value, row, col) { + return value + arg[row][col]; + }); + } + return jStat.map(arr, function(value) { return value + arg; }); + }, + + // subtract a vector or scalar from the vector + subtract: function subtract(arr, arg) { + // check if arg is a vector or scalar + if (isUsable(arg)) { + if (!isUsable(arg[0])) arg = [ arg ]; + return jStat.map(arr, function(value, row, col) { + return value - arg[row][col] || 0; + }); + } + return jStat.map(arr, function(value) { return value - arg; }); + }, + + // matrix division + divide: function divide(arr, arg) { + if (isUsable(arg)) { + if (!isUsable(arg[0])) arg = [ arg ]; + return jStat.multiply(arr, jStat.inv(arg)); + } + return jStat.map(arr, function(value) { return value / arg; }); + }, + + // matrix multiplication + multiply: function multiply(arr, arg) { + var row, col, nrescols, sum, nrow, ncol, res, rescols; + // eg: arr = 2 arg = 3 -> 6 for res[0][0] statement closure + if (arr.length === undefined && arg.length === undefined) { + return arr * arg; + } + nrow = arr.length, + ncol = arr[0].length, + res = jStat.zeros(nrow, nrescols = (isUsable(arg)) ? arg[0].length : ncol), + rescols = 0; + if (isUsable(arg)) { + for (; rescols < nrescols; rescols++) { + for (row = 0; row < nrow; row++) { + sum = 0; + for (col = 0; col < ncol; col++) + sum += arr[row][col] * arg[col][rescols]; + res[row][rescols] = sum; + } + } + return (nrow === 1 && rescols === 1) ? res[0][0] : res; + } + return jStat.map(arr, function(value) { return value * arg; }); + }, + + // outer([1,2,3],[4,5,6]) + // === + // [[1],[2],[3]] times [[4,5,6]] + // -> + // [[4,5,6],[8,10,12],[12,15,18]] + outer:function outer(A, B) { + return jStat.multiply(A.map(function(t){ return [t] }), [B]); + }, + + + // Returns the dot product of two matricies + dot: function dot(arr, arg) { + if (!isUsable(arr[0])) arr = [ arr ]; + if (!isUsable(arg[0])) arg = [ arg ]; + // convert column to row vector + var left = (arr[0].length === 1 && arr.length !== 1) ? jStat.transpose(arr) : arr, + right = (arg[0].length === 1 && arg.length !== 1) ? jStat.transpose(arg) : arg, + res = [], + row = 0, + nrow = left.length, + ncol = left[0].length, + sum, col; + for (; row < nrow; row++) { + res[row] = []; + sum = 0; + for (col = 0; col < ncol; col++) + sum += left[row][col] * right[row][col]; + res[row] = sum; + } + return (res.length === 1) ? res[0] : res; + }, + + // raise every element by a scalar + pow: function pow(arr, arg) { + return jStat.map(arr, function(value) { return Math.pow(value, arg); }); + }, + + // exponentiate every element + exp: function exp(arr) { + return jStat.map(arr, function(value) { return Math.exp(value); }); + }, + + // generate the natural log of every element + log: function exp(arr) { + return jStat.map(arr, function(value) { return Math.log(value); }); + }, + + // generate the absolute values of the vector + abs: function abs(arr) { + return jStat.map(arr, function(value) { return Math.abs(value); }); + }, + + // computes the p-norm of the vector + // In the case that a matrix is passed, uses the first row as the vector + norm: function norm(arr, p) { + var nnorm = 0, + i = 0; + // check the p-value of the norm, and set for most common case + if (isNaN(p)) p = 2; + // check if multi-dimensional array, and make vector correction + if (isUsable(arr[0])) arr = arr[0]; + // vector norm + for (; i < arr.length; i++) { + nnorm += Math.pow(Math.abs(arr[i]), p); + } + return Math.pow(nnorm, 1 / p); + }, + + // computes the angle between two vectors in rads + // In case a matrix is passed, this uses the first row as the vector + angle: function angle(arr, arg) { + return Math.acos(jStat.dot(arr, arg) / (jStat.norm(arr) * jStat.norm(arg))); + }, + + // augment one matrix by another + // Note: this function returns a matrix, not a jStat object + aug: function aug(a, b) { + var newarr = []; + var i; + for (i = 0; i < a.length; i++) { + newarr.push(a[i].slice()); + } + for (i = 0; i < newarr.length; i++) { + push.apply(newarr[i], b[i]); + } + return newarr; + }, + + // The inv() function calculates the inverse of a matrix + // Create the inverse by augmenting the matrix by the identity matrix of the + // appropriate size, and then use G-J elimination on the augmented matrix. + inv: function inv(a) { + var rows = a.length; + var cols = a[0].length; + var b = jStat.identity(rows, cols); + var c = jStat.gauss_jordan(a, b); + var result = []; + var i = 0; + var j; + + //We need to copy the inverse portion to a new matrix to rid G-J artifacts + for (; i < rows; i++) { + result[i] = []; + for (j = cols; j < c[0].length; j++) + result[i][j - cols] = c[i][j]; + } + return result; + }, + + // calculate the determinant of a matrix + det: function det(a) { + var alen = a.length, + alend = alen * 2, + vals = new Array(alend), + rowshift = alen - 1, + colshift = alend - 1, + mrow = rowshift - alen + 1, + mcol = colshift, + i = 0, + result = 0, + j; + // check for special 2x2 case + if (alen === 2) { + return a[0][0] * a[1][1] - a[0][1] * a[1][0]; + } + for (; i < alend; i++) { + vals[i] = 1; + } + for (i = 0; i < alen; i++) { + for (j = 0; j < alen; j++) { + vals[(mrow < 0) ? mrow + alen : mrow ] *= a[i][j]; + vals[(mcol < alen) ? mcol + alen : mcol ] *= a[i][j]; + mrow++; + mcol--; + } + mrow = --rowshift - alen + 1; + mcol = --colshift; + } + for (i = 0; i < alen; i++) { + result += vals[i]; + } + for (; i < alend; i++) { + result -= vals[i]; + } + return result; + }, + + gauss_elimination: function gauss_elimination(a, b) { + var i = 0, + j = 0, + n = a.length, + m = a[0].length, + factor = 1, + sum = 0, + x = [], + maug, pivot, temp, k; + a = jStat.aug(a, b); + maug = a[0].length; + for(i = 0; i < n; i++) { + pivot = a[i][i]; + j = i; + for (k = i + 1; k < m; k++) { + if (pivot < Math.abs(a[k][i])) { + pivot = a[k][i]; + j = k; + } + } + if (j != i) { + for(k = 0; k < maug; k++) { + temp = a[i][k]; + a[i][k] = a[j][k]; + a[j][k] = temp; + } + } + for (j = i + 1; j < n; j++) { + factor = a[j][i] / a[i][i]; + for(k = i; k < maug; k++) { + a[j][k] = a[j][k] - factor * a[i][k]; + } + } + } + for (i = n - 1; i >= 0; i--) { + sum = 0; + for (j = i + 1; j<= n - 1; j++) { + sum = sum + x[j] * a[i][j]; + } + x[i] =(a[i][maug - 1] - sum) / a[i][i]; + } + return x; + }, + + gauss_jordan: function gauss_jordan(a, b) { + var m = jStat.aug(a, b); + var h = m.length; + var w = m[0].length; + var c = 0; + var x, y, y2; + // find max pivot + for (y = 0; y < h; y++) { + var maxrow = y; + for (y2 = y+1; y2 < h; y2++) { + if (Math.abs(m[y2][y]) > Math.abs(m[maxrow][y])) + maxrow = y2; + } + var tmp = m[y]; + m[y] = m[maxrow]; + m[maxrow] = tmp; + for (y2 = y+1; y2 < h; y2++) { + c = m[y2][y] / m[y][y]; + for (x = y; x < w; x++) { + m[y2][x] -= m[y][x] * c; + } + } + } + // backsubstitute + for (y = h-1; y >= 0; y--) { + c = m[y][y]; + for (y2 = 0; y2 < y; y2++) { + for (x = w-1; x > y-1; x--) { + m[y2][x] -= m[y][x] * m[y2][y] / c; + } + } + m[y][y] /= c; + for (x = h; x < w; x++) { + m[y][x] /= c; + } + } + return m; + }, + + // solve equation + // Ax=b + // A is upper triangular matrix + // A=[[1,2,3],[0,4,5],[0,6,7]] + // b=[1,2,3] + // triaUpSolve(A,b) // -> [2.666,0.1666,1.666] + // if you use matrix style + // A=[[1,2,3],[0,4,5],[0,6,7]] + // b=[[1],[2],[3]] + // will return [[2.666],[0.1666],[1.666]] + triaUpSolve: function triaUpSolve(A, b) { + var size = A[0].length; + var x = jStat.zeros(1, size)[0]; + var parts; + var matrix_mode = false; + + if (b[0].length != undefined) { + b = b.map(function(i){ return i[0] }); + matrix_mode = true; + } + + jStat.arange(size - 1, -1, -1).forEach(function(i) { + parts = jStat.arange(i + 1, size).map(function(j) { + return x[j] * A[i][j]; + }); + x[i] = (b[i] - jStat.sum(parts)) / A[i][i]; + }); + + if (matrix_mode) + return x.map(function(i){ return [i] }); + return x; + }, + + triaLowSolve: function triaLowSolve(A, b) { + // like to triaUpSolve but A is lower triangular matrix + var size = A[0].length; + var x = jStat.zeros(1, size)[0]; + var parts; + + var matrix_mode=false; + if (b[0].length != undefined) { + b = b.map(function(i){ return i[0] }); + matrix_mode = true; + } + + jStat.arange(size).forEach(function(i) { + parts = jStat.arange(i).map(function(j) { + return A[i][j] * x[j]; + }); + x[i] = (b[i] - jStat.sum(parts)) / A[i][i]; + }); + + if (matrix_mode) + return x.map(function(i){ return [i] }); + return x; + }, + + + // A -> [L,U] + // A=LU + // L is lower triangular matrix + // U is upper triangular matrix + lu: function lu(A) { + var size = A.length; + //var L=jStat.diagonal(jStat.ones(1,size)[0]); + var L = jStat.identity(size); + var R = jStat.zeros(A.length, A[0].length); + var parts; + jStat.arange(size).forEach(function(t) { + R[0][t] = A[0][t]; + }); + jStat.arange(1, size).forEach(function(l) { + jStat.arange(l).forEach(function(i) { + parts = jStat.arange(i).map(function(jj) { + return L[l][jj] * R[jj][i]; + }); + L[l][i] = (A[l][i] - jStat.sum(parts)) / R[i][i]; + }); + jStat.arange(l, size).forEach(function(j) { + parts = jStat.arange(l).map(function(jj) { + return L[l][jj] * R[jj][j]; + }); + R[l][j] = A[parts.length][j] - jStat.sum(parts); + }); + }); + return [L, R]; + }, + + // A -> T + // A=TT' + // T is lower triangular matrix + cholesky: function cholesky(A) { + var size = A.length; + var T = jStat.zeros(A.length, A[0].length); + var parts; + jStat.arange(size).forEach(function(i) { + parts = jStat.arange(i).map(function(t) { + return Math.pow(T[i][t],2); + }); + T[i][i] = Math.sqrt(A[i][i] - jStat.sum(parts)); + jStat.arange(i + 1, size).forEach(function(j) { + parts = jStat.arange(i).map(function(t) { + return T[i][t] * T[j][t]; + }); + T[j][i] = (A[i][j] - jStat.sum(parts)) / T[i][i]; + }); + }); + return T; + }, + + + gauss_jacobi: function gauss_jacobi(a, b, x, r) { + var i = 0; + var j = 0; + var n = a.length; + var l = []; + var u = []; + var d = []; + var xv, c, h, xk; + for (; i < n; i++) { + l[i] = []; + u[i] = []; + d[i] = []; + for (j = 0; j < n; j++) { + if (i > j) { + l[i][j] = a[i][j]; + u[i][j] = d[i][j] = 0; + } else if (i < j) { + u[i][j] = a[i][j]; + l[i][j] = d[i][j] = 0; + } else { + d[i][j] = a[i][j]; + l[i][j] = u[i][j] = 0; + } + } + } + h = jStat.multiply(jStat.multiply(jStat.inv(d), jStat.add(l, u)), -1); + c = jStat.multiply(jStat.inv(d), b); + xv = x; + xk = jStat.add(jStat.multiply(h, x), c); + i = 2; + while (Math.abs(jStat.norm(jStat.subtract(xk,xv))) > r) { + xv = xk; + xk = jStat.add(jStat.multiply(h, xv), c); + i++; + } + return xk; + }, + + gauss_seidel: function gauss_seidel(a, b, x, r) { + var i = 0; + var n = a.length; + var l = []; + var u = []; + var d = []; + var j, xv, c, h, xk; + for (; i < n; i++) { + l[i] = []; + u[i] = []; + d[i] = []; + for (j = 0; j < n; j++) { + if (i > j) { + l[i][j] = a[i][j]; + u[i][j] = d[i][j] = 0; + } else if (i < j) { + u[i][j] = a[i][j]; + l[i][j] = d[i][j] = 0; + } else { + d[i][j] = a[i][j]; + l[i][j] = u[i][j] = 0; + } + } + } + h = jStat.multiply(jStat.multiply(jStat.inv(jStat.add(d, l)), u), -1); + c = jStat.multiply(jStat.inv(jStat.add(d, l)), b); + xv = x; + xk = jStat.add(jStat.multiply(h, x), c); + i = 2; + while (Math.abs(jStat.norm(jStat.subtract(xk, xv))) > r) { + xv = xk; + xk = jStat.add(jStat.multiply(h, xv), c); + i = i + 1; + } + return xk; + }, + + SOR: function SOR(a, b, x, r, w) { + var i = 0; + var n = a.length; + var l = []; + var u = []; + var d = []; + var j, xv, c, h, xk; + for (; i < n; i++) { + l[i] = []; + u[i] = []; + d[i] = []; + for (j = 0; j < n; j++) { + if (i > j) { + l[i][j] = a[i][j]; + u[i][j] = d[i][j] = 0; + } else if (i < j) { + u[i][j] = a[i][j]; + l[i][j] = d[i][j] = 0; + } else { + d[i][j] = a[i][j]; + l[i][j] = u[i][j] = 0; + } + } + } + h = jStat.multiply(jStat.inv(jStat.add(d, jStat.multiply(l, w))), + jStat.subtract(jStat.multiply(d, 1 - w), + jStat.multiply(u, w))); + c = jStat.multiply(jStat.multiply(jStat.inv(jStat.add(d, + jStat.multiply(l, w))), b), w); + xv = x; + xk = jStat.add(jStat.multiply(h, x), c); + i = 2; + while (Math.abs(jStat.norm(jStat.subtract(xk, xv))) > r) { + xv = xk; + xk = jStat.add(jStat.multiply(h, xv), c); + i++; + } + return xk; + }, + + householder: function householder(a) { + var m = a.length; + var n = a[0].length; + var i = 0; + var w = []; + var p = []; + var alpha, r, k, j, factor; + for (; i < m - 1; i++) { + alpha = 0; + for (j = i + 1; j < n; j++) + alpha += (a[j][i] * a[j][i]); + factor = (a[i + 1][i] > 0) ? -1 : 1; + alpha = factor * Math.sqrt(alpha); + r = Math.sqrt((((alpha * alpha) - a[i + 1][i] * alpha) / 2)); + w = jStat.zeros(m, 1); + w[i + 1][0] = (a[i + 1][i] - alpha) / (2 * r); + for (k = i + 2; k < m; k++) w[k][0] = a[k][i] / (2 * r); + p = jStat.subtract(jStat.identity(m, n), + jStat.multiply(jStat.multiply(w, jStat.transpose(w)), 2)); + a = jStat.multiply(p, jStat.multiply(a, p)); + } + return a; + }, + + // A -> [Q,R] + // Q is orthogonal matrix + // R is upper triangular + QR: (function() { + // x -> Q + // find a orthogonal matrix Q st. + // Qx=y + // y is [||x||,0,0,...] + + // quick ref + var sum = jStat.sum; + var range = jStat.arange; + + function qr2(x) { + // quick impletation + // https://www.stat.wisc.edu/~larget/math496/qr.html + + var n = x.length; + var p = x[0].length; + + var r = jStat.zeros(p, p); + x = jStat.copy(x); + + var i,j,k; + for(j = 0; j < p; j++){ + r[j][j] = Math.sqrt(sum(range(n).map(function(i){ + return x[i][j] * x[i][j]; + }))); + for(i = 0; i < n; i++){ + x[i][j] = x[i][j] / r[j][j]; + } + for(k = j+1; k < p; k++){ + r[j][k] = sum(range(n).map(function(i){ + return x[i][j] * x[i][k]; + })); + for(i = 0; i < n; i++){ + x[i][k] = x[i][k] - x[i][j]*r[j][k]; + } + } + } + return [x, r]; + } + + return qr2; + }()), + + lstsq: (function() { + // solve least squard problem for Ax=b as QR decomposition way if b is + // [[b1],[b2],[b3]] form will return [[x1],[x2],[x3]] array form solution + // else b is [b1,b2,b3] form will return [x1,x2,x3] array form solution + function R_I(A) { + A = jStat.copy(A); + var size = A.length; + var I = jStat.identity(size); + jStat.arange(size - 1, -1, -1).forEach(function(i) { + jStat.sliceAssign( + I, { row: i }, jStat.divide(jStat.slice(I, { row: i }), A[i][i])); + jStat.sliceAssign( + A, { row: i }, jStat.divide(jStat.slice(A, { row: i }), A[i][i])); + jStat.arange(i).forEach(function(j) { + var c = jStat.multiply(A[j][i], -1); + var Aj = jStat.slice(A, { row: j }); + var cAi = jStat.multiply(jStat.slice(A, { row: i }), c); + jStat.sliceAssign(A, { row: j }, jStat.add(Aj, cAi)); + var Ij = jStat.slice(I, { row: j }); + var cIi = jStat.multiply(jStat.slice(I, { row: i }), c); + jStat.sliceAssign(I, { row: j }, jStat.add(Ij, cIi)); + }); + }); + return I; + } + + function qr_solve(A, b){ + var array_mode = false; + if (b[0].length === undefined) { + // [c1,c2,c3] mode + b = b.map(function(x){ return [x] }); + array_mode = true; + } + var QR = jStat.QR(A); + var Q = QR[0]; + var R = QR[1]; + var attrs = A[0].length; + var Q1 = jStat.slice(Q,{col:{end:attrs}}); + var R1 = jStat.slice(R,{row:{end:attrs}}); + var RI = R_I(R1); + var Q2 = jStat.transpose(Q1); + + if(Q2[0].length === undefined){ + Q2 = [Q2]; // The confusing jStat.multifly implementation threat nature process again. + } + + var x = jStat.multiply(jStat.multiply(RI, Q2), b); + + if(x.length === undefined){ + x = [[x]]; // The confusing jStat.multifly implementation threat nature process again. + } + + + if (array_mode) + return x.map(function(i){ return i[0] }); + return x; + } + + return qr_solve; + }()), + + jacobi: function jacobi(a) { + var condition = 1; + var n = a.length; + var e = jStat.identity(n, n); + var ev = []; + var b, i, j, p, q, maxim, theta, s; + // condition === 1 only if tolerance is not reached + while (condition === 1) { + maxim = a[0][1]; + p = 0; + q = 1; + for (i = 0; i < n; i++) { + for (j = 0; j < n; j++) { + if (i != j) { + if (maxim < Math.abs(a[i][j])) { + maxim = Math.abs(a[i][j]); + p = i; + q = j; + } + } + } + } + if (a[p][p] === a[q][q]) + theta = (a[p][q] > 0) ? Math.PI / 4 : -Math.PI / 4; + else + theta = Math.atan(2 * a[p][q] / (a[p][p] - a[q][q])) / 2; + s = jStat.identity(n, n); + s[p][p] = Math.cos(theta); + s[p][q] = -Math.sin(theta); + s[q][p] = Math.sin(theta); + s[q][q] = Math.cos(theta); + // eigen vector matrix + e = jStat.multiply(e, s); + b = jStat.multiply(jStat.multiply(jStat.inv(s), a), s); + a = b; + condition = 0; + for (i = 1; i < n; i++) { + for (j = 1; j < n; j++) { + if (i != j && Math.abs(a[i][j]) > 0.001) { + condition = 1; + } + } + } + } + for (i = 0; i < n; i++) ev.push(a[i][i]); + //returns both the eigenvalue and eigenmatrix + return [e, ev]; + }, + + rungekutta: function rungekutta(f, h, p, t_j, u_j, order) { + var k1, k2, u_j1, k3, k4; + if (order === 2) { + while (t_j <= p) { + k1 = h * f(t_j, u_j); + k2 = h * f(t_j + h, u_j + k1); + u_j1 = u_j + (k1 + k2) / 2; + u_j = u_j1; + t_j = t_j + h; + } + } + if (order === 4) { + while (t_j <= p) { + k1 = h * f(t_j, u_j); + k2 = h * f(t_j + h / 2, u_j + k1 / 2); + k3 = h * f(t_j + h / 2, u_j + k2 / 2); + k4 = h * f(t_j +h, u_j + k3); + u_j1 = u_j + (k1 + 2 * k2 + 2 * k3 + k4) / 6; + u_j = u_j1; + t_j = t_j + h; + } + } + return u_j; + }, + + romberg: function romberg(f, a, b, order) { + var i = 0; + var h = (b - a) / 2; + var x = []; + var h1 = []; + var g = []; + var m, a1, j, k, I; + while (i < order / 2) { + I = f(a); + for (j = a, k = 0; j <= b; j = j + h, k++) x[k] = j; + m = x.length; + for (j = 1; j < m - 1; j++) { + I += (((j % 2) !== 0) ? 4 : 2) * f(x[j]); + } + I = (h / 3) * (I + f(b)); + g[i] = I; + h /= 2; + i++; + } + a1 = g.length; + m = 1; + while (a1 !== 1) { + for (j = 0; j < a1 - 1; j++) + h1[j] = ((Math.pow(4, m)) * g[j + 1] - g[j]) / (Math.pow(4, m) - 1); + a1 = h1.length; + g = h1; + h1 = []; + m++; + } + return g; + }, + + richardson: function richardson(X, f, x, h) { + function pos(X, x) { + var i = 0; + var n = X.length; + var p; + for (; i < n; i++) + if (X[i] === x) p = i; + return p; + } + var h_min = Math.abs(x - X[pos(X, x) + 1]); + var i = 0; + var g = []; + var h1 = []; + var y1, y2, m, a, j; + while (h >= h_min) { + y1 = pos(X, x + h); + y2 = pos(X, x); + g[i] = (f[y1] - 2 * f[y2] + f[2 * y2 - y1]) / (h * h); + h /= 2; + i++; + } + a = g.length; + m = 1; + while (a != 1) { + for (j = 0; j < a - 1; j++) + h1[j] = ((Math.pow(4, m)) * g[j + 1] - g[j]) / (Math.pow(4, m) - 1); + a = h1.length; + g = h1; + h1 = []; + m++; + } + return g; + }, + + simpson: function simpson(f, a, b, n) { + var h = (b - a) / n; + var I = f(a); + var x = []; + var j = a; + var k = 0; + var i = 1; + var m; + for (; j <= b; j = j + h, k++) + x[k] = j; + m = x.length; + for (; i < m - 1; i++) { + I += ((i % 2 !== 0) ? 4 : 2) * f(x[i]); + } + return (h / 3) * (I + f(b)); + }, + + hermite: function hermite(X, F, dF, value) { + var n = X.length; + var p = 0; + var i = 0; + var l = []; + var dl = []; + var A = []; + var B = []; + var j; + for (; i < n; i++) { + l[i] = 1; + for (j = 0; j < n; j++) { + if (i != j) l[i] *= (value - X[j]) / (X[i] - X[j]); + } + dl[i] = 0; + for (j = 0; j < n; j++) { + if (i != j) dl[i] += 1 / (X [i] - X[j]); + } + A[i] = (1 - 2 * (value - X[i]) * dl[i]) * (l[i] * l[i]); + B[i] = (value - X[i]) * (l[i] * l[i]); + p += (A[i] * F[i] + B[i] * dF[i]); + } + return p; + }, + + lagrange: function lagrange(X, F, value) { + var p = 0; + var i = 0; + var j, l; + var n = X.length; + for (; i < n; i++) { + l = F[i]; + for (j = 0; j < n; j++) { + // calculating the lagrange polynomial L_i + if (i != j) l *= (value - X[j]) / (X[i] - X[j]); + } + // adding the lagrange polynomials found above + p += l; + } + return p; + }, + + cubic_spline: function cubic_spline(X, F, value) { + var n = X.length; + var i = 0, j; + var A = []; + var B = []; + var alpha = []; + var c = []; + var h = []; + var b = []; + var d = []; + for (; i < n - 1; i++) + h[i] = X[i + 1] - X[i]; + alpha[0] = 0; + for (i = 1; i < n - 1; i++) { + alpha[i] = (3 / h[i]) * (F[i + 1] - F[i]) - + (3 / h[i-1]) * (F[i] - F[i-1]); + } + for (i = 1; i < n - 1; i++) { + A[i] = []; + B[i] = []; + A[i][i-1] = h[i-1]; + A[i][i] = 2 * (h[i - 1] + h[i]); + A[i][i+1] = h[i]; + B[i][0] = alpha[i]; + } + c = jStat.multiply(jStat.inv(A), B); + for (j = 0; j < n - 1; j++) { + b[j] = (F[j + 1] - F[j]) / h[j] - h[j] * (c[j + 1][0] + 2 * c[j][0]) / 3; + d[j] = (c[j + 1][0] - c[j][0]) / (3 * h[j]); + } + for (j = 0; j < n; j++) { + if (X[j] > value) break; + } + j -= 1; + return F[j] + (value - X[j]) * b[j] + jStat.sq(value-X[j]) * + c[j] + (value - X[j]) * jStat.sq(value - X[j]) * d[j]; + }, + + gauss_quadrature: function gauss_quadrature() { + throw new Error('gauss_quadrature not yet implemented'); + }, + + PCA: function PCA(X) { + var m = X.length; + var n = X[0].length; + var i = 0; + var j, temp1; + var u = []; + var D = []; + var result = []; + var temp2 = []; + var Y = []; + var Bt = []; + var B = []; + var C = []; + var V = []; + var Vt = []; + for (i = 0; i < m; i++) { + u[i] = jStat.sum(X[i]) / n; + } + for (i = 0; i < n; i++) { + B[i] = []; + for(j = 0; j < m; j++) { + B[i][j] = X[j][i] - u[j]; + } + } + B = jStat.transpose(B); + for (i = 0; i < m; i++) { + C[i] = []; + for (j = 0; j < m; j++) { + C[i][j] = (jStat.dot([B[i]], [B[j]])) / (n - 1); + } + } + result = jStat.jacobi(C); + V = result[0]; + D = result[1]; + Vt = jStat.transpose(V); + for (i = 0; i < D.length; i++) { + for (j = i; j < D.length; j++) { + if(D[i] < D[j]) { + temp1 = D[i]; + D[i] = D[j]; + D[j] = temp1; + temp2 = Vt[i]; + Vt[i] = Vt[j]; + Vt[j] = temp2; + } + } + } + Bt = jStat.transpose(B); + for (i = 0; i < m; i++) { + Y[i] = []; + for (j = 0; j < Bt.length; j++) { + Y[i][j] = jStat.dot([Vt[i]], [Bt[j]]); + } + } + return [X, D, Vt, Y]; + } +}); + +// extend jStat.fn with methods that require one argument +(function(funcs) { + for (var i = 0; i < funcs.length; i++) (function(passfunc) { + jStat.fn[passfunc] = function(arg, func) { + var tmpthis = this; + // check for callback + if (func) { + setTimeout(function() { + func.call(tmpthis, jStat.fn[passfunc].call(tmpthis, arg)); + }, 15); + return this; + } + if (typeof jStat[passfunc](this, arg) === 'number') + return jStat[passfunc](this, arg); + else + return jStat(jStat[passfunc](this, arg)); + }; + }(funcs[i])); +}('add divide multiply subtract dot pow exp log abs norm angle'.split(' '))); + +}(jStat, Math)); +(function(jStat, Math) { + +var slice = [].slice; +var isNumber = jStat.utils.isNumber; +var isArray = jStat.utils.isArray; + +// flag==true denotes use of sample standard deviation +// Z Statistics +jStat.extend({ + // 2 different parameter lists: + // (value, mean, sd) + // (value, array, flag) + zscore: function zscore() { + var args = slice.call(arguments); + if (isNumber(args[1])) { + return (args[0] - args[1]) / args[2]; + } + return (args[0] - jStat.mean(args[1])) / jStat.stdev(args[1], args[2]); + }, + + // 3 different paramter lists: + // (value, mean, sd, sides) + // (zscore, sides) + // (value, array, sides, flag) + ztest: function ztest() { + var args = slice.call(arguments); + var z; + if (isArray(args[1])) { + // (value, array, sides, flag) + z = jStat.zscore(args[0],args[1],args[3]); + return (args[2] === 1) ? + (jStat.normal.cdf(-Math.abs(z), 0, 1)) : + (jStat.normal.cdf(-Math.abs(z), 0, 1)*2); + } else { + if (args.length > 2) { + // (value, mean, sd, sides) + z = jStat.zscore(args[0],args[1],args[2]); + return (args[3] === 1) ? + (jStat.normal.cdf(-Math.abs(z),0,1)) : + (jStat.normal.cdf(-Math.abs(z),0,1)* 2); + } else { + // (zscore, sides) + z = args[0]; + return (args[1] === 1) ? + (jStat.normal.cdf(-Math.abs(z),0,1)) : + (jStat.normal.cdf(-Math.abs(z),0,1)*2); + } + } + } +}); + +jStat.extend(jStat.fn, { + zscore: function zscore(value, flag) { + return (value - this.mean()) / this.stdev(flag); + }, + + ztest: function ztest(value, sides, flag) { + var zscore = Math.abs(this.zscore(value, flag)); + return (sides === 1) ? + (jStat.normal.cdf(-zscore, 0, 1)) : + (jStat.normal.cdf(-zscore, 0, 1) * 2); + } +}); + +// T Statistics +jStat.extend({ + // 2 parameter lists + // (value, mean, sd, n) + // (value, array) + tscore: function tscore() { + var args = slice.call(arguments); + return (args.length === 4) ? + ((args[0] - args[1]) / (args[2] / Math.sqrt(args[3]))) : + ((args[0] - jStat.mean(args[1])) / + (jStat.stdev(args[1], true) / Math.sqrt(args[1].length))); + }, + + // 3 different paramter lists: + // (value, mean, sd, n, sides) + // (tscore, n, sides) + // (value, array, sides) + ttest: function ttest() { + var args = slice.call(arguments); + var tscore; + if (args.length === 5) { + tscore = Math.abs(jStat.tscore(args[0], args[1], args[2], args[3])); + return (args[4] === 1) ? + (jStat.studentt.cdf(-tscore, args[3]-1)) : + (jStat.studentt.cdf(-tscore, args[3]-1)*2); + } + if (isNumber(args[1])) { + tscore = Math.abs(args[0]); + return (args[2] == 1) ? + (jStat.studentt.cdf(-tscore, args[1]-1)) : + (jStat.studentt.cdf(-tscore, args[1]-1) * 2); + } + tscore = Math.abs(jStat.tscore(args[0], args[1])); + return (args[2] == 1) ? + (jStat.studentt.cdf(-tscore, args[1].length-1)) : + (jStat.studentt.cdf(-tscore, args[1].length-1) * 2); + } +}); + +jStat.extend(jStat.fn, { + tscore: function tscore(value) { + return (value - this.mean()) / (this.stdev(true) / Math.sqrt(this.cols())); + }, + + ttest: function ttest(value, sides) { + return (sides === 1) ? + (1 - jStat.studentt.cdf(Math.abs(this.tscore(value)), this.cols()-1)) : + (jStat.studentt.cdf(-Math.abs(this.tscore(value)), this.cols()-1)*2); + } +}); + +// F Statistics +jStat.extend({ + // Paramter list is as follows: + // (array1, array2, array3, ...) + // or it is an array of arrays + // array of arrays conversion + anovafscore: function anovafscore() { + var args = slice.call(arguments), + expVar, sample, sampMean, sampSampMean, tmpargs, unexpVar, i, j; + if (args.length === 1) { + tmpargs = new Array(args[0].length); + for (i = 0; i < args[0].length; i++) { + tmpargs[i] = args[0][i]; + } + args = tmpargs; + } + // Builds sample array + sample = new Array(); + for (i = 0; i < args.length; i++) { + sample = sample.concat(args[i]); + } + sampMean = jStat.mean(sample); + // Computes the explained variance + expVar = 0; + for (i = 0; i < args.length; i++) { + expVar = expVar + args[i].length * Math.pow(jStat.mean(args[i]) - sampMean, 2); + } + expVar /= (args.length - 1); + // Computes unexplained variance + unexpVar = 0; + for (i = 0; i < args.length; i++) { + sampSampMean = jStat.mean(args[i]); + for (j = 0; j < args[i].length; j++) { + unexpVar += Math.pow(args[i][j] - sampSampMean, 2); + } + } + unexpVar /= (sample.length - args.length); + return expVar / unexpVar; + }, + + // 2 different paramter setups + // (array1, array2, array3, ...) + // (anovafscore, df1, df2) + anovaftest: function anovaftest() { + var args = slice.call(arguments), + df1, df2, n, i; + if (isNumber(args[0])) { + return 1 - jStat.centralF.cdf(args[0], args[1], args[2]); + } + var anovafscore = jStat.anovafscore(args); + df1 = args.length - 1; + n = 0; + for (i = 0; i < args.length; i++) { + n = n + args[i].length; + } + df2 = n - df1 - 1; + return 1 - jStat.centralF.cdf(anovafscore, df1, df2); + }, + + ftest: function ftest(fscore, df1, df2) { + return 1 - jStat.centralF.cdf(fscore, df1, df2); + } +}); + +jStat.extend(jStat.fn, { + anovafscore: function anovafscore() { + return jStat.anovafscore(this.toArray()); + }, + + anovaftes: function anovaftes() { + var n = 0; + var i; + for (i = 0; i < this.length; i++) { + n = n + this[i].length; + } + return jStat.ftest(this.anovafscore(), this.length - 1, n - this.length); + } +}); + +// Tukey's range test +jStat.extend({ + // 2 parameter lists + // (mean1, mean2, n1, n2, sd) + // (array1, array2, sd) + qscore: function qscore() { + var args = slice.call(arguments); + var mean1, mean2, n1, n2, sd; + if (isNumber(args[0])) { + mean1 = args[0]; + mean2 = args[1]; + n1 = args[2]; + n2 = args[3]; + sd = args[4]; + } else { + mean1 = jStat.mean(args[0]); + mean2 = jStat.mean(args[1]); + n1 = args[0].length; + n2 = args[1].length; + sd = args[2]; + } + return Math.abs(mean1 - mean2) / (sd * Math.sqrt((1 / n1 + 1 / n2) / 2)); + }, + + // 3 different parameter lists: + // (qscore, n, k) + // (mean1, mean2, n1, n2, sd, n, k) + // (array1, array2, sd, n, k) + qtest: function qtest() { + var args = slice.call(arguments); + + var qscore; + if (args.length === 3) { + qscore = args[0]; + args = args.slice(1); + } else if (args.length === 7) { + qscore = jStat.qscore(args[0], args[1], args[2], args[3], args[4]); + args = args.slice(5); + } else { + qscore = jStat.qscore(args[0], args[1], args[2]); + args = args.slice(3); + } + + var n = args[0]; + var k = args[1]; + + return 1 - jStat.tukey.cdf(qscore, k, n - k); + }, + + tukeyhsd: function tukeyhsd(arrays) { + var sd = jStat.pooledstdev(arrays); + var means = arrays.map(function (arr) {return jStat.mean(arr);}); + var n = arrays.reduce(function (n, arr) {return n + arr.length;}, 0); + + var results = []; + for (var i = 0; i < arrays.length; ++i) { + for (var j = i + 1; j < arrays.length; ++j) { + var p = jStat.qtest(means[i], means[j], arrays[i].length, arrays[j].length, sd, n, arrays.length); + results.push([[i, j], p]); + } + } + + return results; + } +}); + +// Error Bounds +jStat.extend({ + // 2 different parameter setups + // (value, alpha, sd, n) + // (value, alpha, array) + normalci: function normalci() { + var args = slice.call(arguments), + ans = new Array(2), + change; + if (args.length === 4) { + change = Math.abs(jStat.normal.inv(args[1] / 2, 0, 1) * + args[2] / Math.sqrt(args[3])); + } else { + change = Math.abs(jStat.normal.inv(args[1] / 2, 0, 1) * + jStat.stdev(args[2]) / Math.sqrt(args[2].length)); + } + ans[0] = args[0] - change; + ans[1] = args[0] + change; + return ans; + }, + + // 2 different parameter setups + // (value, alpha, sd, n) + // (value, alpha, array) + tci: function tci() { + var args = slice.call(arguments), + ans = new Array(2), + change; + if (args.length === 4) { + change = Math.abs(jStat.studentt.inv(args[1] / 2, args[3] - 1) * + args[2] / Math.sqrt(args[3])); + } else { + change = Math.abs(jStat.studentt.inv(args[1] / 2, args[2].length - 1) * + jStat.stdev(args[2], true) / Math.sqrt(args[2].length)); + } + ans[0] = args[0] - change; + ans[1] = args[0] + change; + return ans; + }, + + significant: function significant(pvalue, alpha) { + return pvalue < alpha; + } +}); + +jStat.extend(jStat.fn, { + normalci: function normalci(value, alpha) { + return jStat.normalci(value, alpha, this.toArray()); + }, + + tci: function tci(value, alpha) { + return jStat.tci(value, alpha, this.toArray()); + } +}); + +// internal method for calculating the z-score for a difference of proportions test +function differenceOfProportions(p1, n1, p2, n2) { + if (p1 > 1 || p2 > 1 || p1 <= 0 || p2 <= 0) { + throw new Error("Proportions should be greater than 0 and less than 1") + } + var pooled = (p1 * n1 + p2 * n2) / (n1 + n2); + var se = Math.sqrt(pooled * (1 - pooled) * ((1/n1) + (1/n2))); + return (p1 - p2) / se; +} + +// Difference of Proportions +jStat.extend(jStat.fn, { + oneSidedDifferenceOfProportions: function oneSidedDifferenceOfProportions(p1, n1, p2, n2) { + var z = differenceOfProportions(p1, n1, p2, n2); + return jStat.ztest(z, 1); + }, + + twoSidedDifferenceOfProportions: function twoSidedDifferenceOfProportions(p1, n1, p2, n2) { + var z = differenceOfProportions(p1, n1, p2, n2); + return jStat.ztest(z, 2); + } +}); + +}(jStat, Math)); +jStat.models = (function(){ + function sub_regress(exog) { + var var_count = exog[0].length; + var modelList = jStat.arange(var_count).map(function(endog_index) { + var exog_index = + jStat.arange(var_count).filter(function(i){return i!==endog_index}); + return ols(jStat.col(exog, endog_index).map(function(x){ return x[0] }), + jStat.col(exog, exog_index)) + }); + return modelList; + } + + // do OLS model regress + // exog have include const columns ,it will not generate it .In fact, exog is + // "design matrix" look at + //https://en.wikipedia.org/wiki/Design_matrix + function ols(endog, exog) { + var nobs = endog.length; + var df_model = exog[0].length - 1; + var df_resid = nobs-df_model - 1; + var coef = jStat.lstsq(exog, endog); + var predict = + jStat.multiply(exog, coef.map(function(x) { return [x] })) + .map(function(p) { return p[0] }); + var resid = jStat.subtract(endog, predict); + var ybar = jStat.mean(endog); + // constant cause problem + // var SST = jStat.sum(endog.map(function(y) { + // return Math.pow(y-ybar,2); + // })); + var SSE = jStat.sum(predict.map(function(f) { + return Math.pow(f - ybar, 2); + })); + var SSR = jStat.sum(endog.map(function(y, i) { + return Math.pow(y - predict[i], 2); + })); + var SST = SSE + SSR; + var R2 = (SSE / SST); + return { + exog:exog, + endog:endog, + nobs:nobs, + df_model:df_model, + df_resid:df_resid, + coef:coef, + predict:predict, + resid:resid, + ybar:ybar, + SST:SST, + SSE:SSE, + SSR:SSR, + R2:R2 + }; + } + + // H0: b_I=0 + // H1: b_I!=0 + function t_test(model) { + var subModelList = sub_regress(model.exog); + //var sigmaHat=jStat.stdev(model.resid); + var sigmaHat = Math.sqrt(model.SSR / (model.df_resid)); + var seBetaHat = subModelList.map(function(mod) { + var SST = mod.SST; + var R2 = mod.R2; + return sigmaHat / Math.sqrt(SST * (1 - R2)); + }); + var tStatistic = model.coef.map(function(coef, i) { + return (coef - 0) / seBetaHat[i]; + }); + var pValue = tStatistic.map(function(t) { + var leftppf = jStat.studentt.cdf(t, model.df_resid); + return (leftppf > 0.5 ? 1 - leftppf : leftppf) * 2; + }); + var c = jStat.studentt.inv(0.975, model.df_resid); + var interval95 = model.coef.map(function(coef, i) { + var d = c * seBetaHat[i]; + return [coef - d, coef + d]; + }); + return { + se: seBetaHat, + t: tStatistic, + p: pValue, + sigmaHat: sigmaHat, + interval95: interval95 + }; + } + + function F_test(model) { + var F_statistic = + (model.R2 / model.df_model) / ((1 - model.R2) / model.df_resid); + var fcdf = function(x, n1, n2) { + return jStat.beta.cdf(x / (n2 / n1 + x), n1 / 2, n2 / 2) + }; + var pvalue = 1 - fcdf(F_statistic, model.df_model, model.df_resid); + return { F_statistic: F_statistic, pvalue: pvalue }; + } + + function ols_wrap(endog, exog) { + var model = ols(endog,exog); + var ttest = t_test(model); + var ftest = F_test(model); + // Provide the Wherry / Ezekiel / McNemar / Cohen Adjusted R^2 + // Which matches the 'adjusted R^2' provided by R's lm package + var adjust_R2 = + 1 - (1 - model.R2) * ((model.nobs - 1) / (model.df_resid)); + model.t = ttest; + model.f = ftest; + model.adjust_R2 = adjust_R2; + return model; + } + + return { ols: ols_wrap }; +})(); +//To regress, simply build X matrix +//(append column of 1's) using +//buildxmatrix and build the Y +//matrix using buildymatrix +//(simply the transpose) +//and run regress. + + + +//Regressions + +jStat.extend({ + buildxmatrix: function buildxmatrix(){ + //Parameters will be passed in as such + //(array1,array2,array3,...) + //as (x1,x2,x3,...) + //needs to be (1,x1,x2,x3,...) + var matrixRows = new Array(arguments.length); + for(var i=0;i1){ + result = []; + for (i = 0; i < A.rows(); i++) { + result[i] = []; + for (j = 0; j < B.cols(); j++) { + sum = 0; + for (k = 0; k < A.cols(); k++) { + sum += A.toArray()[i][k] * B.toArray()[k][j]; + } + result[i][j] = sum; + } + } + return jStat(result); + } + result = []; + for (i = 0; i < A.rows(); i++) { + result[i] = []; + for (j = 0; j < B.cols(); j++) { + sum = 0; + for (k = 0; k < A.cols(); k++) { + sum += A.toArray()[i][k] * B.toArray()[j]; + } + result[i][j] = sum; + } + } + return jStat(result); + } + }, + + //regress and regresst to be fixed + + regress: function regress(jMatX,jMatY){ + //print("regressin!"); + //print(jMatX.toArray()); + var innerinv = jStat.xtranspxinv(jMatX); + //print(innerinv); + var xtransp = jMatX.transpose(); + var next = jStat.matrixmult(jStat(innerinv),xtransp); + return jStat.matrixmult(next,jMatY); + + }, + + regresst: function regresst(jMatX,jMatY,sides){ + var beta = jStat.regress(jMatX,jMatY); + + var compile = {}; + compile.anova = {}; + var jMatYBar = jStat.jMatYBar(jMatX, beta); + compile.yBar = jMatYBar; + var yAverage = jMatY.mean(); + compile.anova.residuals = jStat.residuals(jMatY, jMatYBar); + + compile.anova.ssr = jStat.ssr(jMatYBar, yAverage); + compile.anova.msr = compile.anova.ssr / (jMatX[0].length - 1); + + compile.anova.sse = jStat.sse(jMatY, jMatYBar); + compile.anova.mse = + compile.anova.sse / (jMatY.length - (jMatX[0].length - 1) - 1); + + compile.anova.sst = jStat.sst(jMatY, yAverage); + compile.anova.mst = compile.anova.sst / (jMatY.length - 1); + + compile.anova.r2 = 1 - (compile.anova.sse / compile.anova.sst); + if (compile.anova.r2 < 0) compile.anova.r2 = 0; + + compile.anova.fratio = compile.anova.msr / compile.anova.mse; + compile.anova.pvalue = + jStat.anovaftest(compile.anova.fratio, + jMatX[0].length - 1, + jMatY.length - (jMatX[0].length - 1) - 1); + + compile.anova.rmse = Math.sqrt(compile.anova.mse); + + compile.anova.r2adj = 1 - (compile.anova.mse / compile.anova.mst); + if (compile.anova.r2adj < 0) compile.anova.r2adj = 0; + + compile.stats = new Array(jMatX[0].length); + var covar = jStat.xtranspxinv(jMatX); + var sds, ts, ps; + + for(var i=0; i', '>=', '<', '<=', '=', '<>']; +var TOKEN_TYPE_OPERATOR = 'operator'; +var TOKEN_TYPE_LITERAL = 'literal'; +var SUPPORTED_TOKENS = [TOKEN_TYPE_OPERATOR, TOKEN_TYPE_LITERAL]; + +var TOKEN_TYPE_OPERATOR_1 = TOKEN_TYPE_OPERATOR; +var TOKEN_TYPE_LITERAL_1 = TOKEN_TYPE_LITERAL; + +/** + * Create token which describe passed symbol/value. + * + * @param {String} value Value/Symbol to describe. + * @param {String} type Type of the token 'operator' or 'literal'. + * @return {Object} + */ +function createToken(value, type) { + if (SUPPORTED_TOKENS.indexOf(type) === -1) { + throw new Error('Unsupported token type: ' + type); + } + + return { + value: value, + type: type, + }; +} + +/** + * Tries to cast numeric values to their type passed as a string. + * + * @param {*} value + * @return {*} + */ +function castValueToCorrectType(value) { + if (typeof value !== 'string') { + return value; + } + + if (/^\d+(\.\d+)?$/.test(value)) { + value = value.indexOf('.') === -1 ? parseInt(value, 10) : parseFloat(value); + } + + return value; +} + +/** + * Generate stream of tokens from passed expression. + * + * @param {String} expression + * @return {String[]} + */ +function tokenizeExpression(expression) { + var expressionLength = expression.length; + var tokens = []; + var cursorIndex = 0; + var processedValue = ''; + var processedSymbol = ''; + + while (cursorIndex < expressionLength) { + var char = expression.charAt(cursorIndex); + + switch (char) { + case '>': + case '<': + case '=': + processedSymbol = processedSymbol + char; + + if (processedValue.length > 0) { + tokens.push(processedValue); + processedValue = ''; + } + break; + default: + if (processedSymbol.length > 0) { + tokens.push(processedSymbol); + processedSymbol = ''; + } + + processedValue = processedValue + char; + break; + } + cursorIndex++; + } + + if (processedValue.length > 0) { + tokens.push(processedValue); + } + if (processedSymbol.length > 0) { + tokens.push(processedSymbol); + } + + return tokens; +} +/** + * Analyze and convert tokens to an object which describes their meaning. + * + * @param {String[]} tokens + * @return {Object[]} + */ +function analyzeTokens(tokens) { + var literalValue = ''; + var analyzedTokens = []; + + for (var i = 0; i < tokens.length; i++) { + var token = tokens[i]; + + if (i === 0 && validSymbols.indexOf(token) >= 0) { + analyzedTokens.push(createToken(token, TOKEN_TYPE_OPERATOR)); + } else { + literalValue += token; + } + } + + if (literalValue.length > 0) { + analyzedTokens.push(createToken(castValueToCorrectType(literalValue), TOKEN_TYPE_LITERAL)); + } + + if (analyzedTokens.length > 0 && analyzedTokens[0].type !== TOKEN_TYPE_OPERATOR) { + analyzedTokens.unshift(createToken(defaultOperator, TOKEN_TYPE_OPERATOR)); + } + + return analyzedTokens; +} +/** + * Compute/Evaluate an expression passed as an array of tokens. + * + * @param {Object[]} tokens + * @return {Boolean} + */ +function computeExpression(tokens) { + var values = []; + var operator; + + for (var i = 0; i < tokens.length; i++) { + var token = tokens[i]; + + switch (token.type) { + case TOKEN_TYPE_OPERATOR: + operator = token.value; + break; + case TOKEN_TYPE_LITERAL: + values.push(token.value); + break; + } + } + + return evaluate(values, operator); +} +/** + * Evaluate values based on passed math operator. + * + * @param {*} values + * @param {String} operator + * @return {Boolean} + */ +function evaluate(values, operator) { + var result = false; + + switch (operator) { + case '>': + result = values[0] > values[1]; + break; + case '>=': + result = values[0] >= values[1]; + break; + case '<': + result = values[0] < values[1]; + break; + case '<=': + result = values[0] <= values[1]; + break; + case '=': + result = values[0] == values[1]; + break; + case '<>': + result = values[0] != values[1]; + break; + } + + return result; +} + +var parse$1 = function(expression) { + return analyzeTokens(tokenizeExpression(expression)); +}; +var createToken_1 = createToken; +var compute = computeExpression; + +var criteriaEval = { + TOKEN_TYPE_OPERATOR: TOKEN_TYPE_OPERATOR_1, + TOKEN_TYPE_LITERAL: TOKEN_TYPE_LITERAL_1, + parse: parse$1, + createToken: createToken_1, + compute: compute +}; + +var UNIQUE = function () { + var result = []; + for (var i = 0; i < arguments.length; ++i) { + var hasElement = false; + var element = arguments[i]; + + // Check if we've already seen this element. + for (var j = 0; j < result.length; ++j) { + hasElement = result[j] === element; + if (hasElement) { break; } + } + + // If we did not find it, add it to the result. + if (!hasElement) { + result.push(element); + } + } + return result; +}; + +var FLATTEN = common.flatten; + +var ARGS2ARRAY = function () { + return Array.prototype.slice.call(arguments, 0); +}; + +var REFERENCE = function (context, reference) { + if (!arguments.length) { + return error$1.error; + } + try { + var path = reference.split('.'); + var result = context; + for (var i = 0; i < path.length; ++i) { + var step = path[i]; + if (step[step.length - 1] === ']') { + var opening = step.indexOf('['); + var index = step.substring(opening + 1, step.length - 1); + result = result[step.substring(0, opening)][index]; + } else { + result = result[step]; + } + } + return result; + } catch (error) {} +}; + +var JOIN = function (array, separator) { + return array.join(separator); +}; + +var NUMBERS = function () { + var possibleNumbers = common.flatten(arguments); + return possibleNumbers.filter(function (el) { + return typeof el === 'number'; + }); +}; + +var miscellaneous = { + UNIQUE: UNIQUE, + FLATTEN: FLATTEN, + ARGS2ARRAY: ARGS2ARRAY, + REFERENCE: REFERENCE, + JOIN: JOIN, + NUMBERS: NUMBERS +}; + +var statistical = createCommonjsModule(function (module, exports) { +var SQRT2PI = 2.5066282746310002; + +exports.AVEDEV = function() { + var range = common.parseNumberArray(common.flatten(arguments)); + if (range instanceof Error) { + return range; + } + return jstat.sum(jstat(range).subtract(jstat.mean(range)).abs()[0]) / range.length; +}; + +exports.AVERAGE = function() { + var range = common.numbers(common.flatten(arguments)); + var n = range.length; + var sum = 0; + var count = 0; + var result; + + for (var i = 0; i < n; i++) { + sum += range[i]; + count += 1; + } + result = sum / count; + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.AVERAGEA = function() { + var range = common.flatten(arguments); + var n = range.length; + var sum = 0; + var count = 0; + var result; + for (var i = 0; i < n; i++) { + var el = range[i]; + if (typeof el === 'number') { + sum += el; + } + if (el === true) { + sum++; + } + if (el !== null) { + count++; + } + } + result = sum / count; + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.AVERAGEIF = function(range, criteria, average_range) { + if (arguments.length <= 1) { + return error$1.na; + } + average_range = average_range || range; + range = common.flatten(range); + average_range = common.parseNumberArray(common.flatten(average_range)); + + if (average_range instanceof Error) { + return average_range; + } + var average_count = 0; + var result = 0; + var isWildcard = criteria === void 0 || criteria === '*'; + var tokenizedCriteria = isWildcard ? null : criteriaEval.parse(criteria + ''); + + for (var i = 0; i < range.length; i++) { + var value = range[i]; + + if (isWildcard) { + result += average_range[i]; + average_count++; + } else { + var tokens = [criteriaEval.createToken(value, criteriaEval.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria); + + if (criteriaEval.compute(tokens)) { + result += average_range[i]; + average_count++; + } + } + } + + return result / average_count; +}; + +exports.AVERAGEIFS = function() { + // Does not work with multi dimensional ranges yet! + //http://office.microsoft.com/en-001/excel-help/averageifs-function-HA010047493.aspx + var args = common.argsToArray(arguments); + var criteriaLength = (args.length - 1) / 2; + var range = common.flatten(args[0]); + var count = 0; + var result = 0; + + for (var i = 0; i < range.length; i++) { + var isMeetCondition = false; + + for (var j = 0; j < criteriaLength; j++) { + var value = args[2 * j + 1][i]; + var criteria = args[2 * j + 2]; + var isWildcard = criteria === void 0 || criteria === '*'; + var computedResult = false; + + if (isWildcard) { + computedResult = true; + } else { + var tokenizedCriteria = criteriaEval.parse(criteria + ''); + var tokens = [criteriaEval.createToken(value, criteriaEval.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria); + + computedResult = criteriaEval.compute(tokens); + } + + // Criterias are calculated as AND so any `false` breakes the loop as unmeet condition + if (!computedResult) { + isMeetCondition = false; + break; + } + + isMeetCondition = true; + } + + if (isMeetCondition) { + result += range[i]; + count++; + } + } + + var average = result / count; + + if (isNaN(average)) { + return 0; + } else { + return average; + } +}; + +exports.BETA = {}; + +exports.BETA.DIST = function(x, alpha, beta, cumulative, A, B) { + if (arguments.length < 4) { + return error$1.value; + } + + A = (A === undefined) ? 0 : A; + B = (B === undefined) ? 1 : B; + + x = common.parseNumber(x); + alpha = common.parseNumber(alpha); + beta = common.parseNumber(beta); + A = common.parseNumber(A); + B = common.parseNumber(B); + if (common.anyIsError(x, alpha, beta, A, B)) { + return error$1.value; + } + + x = (x - A) / (B - A); + return (cumulative) ? jstat.beta.cdf(x, alpha, beta) : jstat.beta.pdf(x, alpha, beta); +}; + +exports.BETA.INV = function(probability, alpha, beta, A, B) { + A = (A === undefined) ? 0 : A; + B = (B === undefined) ? 1 : B; + + probability = common.parseNumber(probability); + alpha = common.parseNumber(alpha); + beta = common.parseNumber(beta); + A = common.parseNumber(A); + B = common.parseNumber(B); + if (common.anyIsError(probability, alpha, beta, A, B)) { + return error$1.value; + } + + return jstat.beta.inv(probability, alpha, beta) * (B - A) + A; +}; + +exports.BINOM = {}; + +exports.BINOM.DIST = function(successes, trials, probability, cumulative) { + successes = common.parseNumber(successes); + trials = common.parseNumber(trials); + probability = common.parseNumber(probability); + cumulative = common.parseNumber(cumulative); + if (common.anyIsError(successes, trials, probability, cumulative)) { + return error$1.value; + } + return (cumulative) ? jstat.binomial.cdf(successes, trials, probability) : jstat.binomial.pdf(successes, trials, probability); +}; + +exports.BINOM.DIST.RANGE = function(trials, probability, successes, successes2) { + successes2 = (successes2 === undefined) ? successes : successes2; + + trials = common.parseNumber(trials); + probability = common.parseNumber(probability); + successes = common.parseNumber(successes); + successes2 = common.parseNumber(successes2); + if (common.anyIsError(trials, probability, successes, successes2)) { + return error$1.value; + } + + var result = 0; + for (var i = successes; i <= successes2; i++) { + result += mathTrig.COMBIN(trials, i) * Math.pow(probability, i) * Math.pow(1 - probability, trials - i); + } + return result; +}; + +exports.BINOM.INV = function(trials, probability, alpha) { + trials = common.parseNumber(trials); + probability = common.parseNumber(probability); + alpha = common.parseNumber(alpha); + if (common.anyIsError(trials, probability, alpha)) { + return error$1.value; + } + + var x = 0; + while (x <= trials) { + if (jstat.binomial.cdf(x, trials, probability) >= alpha) { + return x; + } + x++; + } +}; + +exports.CHISQ = {}; + +exports.CHISQ.DIST = function(x, k, cumulative) { + x = common.parseNumber(x); + k = common.parseNumber(k); + if (common.anyIsError(x, k)) { + return error$1.value; + } + + return (cumulative) ? jstat.chisquare.cdf(x, k) : jstat.chisquare.pdf(x, k); +}; + +exports.CHISQ.DIST.RT = function(x, k) { + if (!x | !k) { + return error$1.na; + } + + if (x < 1 || k > Math.pow(10, 10)) { + return error$1.num; + } + + if ((typeof x !== 'number') || (typeof k !== 'number')) { + return error$1.value; + } + + return 1 - jstat.chisquare.cdf(x, k); +}; + +exports.CHISQ.INV = function(probability, k) { + probability = common.parseNumber(probability); + k = common.parseNumber(k); + if (common.anyIsError(probability, k)) { + return error$1.value; + } + return jstat.chisquare.inv(probability, k); +}; + +exports.CHISQ.INV.RT = function(p, k) { + if (!p | !k) { + return error$1.na; + } + + if (p < 0 || p > 1 || k < 1 || k > Math.pow(10, 10)) { + return error$1.num; + } + + if ((typeof p !== 'number') || (typeof k !== 'number')) { + return error$1.value; + } + + return jstat.chisquare.inv(1.0 - p, k); +}; + +exports.CHISQ.TEST = function(observed, expected) { + if (arguments.length !== 2) { + return error$1.na; + } + + if ((!(observed instanceof Array)) || (!(expected instanceof Array))) { + return error$1.value; + } + + if (observed.length !== expected.length) { + return error$1.value; + } + + if (observed[0] && expected[0] && + observed[0].length !== expected[0].length) { + return error$1.value; + } + + var row = observed.length; + var tmp, i, j; + + // Convert single-dimension array into two-dimension array + for (i = 0; i < row; i ++) { + if (!(observed[i] instanceof Array)) { + tmp = observed[i]; + observed[i] = []; + observed[i].push(tmp); + } + if (!(expected[i] instanceof Array)) { + tmp = expected[i]; + expected[i] = []; + expected[i].push(tmp); + } + } + + var col = observed[0].length; + var dof = (col === 1) ? row-1 : (row-1)*(col-1); + var xsqr = 0; + var Pi =Math.PI; + + for (i = 0; i < row; i ++) { + for (j = 0; j < col; j ++) { + xsqr += Math.pow((observed[i][j] - expected[i][j]), 2) / expected[i][j]; + } + } + + // Get independency by X square and its degree of freedom + function ChiSq(xsqr, dof) { + var p = Math.exp(-0.5 * xsqr); + if((dof%2) === 1) { + p = p * Math.sqrt(2 * xsqr/Pi); + } + var k = dof; + while(k >= 2) { + p = p * xsqr/k; + k = k - 2; + } + var t = p; + var a = dof; + while (t > 0.0000000001*p) { + a = a + 2; + t = t * xsqr/a; + p = p + t; + } + return 1-p; + } + + return Math.round(ChiSq(xsqr, dof) * 1000000) / 1000000; +}; + +exports.COLUMN = function(matrix, index) { + if (arguments.length !== 2) { + return error$1.na; + } + + if (index < 0) { + return error$1.num; + } + + if (!(matrix instanceof Array) || (typeof index !== 'number')) { + return error$1.value; + } + + if (matrix.length === 0) { + return undefined; + } + + return jstat.col(matrix, index); +}; + +exports.COLUMNS = function(matrix) { + if (arguments.length !== 1) { + return error$1.na; + } + + if (!(matrix instanceof Array)) { + return error$1.value; + } + + if (matrix.length === 0) { + return 0; + } + + return jstat.cols(matrix); +}; + +exports.CONFIDENCE = {}; + +exports.CONFIDENCE.NORM = function(alpha, sd, n) { + alpha = common.parseNumber(alpha); + sd = common.parseNumber(sd); + n = common.parseNumber(n); + if (common.anyIsError(alpha, sd, n)) { + return error$1.value; + } + return jstat.normalci(1, alpha, sd, n)[1] - 1; +}; + +exports.CONFIDENCE.T = function(alpha, sd, n) { + alpha = common.parseNumber(alpha); + sd = common.parseNumber(sd); + n = common.parseNumber(n); + if (common.anyIsError(alpha, sd, n)) { + return error$1.value; + } + return jstat.tci(1, alpha, sd, n)[1] - 1; +}; + +exports.CORREL = function(array1, array2) { + array1 = common.parseNumberArray(common.flatten(array1)); + array2 = common.parseNumberArray(common.flatten(array2)); + if (common.anyIsError(array1, array2)) { + return error$1.value; + } + return jstat.corrcoeff(array1, array2); +}; + +exports.COUNT = function() { + return common.numbers(common.flatten(arguments)).length; +}; + +exports.COUNTA = function() { + var range = common.flatten(arguments); + return range.length - exports.COUNTBLANK(range); +}; + +exports.COUNTIN = function (range, value) { + var result = 0; + + range = common.flatten(range); + + for (var i = 0; i < range.length; i++) { + if (range[i] === value) { + result++; + } + } + return result; +}; + + +exports.COUNTBLANK = function() { + var range = common.flatten(arguments); + var blanks = 0; + var element; + for (var i = 0; i < range.length; i++) { + element = range[i]; + if (element === null || element === '') { + blanks++; + } + } + return blanks; +}; + +exports.COUNTIF = function(range, criteria) { + range = common.flatten(range); + + var isWildcard = criteria === void 0 || criteria === '*'; + + if (isWildcard) { + return range.length; + } + + var matches = 0; + var tokenizedCriteria = criteriaEval.parse(criteria + ''); + + for (var i = 0; i < range.length; i++) { + var value = range[i]; + var tokens = [criteriaEval.createToken(value, criteriaEval.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria); + + if (criteriaEval.compute(tokens)) { + matches++; + } + } + + return matches; +}; + +exports.COUNTIFS = function() { + var args = common.argsToArray(arguments); + var results = new Array(common.flatten(args[0]).length); + + for (var i = 0; i < results.length; i++) { + results[i] = true; + } + for (i = 0; i < args.length; i += 2) { + var range = common.flatten(args[i]); + var criteria = args[i + 1]; + var isWildcard = criteria === void 0 || criteria === '*'; + + if (!isWildcard) { + var tokenizedCriteria = criteriaEval.parse(criteria + ''); + + for (var j = 0; j < range.length; j++) { + var value = range[j]; + var tokens = [criteriaEval.createToken(value, criteriaEval.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria); + + results[j] = results[j] && criteriaEval.compute(tokens); + } + } + } + var result = 0; + for (i = 0; i < results.length; i++) { + if (results[i]) { + result++; + } + } + + return result; +}; + +exports.COUNTUNIQUE = function () { + return miscellaneous.UNIQUE.apply(null, common.flatten(arguments)).length; +}; + +exports.COVARIANCE = {}; + +exports.COVARIANCE.P = function(array1, array2) { + array1 = common.parseNumberArray(common.flatten(array1)); + array2 = common.parseNumberArray(common.flatten(array2)); + if (common.anyIsError(array1, array2)) { + return error$1.value; + } + var mean1 = jstat.mean(array1); + var mean2 = jstat.mean(array2); + var result = 0; + var n = array1.length; + for (var i = 0; i < n; i++) { + result += (array1[i] - mean1) * (array2[i] - mean2); + } + return result / n; +}; + +exports.COVARIANCE.S = function(array1, array2) { + array1 = common.parseNumberArray(common.flatten(array1)); + array2 = common.parseNumberArray(common.flatten(array2)); + if (common.anyIsError(array1, array2)) { + return error$1.value; + } + return jstat.covariance(array1, array2); +}; + +exports.DEVSQ = function() { + var range = common.parseNumberArray(common.flatten(arguments)); + if (range instanceof Error) { + return range; + } + var mean = jstat.mean(range); + var result = 0; + for (var i = 0; i < range.length; i++) { + result += Math.pow((range[i] - mean), 2); + } + return result; +}; + +exports.EXPON = {}; + +exports.EXPON.DIST = function(x, lambda, cumulative) { + x = common.parseNumber(x); + lambda = common.parseNumber(lambda); + if (common.anyIsError(x, lambda)) { + return error$1.value; + } + return (cumulative) ? jstat.exponential.cdf(x, lambda) : jstat.exponential.pdf(x, lambda); +}; + +exports.F = {}; + +exports.F.DIST = function(x, d1, d2, cumulative) { + x = common.parseNumber(x); + d1 = common.parseNumber(d1); + d2 = common.parseNumber(d2); + if (common.anyIsError(x, d1, d2)) { + return error$1.value; + } + return (cumulative) ? jstat.centralF.cdf(x, d1, d2) : jstat.centralF.pdf(x, d1, d2); +}; + +exports.F.DIST.RT = function(x, d1, d2) { + if (arguments.length !== 3) { + return error$1.na; + } + + if (x < 0 || d1 < 1 || d2 < 1) { + return error$1.num; + } + + if ((typeof x !== 'number') || (typeof d1 !== 'number') || (typeof d2 !== 'number')) { + return error$1.value; + } + + return 1 - jstat.centralF.cdf(x, d1, d2); +}; + +exports.F.INV = function(probability, d1, d2) { + probability = common.parseNumber(probability); + d1 = common.parseNumber(d1); + d2 = common.parseNumber(d2); + if (common.anyIsError(probability, d1, d2)) { + return error$1.value; + } + if (probability <= 0.0 || probability > 1.0) { + return error$1.num; + } + + return jstat.centralF.inv(probability, d1, d2); +}; + +exports.F.INV.RT = function(p, d1, d2) { + if (arguments.length !== 3) { + return error$1.na; + } + + if (p < 0 || p > 1 || d1 < 1 || d1 > Math.pow(10, 10) || d2 < 1 || d2 > Math.pow(10, 10)) { + return error$1.num; + } + + if ((typeof p !== 'number') || (typeof d1 !== 'number') || (typeof d2 !== 'number')) { + return error$1.value; + } + + return jstat.centralF.inv(1.0 - p, d1, d2); +}; + +exports.F.TEST = function(array1, array2) { + if (!array1 || !array2) { + return error$1.na; + } + + if (!(array1 instanceof Array) || !(array2 instanceof Array)) { + return error$1.na; + } + + if (array1.length < 2 || array2.length < 2) { + return error$1.div0; + } + + var sumOfSquares = function(values, x1) { + var sum = 0; + for (var i = 0; i < values.length; i++) { + sum +=Math.pow((values[i] - x1), 2); + } + return sum; + }; + + var x1 = mathTrig.SUM(array1) / array1.length; + var x2 = mathTrig.SUM(array2) / array2.length; + var sum1 = sumOfSquares(array1, x1) / (array1.length - 1); + var sum2 = sumOfSquares(array2, x2) / (array2.length - 1); + + return sum1 / sum2; +}; + +exports.FISHER = function(x) { + x = common.parseNumber(x); + if (x instanceof Error) { + return x; + } + return Math.log((1 + x) / (1 - x)) / 2; +}; + +exports.FISHERINV = function(y) { + y = common.parseNumber(y); + if (y instanceof Error) { + return y; + } + var e2y = Math.exp(2 * y); + return (e2y - 1) / (e2y + 1); +}; + +exports.FORECAST = function(x, data_y, data_x) { + x = common.parseNumber(x); + data_y = common.parseNumberArray(common.flatten(data_y)); + data_x = common.parseNumberArray(common.flatten(data_x)); + if (common.anyIsError(x, data_y, data_x)) { + return error$1.value; + } + var xmean = jstat.mean(data_x); + var ymean = jstat.mean(data_y); + var n = data_x.length; + var num = 0; + var den = 0; + for (var i = 0; i < n; i++) { + num += (data_x[i] - xmean) * (data_y[i] - ymean); + den += Math.pow(data_x[i] - xmean, 2); + } + var b = num / den; + var a = ymean - b * xmean; + return a + b * x; +}; + +exports.FREQUENCY = function(data, bins) { + data = common.parseNumberArray(common.flatten(data)); + bins = common.parseNumberArray(common.flatten(bins)); + if (common.anyIsError(data, bins)) { + return error$1.value; + } + var n = data.length; + var b = bins.length; + var r = []; + for (var i = 0; i <= b; i++) { + r[i] = 0; + for (var j = 0; j < n; j++) { + if (i === 0) { + if (data[j] <= bins[0]) { + r[0] += 1; + } + } else if (i < b) { + if (data[j] > bins[i - 1] && data[j] <= bins[i]) { + r[i] += 1; + } + } else if (i === b) { + if (data[j] > bins[b - 1]) { + r[b] += 1; + } + } + } + } + return r; +}; + + +exports.GAMMA = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + + if (number === 0) { + return error$1.num; + } + + if (parseInt(number, 10) === number && number < 0) { + return error$1.num; + } + + return jstat.gammafn(number); +}; + +exports.GAMMA.DIST = function(value, alpha, beta, cumulative) { + if (arguments.length !== 4) { + return error$1.na; + } + + if (value < 0 || alpha <= 0 || beta <= 0) { + return error$1.value; + } + + if ((typeof value !== 'number') || (typeof alpha !== 'number') || (typeof beta !== 'number')) { + return error$1.value; + } + + return cumulative ? jstat.gamma.cdf(value, alpha, beta, true) : jstat.gamma.pdf(value, alpha, beta, false); +}; + +exports.GAMMA.INV = function(probability, alpha, beta) { + if (arguments.length !== 3) { + return error$1.na; + } + + if (probability < 0 || probability > 1 || alpha <= 0 || beta <= 0) { + return error$1.num; + } + + if ((typeof probability !== 'number') || (typeof alpha !== 'number') || (typeof beta !== 'number')) { + return error$1.value; + } + + return jstat.gamma.inv(probability, alpha, beta); +}; + +exports.GAMMALN = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return jstat.gammaln(number); +}; + +exports.GAMMALN.PRECISE = function(x) { + if (arguments.length !== 1) { + return error$1.na; + } + + if (x <= 0) { + return error$1.num; + } + + if (typeof x !== 'number') { + return error$1.value; + } + + return jstat.gammaln(x); +}; + +exports.GAUSS = function(z) { + z = common.parseNumber(z); + if (z instanceof Error) { + return z; + } + return jstat.normal.cdf(z, 0, 1) - 0.5; +}; + +exports.GEOMEAN = function() { + var args = common.parseNumberArray(common.flatten(arguments)); + if (args instanceof Error) { + return args; + } + return jstat.geomean(args); +}; + +exports.GROWTH = function(known_y, known_x, new_x, use_const) { + // Credits: Ilmari Karonen (http://stackoverflow.com/questions/14161990/how-to-implement-growth-function-in-javascript) + + known_y = common.parseNumberArray(known_y); + if (known_y instanceof Error) { + return known_y; + } + + // Default values for optional parameters: + var i; + if (known_x === undefined) { + known_x = []; + for (i = 1; i <= known_y.length; i++) { + known_x.push(i); + } + } + if (new_x === undefined) { + new_x = []; + for (i = 1; i <= known_y.length; i++) { + new_x.push(i); + } + } + + known_x = common.parseNumberArray(known_x); + new_x = common.parseNumberArray(new_x); + if (common.anyIsError(known_x, new_x)) { + return error$1.value; + } + + + if (use_const === undefined) { + use_const = true; + } + + // Calculate sums over the data: + var n = known_y.length; + var avg_x = 0; + var avg_y = 0; + var avg_xy = 0; + var avg_xx = 0; + for (i = 0; i < n; i++) { + var x = known_x[i]; + var y = Math.log(known_y[i]); + avg_x += x; + avg_y += y; + avg_xy += x * y; + avg_xx += x * x; + } + avg_x /= n; + avg_y /= n; + avg_xy /= n; + avg_xx /= n; + + // Compute linear regression coefficients: + var beta; + var alpha; + if (use_const) { + beta = (avg_xy - avg_x * avg_y) / (avg_xx - avg_x * avg_x); + alpha = avg_y - beta * avg_x; + } else { + beta = avg_xy / avg_xx; + alpha = 0; + } + + // Compute and return result array: + var new_y = []; + for (i = 0; i < new_x.length; i++) { + new_y.push(Math.exp(alpha + beta * new_x[i])); + } + return new_y; +}; + +exports.HARMEAN = function() { + var range = common.parseNumberArray(common.flatten(arguments)); + if (range instanceof Error) { + return range; + } + var n = range.length; + var den = 0; + for (var i = 0; i < n; i++) { + den += 1 / range[i]; + } + return n / den; +}; + +exports.HYPGEOM = {}; + +exports.HYPGEOM.DIST = function(x, n, M, N, cumulative) { + x = common.parseNumber(x); + n = common.parseNumber(n); + M = common.parseNumber(M); + N = common.parseNumber(N); + if (common.anyIsError(x, n, M, N)) { + return error$1.value; + } + + function pdf(x, n, M, N) { + return mathTrig.COMBIN(M, x) * mathTrig.COMBIN(N - M, n - x) / mathTrig.COMBIN(N, n); + } + + function cdf(x, n, M, N) { + var result = 0; + for (var i = 0; i <= x; i++) { + result += pdf(i, n, M, N); + } + return result; + } + + return (cumulative) ? cdf(x, n, M, N) : pdf(x, n, M, N); +}; + +exports.INTERCEPT = function(known_y, known_x) { + known_y = common.parseNumberArray(known_y); + known_x = common.parseNumberArray(known_x); + if (common.anyIsError(known_y, known_x)) { + return error$1.value; + } + if (known_y.length !== known_x.length) { + return error$1.na; + } + return exports.FORECAST(0, known_y, known_x); +}; + +exports.KURT = function() { + var range = common.parseNumberArray(common.flatten(arguments)); + if (range instanceof Error) { + return range; + } + var mean = jstat.mean(range); + var n = range.length; + var sigma = 0; + for (var i = 0; i < n; i++) { + sigma += Math.pow(range[i] - mean, 4); + } + sigma = sigma / Math.pow(jstat.stdev(range, true), 4); + return ((n * (n + 1)) / ((n - 1) * (n - 2) * (n - 3))) * sigma - 3 * (n - 1) * (n - 1) / ((n - 2) * (n - 3)); +}; + +exports.LARGE = function(range, k) { + range = common.parseNumberArray(common.flatten(range)); + k = common.parseNumber(k); + if (common.anyIsError(range, k)) { + return range; + } + return range.sort(function(a, b) { + return b - a; + })[k - 1]; +}; + +exports.LINEST = function(data_y, data_x) { + data_y = common.parseNumberArray(common.flatten(data_y)); + data_x = common.parseNumberArray(common.flatten(data_x)); + if (common.anyIsError(data_y, data_x)) { + return error$1.value; + } + var ymean = jstat.mean(data_y); + var xmean = jstat.mean(data_x); + var n = data_x.length; + var num = 0; + var den = 0; + for (var i = 0; i < n; i++) { + num += (data_x[i] - xmean) * (data_y[i] - ymean); + den += Math.pow(data_x[i] - xmean, 2); + } + var m = num / den; + var b = ymean - m * xmean; + return [m, b]; +}; + +// According to Microsoft: +// http://office.microsoft.com/en-us/starter-help/logest-function-HP010342665.aspx +// LOGEST returns are based on the following linear model: +// ln y = x1 ln m1 + ... + xn ln mn + ln b +exports.LOGEST = function(data_y, data_x) { + data_y = common.parseNumberArray(common.flatten(data_y)); + data_x = common.parseNumberArray(common.flatten(data_x)); + if (common.anyIsError(data_y, data_x)) { + return error$1.value; + } + for (var i = 0; i < data_y.length; i ++) { + data_y[i] = Math.log(data_y[i]); + } + + var result = exports.LINEST(data_y, data_x); + result[0] = Math.round(Math.exp(result[0])*1000000)/1000000; + result[1] = Math.round(Math.exp(result[1])*1000000)/1000000; + return result; +}; + +exports.LOGNORM = {}; + +exports.LOGNORM.DIST = function(x, mean, sd, cumulative) { + x = common.parseNumber(x); + mean = common.parseNumber(mean); + sd = common.parseNumber(sd); + if (common.anyIsError(x, mean, sd)) { + return error$1.value; + } + return (cumulative) ? jstat.lognormal.cdf(x, mean, sd) : jstat.lognormal.pdf(x, mean, sd); +}; + +exports.LOGNORM.INV = function(probability, mean, sd) { + probability = common.parseNumber(probability); + mean = common.parseNumber(mean); + sd = common.parseNumber(sd); + if (common.anyIsError(probability, mean, sd)) { + return error$1.value; + } + return jstat.lognormal.inv(probability, mean, sd); +}; + +exports.MAX = function() { + var range = common.numbers(common.flatten(arguments)); + return (range.length === 0) ? 0 : Math.max.apply(Math, range); +}; + +exports.MAXA = function() { + var range = common.arrayValuesToNumbers(common.flatten(arguments)); + return (range.length === 0) ? 0 : Math.max.apply(Math, range); +}; + +exports.MEDIAN = function() { + var range = common.arrayValuesToNumbers(common.flatten(arguments)); + var result = jstat.median(range); + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.MIN = function() { + var range = common.numbers(common.flatten(arguments)); + return (range.length === 0) ? 0 : Math.min.apply(Math, range); +}; + +exports.MINA = function() { + var range = common.arrayValuesToNumbers(common.flatten(arguments)); + return (range.length === 0) ? 0 : Math.min.apply(Math, range); +}; + +exports.MODE = {}; + +exports.MODE.MULT = function() { + // Credits: Roönaän + var range = common.parseNumberArray(common.flatten(arguments)); + if (range instanceof Error) { + return range; + } + var n = range.length; + var count = {}; + var maxItems = []; + var max = 0; + var currentItem; + + for (var i = 0; i < n; i++) { + currentItem = range[i]; + count[currentItem] = count[currentItem] ? count[currentItem] + 1 : 1; + if (count[currentItem] > max) { + max = count[currentItem]; + maxItems = []; + } + if (count[currentItem] === max) { + maxItems[maxItems.length] = currentItem; + } + } + return maxItems; +}; + +exports.MODE.SNGL = function() { + var range = common.parseNumberArray(common.flatten(arguments)); + if (range instanceof Error) { + return range; + } + return exports.MODE.MULT(range).sort(function(a, b) { + return a - b; + })[0]; +}; + +exports.NEGBINOM = {}; + +exports.NEGBINOM.DIST = function(k, r, p, cumulative) { + k = common.parseNumber(k); + r = common.parseNumber(r); + p = common.parseNumber(p); + if (common.anyIsError(k, r, p)) { + return error$1.value; + } + return (cumulative) ? jstat.negbin.cdf(k, r, p) : jstat.negbin.pdf(k, r, p); +}; + +exports.NORM = {}; + +exports.NORM.DIST = function(x, mean, sd, cumulative) { + x = common.parseNumber(x); + mean = common.parseNumber(mean); + sd = common.parseNumber(sd); + if (common.anyIsError(x, mean, sd)) { + return error$1.value; + } + if (sd <= 0) { + return error$1.num; + } + + // Return normal distribution computed by jStat [http://jstat.org] + return (cumulative) ? jstat.normal.cdf(x, mean, sd) : jstat.normal.pdf(x, mean, sd); +}; + +exports.NORM.INV = function(probability, mean, sd) { + probability = common.parseNumber(probability); + mean = common.parseNumber(mean); + sd = common.parseNumber(sd); + if (common.anyIsError(probability, mean, sd)) { + return error$1.value; + } + return jstat.normal.inv(probability, mean, sd); +}; + +exports.NORM.S = {}; + +exports.NORM.S.DIST = function(z, cumulative) { + z = common.parseNumber(z); + if (z instanceof Error) { + return error$1.value; + } + return (cumulative) ? jstat.normal.cdf(z, 0, 1) : jstat.normal.pdf(z, 0, 1); +}; + +exports.NORM.S.INV = function(probability) { + probability = common.parseNumber(probability); + if (probability instanceof Error) { + return error$1.value; + } + return jstat.normal.inv(probability, 0, 1); +}; + +exports.PEARSON = function(data_x, data_y) { + data_y = common.parseNumberArray(common.flatten(data_y)); + data_x = common.parseNumberArray(common.flatten(data_x)); + if (common.anyIsError(data_y, data_x)) { + return error$1.value; + } + var xmean = jstat.mean(data_x); + var ymean = jstat.mean(data_y); + var n = data_x.length; + var num = 0; + var den1 = 0; + var den2 = 0; + for (var i = 0; i < n; i++) { + num += (data_x[i] - xmean) * (data_y[i] - ymean); + den1 += Math.pow(data_x[i] - xmean, 2); + den2 += Math.pow(data_y[i] - ymean, 2); + } + return num / Math.sqrt(den1 * den2); +}; + +exports.PERCENTILE = {}; + +exports.PERCENTILE.EXC = function(array, k) { + array = common.parseNumberArray(common.flatten(array)); + k = common.parseNumber(k); + if (common.anyIsError(array, k)) { + return error$1.value; + } + array = array.sort(function(a, b) { + { + return a - b; + } + }); + var n = array.length; + if (k < 1 / (n + 1) || k > 1 - 1 / (n + 1)) { + return error$1.num; + } + var l = k * (n + 1) - 1; + var fl = Math.floor(l); + return common.cleanFloat((l === fl) ? array[l] : array[fl] + (l - fl) * (array[fl + 1] - array[fl])); +}; + +exports.PERCENTILE.INC = function(array, k) { + array = common.parseNumberArray(common.flatten(array)); + k = common.parseNumber(k); + if (common.anyIsError(array, k)) { + return error$1.value; + } + array = array.sort(function(a, b) { + return a - b; + }); + var n = array.length; + var l = k * (n - 1); + var fl = Math.floor(l); + return common.cleanFloat((l === fl) ? array[l] : array[fl] + (l - fl) * (array[fl + 1] - array[fl])); +}; + +exports.PERCENTRANK = {}; + +exports.PERCENTRANK.EXC = function(array, x, significance) { + significance = (significance === undefined) ? 3 : significance; + array = common.parseNumberArray(common.flatten(array)); + x = common.parseNumber(x); + significance = common.parseNumber(significance); + if (common.anyIsError(array, x, significance)) { + return error$1.value; + } + array = array.sort(function(a, b) { + return a - b; + }); + var uniques = miscellaneous.UNIQUE.apply(null, array); + var n = array.length; + var m = uniques.length; + var power = Math.pow(10, significance); + var result = 0; + var match = false; + var i = 0; + while (!match && i < m) { + if (x === uniques[i]) { + result = (array.indexOf(uniques[i]) + 1) / (n + 1); + match = true; + } else if (x >= uniques[i] && (x < uniques[i + 1] || i === m - 1)) { + result = (array.indexOf(uniques[i]) + 1 + (x - uniques[i]) / (uniques[i + 1] - uniques[i])) / (n + 1); + match = true; + } + i++; + } + return Math.floor(result * power) / power; +}; + +exports.PERCENTRANK.INC = function(array, x, significance) { + significance = (significance === undefined) ? 3 : significance; + array = common.parseNumberArray(common.flatten(array)); + x = common.parseNumber(x); + significance = common.parseNumber(significance); + if (common.anyIsError(array, x, significance)) { + return error$1.value; + } + array = array.sort(function(a, b) { + return a - b; + }); + var uniques = miscellaneous.UNIQUE.apply(null, array); + var n = array.length; + var m = uniques.length; + var power = Math.pow(10, significance); + var result = 0; + var match = false; + var i = 0; + while (!match && i < m) { + if (x === uniques[i]) { + result = array.indexOf(uniques[i]) / (n - 1); + match = true; + } else if (x >= uniques[i] && (x < uniques[i + 1] || i === m - 1)) { + result = (array.indexOf(uniques[i]) + (x - uniques[i]) / (uniques[i + 1] - uniques[i])) / (n - 1); + match = true; + } + i++; + } + return Math.floor(result * power) / power; +}; + +exports.PERMUT = function(number, number_chosen) { + number = common.parseNumber(number); + number_chosen = common.parseNumber(number_chosen); + if (common.anyIsError(number, number_chosen)) { + return error$1.value; + } + return mathTrig.FACT(number) / mathTrig.FACT(number - number_chosen); +}; + +exports.PERMUTATIONA = function(number, number_chosen) { + number = common.parseNumber(number); + number_chosen = common.parseNumber(number_chosen); + if (common.anyIsError(number, number_chosen)) { + return error$1.value; + } + return Math.pow(number, number_chosen); +}; + +exports.PHI = function(x) { + x = common.parseNumber(x); + if (x instanceof Error) { + return error$1.value; + } + return Math.exp(-0.5 * x * x) / SQRT2PI; +}; + +exports.POISSON = {}; + +exports.POISSON.DIST = function(x, mean, cumulative) { + x = common.parseNumber(x); + mean = common.parseNumber(mean); + if (common.anyIsError(x, mean)) { + return error$1.value; + } + return (cumulative) ? jstat.poisson.cdf(x, mean) : jstat.poisson.pdf(x, mean); +}; + +exports.PROB = function(range, probability, lower, upper) { + if (lower === undefined) { + return 0; + } + upper = (upper === undefined) ? lower : upper; + + range = common.parseNumberArray(common.flatten(range)); + probability = common.parseNumberArray(common.flatten(probability)); + lower = common.parseNumber(lower); + upper = common.parseNumber(upper); + if (common.anyIsError(range, probability, lower, upper)) { + return error$1.value; + } + + if (lower === upper) { + return (range.indexOf(lower) >= 0) ? probability[range.indexOf(lower)] : 0; + } + + var sorted = range.sort(function(a, b) { + return a - b; + }); + var n = sorted.length; + var result = 0; + for (var i = 0; i < n; i++) { + if (sorted[i] >= lower && sorted[i] <= upper) { + result += probability[range.indexOf(sorted[i])]; + } + } + return result; +}; + +exports.QUARTILE = {}; + +exports.QUARTILE.EXC = function(range, quart) { + range = common.parseNumberArray(common.flatten(range)); + quart = common.parseNumber(quart); + if (common.anyIsError(range, quart)) { + return error$1.value; + } + switch (quart) { + case 1: + return exports.PERCENTILE.EXC(range, 0.25); + case 2: + return exports.PERCENTILE.EXC(range, 0.5); + case 3: + return exports.PERCENTILE.EXC(range, 0.75); + default: + return error$1.num; + } +}; + +exports.QUARTILE.INC = function(range, quart) { + range = common.parseNumberArray(common.flatten(range)); + quart = common.parseNumber(quart); + if (common.anyIsError(range, quart)) { + return error$1.value; + } + switch (quart) { + case 1: + return exports.PERCENTILE.INC(range, 0.25); + case 2: + return exports.PERCENTILE.INC(range, 0.5); + case 3: + return exports.PERCENTILE.INC(range, 0.75); + default: + return error$1.num; + } +}; + +exports.RANK = {}; + +exports.RANK.AVG = function(number, range, order) { + number = common.parseNumber(number); + range = common.parseNumberArray(common.flatten(range)); + if (common.anyIsError(number, range)) { + return error$1.value; + } + range = common.flatten(range); + order = order || false; + var sort = (order) ? function(a, b) { + return a - b; + } : function(a, b) { + return b - a; + }; + range = range.sort(sort); + + var length = range.length; + var count = 0; + for (var i = 0; i < length; i++) { + if (range[i] === number) { + count++; + } + } + + return (count > 1) ? (2 * range.indexOf(number) + count + 1) / 2 : range.indexOf(number) + 1; +}; + +exports.RANK.EQ = function(number, range, order) { + number = common.parseNumber(number); + range = common.parseNumberArray(common.flatten(range)); + if (common.anyIsError(number, range)) { + return error$1.value; + } + order = order || false; + var sort = (order) ? function(a, b) { + return a - b; + } : function(a, b) { + return b - a; + }; + range = range.sort(sort); + return range.indexOf(number) + 1; +}; + +exports.ROW = function(matrix, index) { + if (arguments.length !== 2) { + return error$1.na; + } + + if (index < 0) { + return error$1.num; + } + + if (!(matrix instanceof Array) || (typeof index !== 'number')) { + return error$1.value; + } + + if (matrix.length === 0) { + return undefined; + } + + return jstat.row(matrix, index); +}; + +exports.ROWS = function(matrix) { + if (arguments.length !== 1) { + return error$1.na; + } + + if (!(matrix instanceof Array)) { + return error$1.value; + } + + if (matrix.length === 0) { + return 0; + } + + return jstat.rows(matrix); +}; + +exports.RSQ = function(data_x, data_y) { // no need to flatten here, PEARSON will take care of that + data_x = common.parseNumberArray(common.flatten(data_x)); + data_y = common.parseNumberArray(common.flatten(data_y)); + if (common.anyIsError(data_x, data_y)) { + return error$1.value; + } + return Math.pow(exports.PEARSON(data_x, data_y), 2); +}; + +exports.SKEW = function() { + var range = common.parseNumberArray(common.flatten(arguments)); + if (range instanceof Error) { + return range; + } + var mean = jstat.mean(range); + var n = range.length; + var sigma = 0; + for (var i = 0; i < n; i++) { + sigma += Math.pow(range[i] - mean, 3); + } + return n * sigma / ((n - 1) * (n - 2) * Math.pow(jstat.stdev(range, true), 3)); +}; + +exports.SKEW.P = function() { + var range = common.parseNumberArray(common.flatten(arguments)); + if (range instanceof Error) { + return range; + } + var mean = jstat.mean(range); + var n = range.length; + var m2 = 0; + var m3 = 0; + for (var i = 0; i < n; i++) { + m3 += Math.pow(range[i] - mean, 3); + m2 += Math.pow(range[i] - mean, 2); + } + m3 = m3 / n; + m2 = m2 / n; + return m3 / Math.pow(m2, 3 / 2); +}; + +exports.SLOPE = function(data_y, data_x) { + data_y = common.parseNumberArray(common.flatten(data_y)); + data_x = common.parseNumberArray(common.flatten(data_x)); + if (common.anyIsError(data_y, data_x)) { + return error$1.value; + } + var xmean = jstat.mean(data_x); + var ymean = jstat.mean(data_y); + var n = data_x.length; + var num = 0; + var den = 0; + for (var i = 0; i < n; i++) { + num += (data_x[i] - xmean) * (data_y[i] - ymean); + den += Math.pow(data_x[i] - xmean, 2); + } + return num / den; +}; + +exports.SMALL = function(range, k) { + range = common.parseNumberArray(common.flatten(range)); + k = common.parseNumber(k); + if (common.anyIsError(range, k)) { + return range; + } + return range.sort(function(a, b) { + return a - b; + })[k - 1]; +}; + +exports.STANDARDIZE = function(x, mean, sd) { + x = common.parseNumber(x); + mean = common.parseNumber(mean); + sd = common.parseNumber(sd); + if (common.anyIsError(x, mean, sd)) { + return error$1.value; + } + return (x - mean) / sd; +}; + +exports.STDEV = {}; + +exports.STDEV.P = function() { + var v = exports.VAR.P.apply(this, arguments); + var result = Math.sqrt(v); + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.STDEV.S = function() { + var v = exports.VAR.S.apply(this, arguments); + var result = Math.sqrt(v); + + return result; +}; + +exports.STDEVA = function() { + var v = exports.VARA.apply(this, arguments); + var result = Math.sqrt(v); + + return result; +}; + +exports.STDEVPA = function() { + var v = exports.VARPA.apply(this, arguments); + var result = Math.sqrt(v); + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + + +exports.STEYX = function(data_y, data_x) { + data_y = common.parseNumberArray(common.flatten(data_y)); + data_x = common.parseNumberArray(common.flatten(data_x)); + if (common.anyIsError(data_y, data_x)) { + return error$1.value; + } + var xmean = jstat.mean(data_x); + var ymean = jstat.mean(data_y); + var n = data_x.length; + var lft = 0; + var num = 0; + var den = 0; + for (var i = 0; i < n; i++) { + lft += Math.pow(data_y[i] - ymean, 2); + num += (data_x[i] - xmean) * (data_y[i] - ymean); + den += Math.pow(data_x[i] - xmean, 2); + } + return Math.sqrt((lft - num * num / den) / (n - 2)); +}; + +exports.TRANSPOSE = function(matrix) { + if (!matrix) { + return error$1.na; + } + return jstat.transpose(matrix); +}; + +exports.T = text$1.T; + +exports.T.DIST = function(x, df, cumulative) { + x = common.parseNumber(x); + df = common.parseNumber(df); + if (common.anyIsError(x, df)) { + return error$1.value; + } + return (cumulative) ? jstat.studentt.cdf(x, df) : jstat.studentt.pdf(x, df); +}; + +exports.T.DIST['2T'] = function(x, df) { + if (arguments.length !== 2) { + return error$1.na; + } + + if (x < 0 || df < 1) { + return error$1.num; + } + + if ((typeof x !== 'number') || (typeof df !== 'number')) { + return error$1.value; + } + + return (1 - jstat.studentt.cdf(x , df)) * 2; +}; + +exports.T.DIST.RT = function(x, df) { + if (arguments.length !== 2) { + return error$1.na; + } + + if (x < 0 || df < 1) { + return error$1.num; + } + + if ((typeof x !== 'number') || (typeof df !== 'number')) { + return error$1.value; + } + + return 1 - jstat.studentt.cdf(x , df); +}; + +exports.T.INV = function(probability, df) { + probability = common.parseNumber(probability); + df = common.parseNumber(df); + if (common.anyIsError(probability, df)) { + return error$1.value; + } + return jstat.studentt.inv(probability, df); +}; + +exports.T.INV['2T'] = function(probability, df) { + probability = common.parseNumber(probability); + df = common.parseNumber(df); + if (probability <= 0 || probability > 1 || df < 1) { + return error$1.num; + } + if (common.anyIsError(probability, df)) { + return error$1.value; + } + return Math.abs(jstat.studentt.inv(probability/2, df)); +}; + +// The algorithm can be found here: +// http://www.chem.uoa.gr/applets/AppletTtest/Appl_Ttest2.html +exports.T.TEST = function(data_x, data_y) { + data_x = common.parseNumberArray(common.flatten(data_x)); + data_y = common.parseNumberArray(common.flatten(data_y)); + if (common.anyIsError(data_x, data_y)) { + return error$1.value; + } + + var mean_x = jstat.mean(data_x); + var mean_y = jstat.mean(data_y); + var s_x = 0; + var s_y = 0; + var i; + + for (i = 0; i < data_x.length; i++) { + s_x += Math.pow(data_x[i] - mean_x, 2); + } + for (i = 0; i < data_y.length; i++) { + s_y += Math.pow(data_y[i] - mean_y, 2); + } + + s_x = s_x / (data_x.length-1); + s_y = s_y / (data_y.length-1); + + var t = Math.abs(mean_x - mean_y) / Math.sqrt(s_x/data_x.length + s_y/data_y.length); + + return exports.T.DIST['2T'](t, data_x.length+data_y.length-2); +}; + +exports.TREND = function(data_y, data_x, new_data_x) { + data_y = common.parseNumberArray(common.flatten(data_y)); + data_x = common.parseNumberArray(common.flatten(data_x)); + new_data_x = common.parseNumberArray(common.flatten(new_data_x)); + if (common.anyIsError(data_y, data_x, new_data_x)) { + return error$1.value; + } + var linest = exports.LINEST(data_y, data_x); + var m = linest[0]; + var b = linest[1]; + var result = []; + + new_data_x.forEach(function(x) { + result.push(m * x + b); + }); + + return result; +}; + +exports.TRIMMEAN = function(range, percent) { + range = common.parseNumberArray(common.flatten(range)); + percent = common.parseNumber(percent); + if (common.anyIsError(range, percent)) { + return error$1.value; + } + var trim = mathTrig.FLOOR(range.length * percent, 2) / 2; + return jstat.mean(common.initial(common.rest(range.sort(function(a, b) { + return a - b; + }), trim), trim)); +}; + +exports.VAR = {}; + +exports.VAR.P = function() { + var range = common.numbers(common.flatten(arguments)); + var n = range.length; + var sigma = 0; + var mean = exports.AVERAGE(range); + var result; + for (var i = 0; i < n; i++) { + sigma += Math.pow(range[i] - mean, 2); + } + result = sigma / n; + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.VAR.S = function() { + var range = common.numbers(common.flatten(arguments)); + var n = range.length; + var sigma = 0; + var mean = exports.AVERAGE(range); + for (var i = 0; i < n; i++) { + sigma += Math.pow(range[i] - mean, 2); + } + return sigma / (n - 1); +}; + +exports.VARA = function() { + var range = common.flatten(arguments); + var n = range.length; + var sigma = 0; + var count = 0; + var mean = exports.AVERAGEA(range); + for (var i = 0; i < n; i++) { + var el = range[i]; + if (typeof el === 'number') { + sigma += Math.pow(el - mean, 2); + } else if (el === true) { + sigma += Math.pow(1 - mean, 2); + } else { + sigma += Math.pow(0 - mean, 2); + } + + if (el !== null) { + count++; + } + } + return sigma / (count - 1); +}; + +exports.VARPA = function() { + var range = common.flatten(arguments); + var n = range.length; + var sigma = 0; + var count = 0; + var mean = exports.AVERAGEA(range); + var result; + for (var i = 0; i < n; i++) { + var el = range[i]; + if (typeof el === 'number') { + sigma += Math.pow(el - mean, 2); + } else if (el === true) { + sigma += Math.pow(1 - mean, 2); + } else { + sigma += Math.pow(0 - mean, 2); + } + + if (el !== null) { + count++; + } + } + result = sigma / count; + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.WEIBULL = {}; + +exports.WEIBULL.DIST = function(x, alpha, beta, cumulative) { + x = common.parseNumber(x); + alpha = common.parseNumber(alpha); + beta = common.parseNumber(beta); + if (common.anyIsError(x, alpha, beta)) { + return error$1.value; + } + return (cumulative) ? 1 - Math.exp(-Math.pow(x / beta, alpha)) : Math.pow(x, alpha - 1) * Math.exp(-Math.pow(x / beta, alpha)) * alpha / Math.pow(beta, alpha); +}; + +exports.Z = {}; + +exports.Z.TEST = function(range, x, sd) { + range = common.parseNumberArray(common.flatten(range)); + x = common.parseNumber(x); + if (common.anyIsError(range, x)) { + return error$1.value; + } + + sd = sd || exports.STDEV.S(range); + var n = range.length; + return 1 - exports.NORM.S.DIST((exports.AVERAGE(range) - x) / (sd / Math.sqrt(n)), true); +}; +}); + +var information = createCommonjsModule(function (module, exports) { +// TODO +exports.CELL = function() { + throw new Error('CELL is not implemented'); +}; + +exports.ERROR = {}; +exports.ERROR.TYPE = function(error_val) { + switch (error_val) { + case error$1.nil: return 1; + case error$1.div0: return 2; + case error$1.value: return 3; + case error$1.ref: return 4; + case error$1.name: return 5; + case error$1.num: return 6; + case error$1.na: return 7; + case error$1.data: return 8; + } + return error$1.na; +}; + +// TODO +exports.INFO = function() { + throw new Error('INFO is not implemented'); +}; + +exports.ISBLANK = function(value) { + return value === null; +}; + +exports.ISBINARY = function (number) { + return (/^[01]{1,10}$/).test(number); +}; + +exports.ISERR = function(value) { + return ([error$1.value, error$1.ref, error$1.div0, error$1.num, error$1.name, error$1.nil]).indexOf(value) >= 0 || + (typeof value === 'number' && (isNaN(value) || !isFinite(value))); +}; + +exports.ISERROR = function(value) { + return exports.ISERR(value) || value === error$1.na; +}; + +exports.ISEVEN = function(number) { + return (Math.floor(Math.abs(number)) & 1) ? false : true; +}; + +// TODO +exports.ISFORMULA = function() { + throw new Error('ISFORMULA is not implemented'); +}; + +exports.ISLOGICAL = function(value) { + return value === true || value === false; +}; + +exports.ISNA = function(value) { + return value === error$1.na; +}; + +exports.ISNONTEXT = function(value) { + return typeof(value) !== 'string'; +}; + +exports.ISNUMBER = function(value) { + return typeof(value) === 'number' && !isNaN(value) && isFinite(value); +}; + +exports.ISODD = function(number) { + return (Math.floor(Math.abs(number)) & 1) ? true : false; +}; + +// TODO +exports.ISREF = function() { + throw new Error('ISREF is not implemented'); +}; + +exports.ISTEXT = function(value) { + return typeof(value) === 'string'; +}; + +exports.N = function(value) { + if (this.ISNUMBER(value)) { + return value; + } + if (value instanceof Date) { + return value.getTime(); + } + if (value === true) { + return 1; + } + if (value === false) { + return 0; + } + if (this.ISERROR(value)) { + return value; + } + return 0; +}; + +exports.NA = function() { + return error$1.na; +}; + + +// TODO +exports.SHEET = function() { + throw new Error('SHEET is not implemented'); +}; + +// TODO +exports.SHEETS = function() { + throw new Error('SHEETS is not implemented'); +}; + +exports.TYPE = function(value) { + if (this.ISNUMBER(value)) { + return 1; + } + if (this.ISTEXT(value)) { + return 2; + } + if (this.ISLOGICAL(value)) { + return 4; + } + if (this.ISERROR(value)) { + return 16; + } + if (Array.isArray(value)) { + return 64; + } +}; +}); + +var mathTrig = createCommonjsModule(function (module, exports) { +exports.ABS = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var result = Math.abs(number); + + return result; +}; + +exports.ACOS = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var result = Math.acos(number); + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.ACOSH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var result = Math.log(number + Math.sqrt(number * number - 1)); + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.ACOT = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var result = Math.atan(1 / number); + + return result; +}; + +exports.ACOTH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var result = 0.5 * Math.log((number + 1) / (number - 1)); + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +//TODO: use options +exports.AGGREGATE = function(function_num, options, ref1, ref2) { + function_num = common.parseNumber(function_num); + options = common.parseNumber(function_num); + if (common.anyIsError(function_num, options)) { + return error$1.value; + } + switch (function_num) { + case 1: + return statistical.AVERAGE(ref1); + case 2: + return statistical.COUNT(ref1); + case 3: + return statistical.COUNTA(ref1); + case 4: + return statistical.MAX(ref1); + case 5: + return statistical.MIN(ref1); + case 6: + return exports.PRODUCT(ref1); + case 7: + return statistical.STDEV.S(ref1); + case 8: + return statistical.STDEV.P(ref1); + case 9: + return exports.SUM(ref1); + case 10: + return statistical.VAR.S(ref1); + case 11: + return statistical.VAR.P(ref1); + case 12: + return statistical.MEDIAN(ref1); + case 13: + return statistical.MODE.SNGL(ref1); + case 14: + return statistical.LARGE(ref1, ref2); + case 15: + return statistical.SMALL(ref1, ref2); + case 16: + return statistical.PERCENTILE.INC(ref1, ref2); + case 17: + return statistical.QUARTILE.INC(ref1, ref2); + case 18: + return statistical.PERCENTILE.EXC(ref1, ref2); + case 19: + return statistical.QUARTILE.EXC(ref1, ref2); + } +}; + +exports.ARABIC = function(text) { + // Credits: Rafa? Kukawski + if (!/^M*(?:D?C{0,3}|C[MD])(?:L?X{0,3}|X[CL])(?:V?I{0,3}|I[XV])$/.test(text)) { + return error$1.value; + } + var r = 0; + text.replace(/[MDLV]|C[MD]?|X[CL]?|I[XV]?/g, function(i) { + r += { + M: 1000, + CM: 900, + D: 500, + CD: 400, + C: 100, + XC: 90, + L: 50, + XL: 40, + X: 10, + IX: 9, + V: 5, + IV: 4, + I: 1 + }[i]; + }); + return r; +}; + +exports.ASIN = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var result = Math.asin(number); + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.ASINH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return Math.log(number + Math.sqrt(number * number + 1)); +}; + +exports.ATAN = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return Math.atan(number); +}; + +exports.ATAN2 = function(number_x, number_y) { + number_x = common.parseNumber(number_x); + number_y = common.parseNumber(number_y); + if (common.anyIsError(number_x, number_y)) { + return error$1.value; + } + return Math.atan2(number_x, number_y); +}; + +exports.ATANH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var result = Math.log((1 + number) / (1 - number)) / 2; + + if (isNaN(result)) { + result = error$1.num; + } + + return result; +}; + +exports.BASE = function(number, radix, min_length) { + min_length = min_length || 0; + + number = common.parseNumber(number); + radix = common.parseNumber(radix); + min_length = common.parseNumber(min_length); + if (common.anyIsError(number, radix, min_length)) { + return error$1.value; + } + min_length = (min_length === undefined) ? 0 : min_length; + var result = number.toString(radix); + return new Array(Math.max(min_length + 1 - result.length, 0)).join('0') + result; +}; + +exports.CEILING = function(number, significance, mode) { + significance = (significance === undefined) ? 1 : Math.abs(significance); + mode = mode || 0; + + number = common.parseNumber(number); + significance = common.parseNumber(significance); + mode = common.parseNumber(mode); + if (common.anyIsError(number, significance, mode)) { + return error$1.value; + } + if (significance === 0) { + return 0; + } + var precision = -Math.floor(Math.log(significance) / Math.log(10)); + if (number >= 0) { + return exports.ROUND(Math.ceil(number / significance) * significance, precision); + } else { + if (mode === 0) { + return -exports.ROUND(Math.floor(Math.abs(number) / significance) * significance, precision); + } else { + return -exports.ROUND(Math.ceil(Math.abs(number) / significance) * significance, precision); + } + } +}; + +exports.CEILING.MATH = exports.CEILING; + +exports.CEILING.PRECISE = exports.CEILING; + +exports.COMBIN = function(number, number_chosen) { + number = common.parseNumber(number); + number_chosen = common.parseNumber(number_chosen); + if (common.anyIsError(number, number_chosen)) { + return error$1.value; + } + return exports.FACT(number) / (exports.FACT(number_chosen) * exports.FACT(number - number_chosen)); +}; + +exports.COMBINA = function(number, number_chosen) { + number = common.parseNumber(number); + number_chosen = common.parseNumber(number_chosen); + if (common.anyIsError(number, number_chosen)) { + return error$1.value; + } + return (number === 0 && number_chosen === 0) ? 1 : exports.COMBIN(number + number_chosen - 1, number - 1); +}; + +exports.COS = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return Math.cos(number); +}; + +exports.COSH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return (Math.exp(number) + Math.exp(-number)) / 2; +}; + +exports.COT = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return 1 / Math.tan(number); +}; + +exports.COTH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var e2 = Math.exp(2 * number); + return (e2 + 1) / (e2 - 1); +}; + +exports.CSC = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return 1 / Math.sin(number); +}; + +exports.CSCH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return 2 / (Math.exp(number) - Math.exp(-number)); +}; + +exports.DECIMAL = function(number, radix) { + if (arguments.length < 1) { + return error$1.value; + } + + return parseInt(number, radix); +}; + +exports.DEGREES = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return number * 180 / Math.PI; +}; + +exports.EVEN = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return exports.CEILING(number, -2, -1); +}; + +exports.EXP = function(number) { + if (arguments.length < 1) { + return error$1.na; + } + if (typeof number !== 'number' || arguments.length > 1) { + return error$1.error; + } + + number = Math.exp(number); + + return number; +}; + +var MEMOIZED_FACT = []; +exports.FACT = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var n = Math.floor(number); + if (n === 0 || n === 1) { + return 1; + } else if (MEMOIZED_FACT[n] > 0) { + return MEMOIZED_FACT[n]; + } else { + MEMOIZED_FACT[n] = exports.FACT(n - 1) * n; + return MEMOIZED_FACT[n]; + } +}; + +exports.FACTDOUBLE = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var n = Math.floor(number); + if (n <= 0) { + return 1; + } else { + return n * exports.FACTDOUBLE(n - 2); + } +}; + +exports.FLOOR = function(number, significance) { + number = common.parseNumber(number); + significance = common.parseNumber(significance); + if (common.anyIsError(number, significance)) { + return error$1.value; + } + if (significance === 0) { + return 0; + } + + if (!(number > 0 && significance > 0) && !(number < 0 && significance < 0)) { + return error$1.num; + } + + significance = Math.abs(significance); + var precision = -Math.floor(Math.log(significance) / Math.log(10)); + if (number >= 0) { + return exports.ROUND(Math.floor(number / significance) * significance, precision); + } else { + return -exports.ROUND(Math.ceil(Math.abs(number) / significance), precision); + } +}; + +//TODO: Verify +exports.FLOOR.MATH = function(number, significance, mode) { + significance = (significance === undefined) ? 1 : significance; + mode = (mode === undefined) ? 0 : mode; + + number = common.parseNumber(number); + significance = common.parseNumber(significance); + mode = common.parseNumber(mode); + if (common.anyIsError(number, significance, mode)) { + return error$1.value; + } + if (significance === 0) { + return 0; + } + + significance = significance ? Math.abs(significance) : 1; + var precision = -Math.floor(Math.log(significance) / Math.log(10)); + if (number >= 0) { + return exports.ROUND(Math.floor(number / significance) * significance, precision); + } else if (mode === 0 || mode === undefined) { + return -exports.ROUND(Math.ceil(Math.abs(number) / significance) * significance, precision); + } + return -exports.ROUND(Math.floor(Math.abs(number) / significance) * significance, precision); +}; + +// Deprecated +exports.FLOOR.PRECISE = exports.FLOOR.MATH; + +// adapted http://rosettacode.org/wiki/Greatest_common_divisor#JavaScript +exports.GCD = function() { + var range = common.parseNumberArray(common.flatten(arguments)); + if (range instanceof Error) { + return range; + } + var n = range.length; + var r0 = range[0]; + var x = r0 < 0 ? -r0 : r0; + for (var i = 1; i < n; i++) { + var ri = range[i]; + var y = ri < 0 ? -ri : ri; + while (x && y) { + if (x > y) { + x %= y; + } else { + y %= x; + } + } + x += y; + } + return x; +}; + + +exports.INT = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return Math.floor(number); +}; + +//TODO: verify +exports.ISO = { + CEILING: exports.CEILING +}; + +exports.LCM = function() { + // Credits: Jonas Raoni Soares Silva + var o = common.parseNumberArray(common.flatten(arguments)); + if (o instanceof Error) { + return o; + } + for (var i, j, n, d, r = 1; + (n = o.pop()) !== undefined;) { + while (n > 1) { + if (n % 2) { + for (i = 3, j = Math.floor(Math.sqrt(n)); i <= j && n % i; i += 2) { + //empty + } + d = (i <= j) ? i : n; + } else { + d = 2; + } + for (n /= d, r *= d, i = o.length; i; + (o[--i] % d) === 0 && (o[i] /= d) === 1 && o.splice(i, 1)) { + //empty + } + } + } + return r; +}; + +exports.LN = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return Math.log(number); +}; + +exports.LN10 = function() { + return Math.log(10); +}; + +exports.LN2 = function() { + return Math.log(2); +}; + +exports.LOG10E = function() { + return Math.LOG10E; +}; + +exports.LOG2E = function() { + return Math.LOG2E; +}; + +exports.LOG = function(number, base) { + number = common.parseNumber(number); + base = common.parseNumber(base); + if (common.anyIsError(number, base)) { + return error$1.value; + } + base = (base === undefined) ? 10 : base; + return Math.log(number) / Math.log(base); +}; + +exports.LOG10 = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return Math.log(number) / Math.log(10); +}; + +exports.MOD = function(dividend, divisor) { + dividend = common.parseNumber(dividend); + divisor = common.parseNumber(divisor); + if (common.anyIsError(dividend, divisor)) { + return error$1.value; + } + if (divisor === 0) { + return error$1.div0; + } + var modulus = Math.abs(dividend % divisor); + return (divisor > 0) ? modulus : -modulus; +}; + +exports.MROUND = function(number, multiple) { + number = common.parseNumber(number); + multiple = common.parseNumber(multiple); + if (common.anyIsError(number, multiple)) { + return error$1.value; + } + if (number * multiple < 0) { + return error$1.num; + } + + return Math.round(number / multiple) * multiple; +}; + +exports.MULTINOMIAL = function() { + var args = common.parseNumberArray(common.flatten(arguments)); + if (args instanceof Error) { + return args; + } + var sum = 0; + var divisor = 1; + for (var i = 0; i < args.length; i++) { + sum += args[i]; + divisor *= exports.FACT(args[i]); + } + return exports.FACT(sum) / divisor; +}; + +exports.ODD = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var temp = Math.ceil(Math.abs(number)); + temp = (temp & 1) ? temp : temp + 1; + return (number > 0) ? temp : -temp; +}; + +exports.PI = function() { + return Math.PI; +}; + +exports.E = function() { + return Math.E; +}; + +exports.POWER = function(number, power) { + number = common.parseNumber(number); + power = common.parseNumber(power); + if (common.anyIsError(number, power)) { + return error$1.value; + } + var result = Math.pow(number, power); + if (isNaN(result)) { + return error$1.num; + } + + return result; +}; + +exports.PRODUCT = function() { + var args = common.parseNumberArray(common.flatten(arguments)); + if (args instanceof Error) { + return args; + } + var result = 1; + for (var i = 0; i < args.length; i++) { + result *= args[i]; + } + return result; +}; + +exports.QUOTIENT = function(numerator, denominator) { + numerator = common.parseNumber(numerator); + denominator = common.parseNumber(denominator); + if (common.anyIsError(numerator, denominator)) { + return error$1.value; + } + return parseInt(numerator / denominator, 10); +}; + +exports.RADIANS = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return number * Math.PI / 180; +}; + +exports.RAND = function() { + return Math.random(); +}; + +exports.RANDBETWEEN = function(bottom, top) { + bottom = common.parseNumber(bottom); + top = common.parseNumber(top); + if (common.anyIsError(bottom, top)) { + return error$1.value; + } + // Creative Commons Attribution 3.0 License + // Copyright (c) 2012 eqcode + return bottom + Math.ceil((top - bottom + 1) * Math.random()) - 1; +}; + +// TODO +exports.ROMAN = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + // The MIT License + // Copyright (c) 2008 Steven Levithan + var digits = String(number).split(''); + var key = ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX']; + var roman = ''; + var i = 3; + while (i--) { + roman = (key[+digits.pop() + (i * 10)] || '') + roman; + } + return new Array(+digits.join('') + 1).join('M') + roman; +}; + +exports.ROUND = function(number, digits) { + number = common.parseNumber(number); + digits = common.parseNumber(digits); + if (common.anyIsError(number, digits)) { + return error$1.value; + } + return Math.round(number * Math.pow(10, digits)) / Math.pow(10, digits); +}; + +exports.ROUNDDOWN = function(number, digits) { + number = common.parseNumber(number); + digits = common.parseNumber(digits); + if (common.anyIsError(number, digits)) { + return error$1.value; + } + var sign = (number > 0) ? 1 : -1; + return sign * (Math.floor(Math.abs(number) * Math.pow(10, digits))) / Math.pow(10, digits); +}; + +exports.ROUNDUP = function(number, digits) { + number = common.parseNumber(number); + digits = common.parseNumber(digits); + if (common.anyIsError(number, digits)) { + return error$1.value; + } + var sign = (number > 0) ? 1 : -1; + return sign * (Math.ceil(Math.abs(number) * Math.pow(10, digits))) / Math.pow(10, digits); +}; + +exports.SEC = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return 1 / Math.cos(number); +}; + +exports.SECH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return 2 / (Math.exp(number) + Math.exp(-number)); +}; + +exports.SERIESSUM = function(x, n, m, coefficients) { + x = common.parseNumber(x); + n = common.parseNumber(n); + m = common.parseNumber(m); + coefficients = common.parseNumberArray(coefficients); + if (common.anyIsError(x, n, m, coefficients)) { + return error$1.value; + } + var result = coefficients[0] * Math.pow(x, n); + for (var i = 1; i < coefficients.length; i++) { + result += coefficients[i] * Math.pow(x, n + i * m); + } + return result; +}; + +exports.SIGN = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + if (number < 0) { + return -1; + } else if (number === 0) { + return 0; + } else { + return 1; + } +}; + +exports.SIN = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return Math.sin(number); +}; + +exports.SINH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return (Math.exp(number) - Math.exp(-number)) / 2; +}; + +exports.SQRT = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + if (number < 0) { + return error$1.num; + } + return Math.sqrt(number); +}; + +exports.SQRTPI = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return Math.sqrt(number * Math.PI); +}; + +exports.SQRT1_2 = function() { + return 1 / Math.sqrt(2); +}; + +exports.SQRT2 = function() { + return Math.sqrt(2); +}; + +exports.SUBTOTAL = function(function_code, ref1) { + function_code = common.parseNumber(function_code); + if (function_code instanceof Error) { + return function_code; + } + switch (function_code) { + case 1: + return statistical.AVERAGE(ref1); + case 2: + return statistical.COUNT(ref1); + case 3: + return statistical.COUNTA(ref1); + case 4: + return statistical.MAX(ref1); + case 5: + return statistical.MIN(ref1); + case 6: + return exports.PRODUCT(ref1); + case 7: + return statistical.STDEV.S(ref1); + case 8: + return statistical.STDEV.P(ref1); + case 9: + return exports.SUM(ref1); + case 10: + return statistical.VAR.S(ref1); + case 11: + return statistical.VAR.P(ref1); + // no hidden values for us + case 101: + return statistical.AVERAGE(ref1); + case 102: + return statistical.COUNT(ref1); + case 103: + return statistical.COUNTA(ref1); + case 104: + return statistical.MAX(ref1); + case 105: + return statistical.MIN(ref1); + case 106: + return exports.PRODUCT(ref1); + case 107: + return statistical.STDEV.S(ref1); + case 108: + return statistical.STDEV.P(ref1); + case 109: + return exports.SUM(ref1); + case 110: + return statistical.VAR.S(ref1); + case 111: + return statistical.VAR.P(ref1); + + } +}; + +exports.ADD = function (num1, num2) { + if (arguments.length !== 2) { + return error$1.na; + } + + num1 = common.parseNumber(num1); + num2 = common.parseNumber(num2); + if (common.anyIsError(num1, num2)) { + return error$1.value; + } + + return num1 + num2; +}; + +exports.MINUS = function (num1, num2) { + if (arguments.length !== 2) { + return error$1.na; + } + + num1 = common.parseNumber(num1); + num2 = common.parseNumber(num2); + if (common.anyIsError(num1, num2)) { + return error$1.value; + } + + return num1 - num2; +}; + +exports.DIVIDE = function (dividend, divisor) { + if (arguments.length !== 2) { + return error$1.na; + } + + dividend = common.parseNumber(dividend); + divisor = common.parseNumber(divisor); + if (common.anyIsError(dividend, divisor)) { + return error$1.value; + } + + if (divisor === 0) { + return error$1.div0; + } + + return dividend / divisor; +}; + +exports.MULTIPLY = function (factor1, factor2) { + if (arguments.length !== 2) { + return error$1.na; + } + + factor1 = common.parseNumber(factor1); + factor2 = common.parseNumber(factor2); + if (common.anyIsError(factor1, factor2)) { + return error$1.value; + } + + return factor1 * factor2; +}; + +exports.GTE = function (num1, num2) { + if (arguments.length !== 2) { + return error$1.na; + } + + num1 = common.parseNumber(num1); + num2 = common.parseNumber(num2); + if (common.anyIsError(num1, num2)) { + return error$1.error; + } + + return num1 >= num2; +}; + +exports.LT = function (num1, num2) { + if (arguments.length !== 2) { + return error$1.na; + } + + num1 = common.parseNumber(num1); + num2 = common.parseNumber(num2); + if (common.anyIsError(num1, num2)) { + return error$1.error; + } + + return num1 < num2; +}; + + +exports.LTE = function (num1, num2) { + if (arguments.length !== 2) { + return error$1.na; + } + + num1 = common.parseNumber(num1); + num2 = common.parseNumber(num2); + if (common.anyIsError(num1, num2)) { + return error$1.error; + } + + return num1 <= num2; +}; + +exports.EQ = function (value1, value2) { + if (arguments.length !== 2) { + return error$1.na; + } + + return value1 === value2; +}; + +exports.NE = function (value1, value2) { + if (arguments.length !== 2) { + return error$1.na; + } + + return value1 !== value2; +}; + +exports.POW = function (base, exponent) { + if (arguments.length !== 2) { + return error$1.na; + } + + base = common.parseNumber(base); + exponent = common.parseNumber(exponent); + if (common.anyIsError(base, exponent)) { + return error$1.error; + } + + return exports.POWER(base, exponent); +}; + +exports.SUM = function() { + var result = 0; + + common.arrayEach(common.argsToArray(arguments), function(value) { + if (typeof value === 'number') { + result += value; + + } else if (typeof value === 'string') { + var parsed = parseFloat(value); + + !isNaN(parsed) && (result += parsed); + + } else if (Array.isArray(value)) { + result += exports.SUM.apply(null, value); + } + }); + + return result; +}; + +exports.SUMIF = function(range, criteria) { + range = common.parseNumberArray(common.flatten(range)); + + if (range instanceof Error) { + return range; + } + var result = 0; + var isWildcard = criteria === void 0 || criteria === '*'; + var tokenizedCriteria = isWildcard ? null : criteriaEval.parse(criteria + ''); + + for (var i = 0; i < range.length; i++) { + var value = range[i]; + + if (isWildcard) { + result += value; + } else { + var tokens = [criteriaEval.createToken(value, criteriaEval.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria); + + result += (criteriaEval.compute(tokens) ? value : 0); + } + } + + return result; +}; + +exports.SUMIFS = function() { + var args = common.argsToArray(arguments); + var range = common.parseNumberArray(common.flatten(args.shift())); + + if (range instanceof Error) { + return range; + } + var criterias = args; + var n_range_elements = range.length; + var criteriaLength = criterias.length; + var result = 0; + + for (var i = 0; i < n_range_elements; i++) { + var value = range[i]; + var isMeetCondition = false; + + for (var j = 0; j < criteriaLength; j++) { + var criteria = criterias[j]; + var isWildcard = criteria === void 0 || criteria === '*'; + var computedResult = false; + + if (isWildcard) { + computedResult = true; + } else { + var tokenizedCriteria = criteriaEval.parse(criteria + ''); + var tokens = [criteriaEval.createToken(value, criteriaEval.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria); + + computedResult = criteriaEval.compute(tokens); + } + + // Criterias are calculated as AND so any `false` breakes the loop as unmeet condition + if (!computedResult) { + isMeetCondition = false; + break; + } + + isMeetCondition = true; + } + + if (isMeetCondition) { + result += value; + } + } + + return result; +}; + +exports.SUMPRODUCT = function() { + if (!arguments || arguments.length === 0) { + return error$1.value; + } + var arrays = arguments.length + 1; + var result = 0; + var product; + var k; + var _i; + var _ij; + for (var i = 0; i < arguments[0].length; i++) { + if (!(arguments[0][i] instanceof Array)) { + product = 1; + for (k = 1; k < arrays; k++) { + _i = common.parseNumber(arguments[k - 1][i]); + if (_i instanceof Error) { + return _i; + } + product *= _i; + } + result += product; + } else { + for (var j = 0; j < arguments[0][i].length; j++) { + product = 1; + for (k = 1; k < arrays; k++) { + _ij = common.parseNumber(arguments[k - 1][i][j]); + if (_ij instanceof Error) { + return _ij; + } + product *= _ij; + } + result += product; + } + } + } + return result; +}; + +exports.SUMSQ = function() { + var numbers = common.parseNumberArray(common.flatten(arguments)); + if (numbers instanceof Error) { + return numbers; + } + var result = 0; + var length = numbers.length; + for (var i = 0; i < length; i++) { + result += (information.ISNUMBER(numbers[i])) ? numbers[i] * numbers[i] : 0; + } + return result; +}; + +exports.SUMX2MY2 = function(array_x, array_y) { + array_x = common.parseNumberArray(common.flatten(array_x)); + array_y = common.parseNumberArray(common.flatten(array_y)); + if (common.anyIsError(array_x, array_y)) { + return error$1.value; + } + var result = 0; + for (var i = 0; i < array_x.length; i++) { + result += array_x[i] * array_x[i] - array_y[i] * array_y[i]; + } + return result; +}; + +exports.SUMX2PY2 = function(array_x, array_y) { + array_x = common.parseNumberArray(common.flatten(array_x)); + array_y = common.parseNumberArray(common.flatten(array_y)); + if (common.anyIsError(array_x, array_y)) { + return error$1.value; + } + var result = 0; + array_x = common.parseNumberArray(common.flatten(array_x)); + array_y = common.parseNumberArray(common.flatten(array_y)); + for (var i = 0; i < array_x.length; i++) { + result += array_x[i] * array_x[i] + array_y[i] * array_y[i]; + } + return result; +}; + +exports.SUMXMY2 = function(array_x, array_y) { + array_x = common.parseNumberArray(common.flatten(array_x)); + array_y = common.parseNumberArray(common.flatten(array_y)); + if (common.anyIsError(array_x, array_y)) { + return error$1.value; + } + var result = 0; + array_x = common.flatten(array_x); + array_y = common.flatten(array_y); + for (var i = 0; i < array_x.length; i++) { + result += Math.pow(array_x[i] - array_y[i], 2); + } + return result; +}; + +exports.TAN = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + return Math.tan(number); +}; + +exports.TANH = function(number) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + var e2 = Math.exp(2 * number); + return (e2 - 1) / (e2 + 1); +}; + +exports.TRUNC = function(number, digits) { + digits = (digits === undefined) ? 0 : digits; + number = common.parseNumber(number); + digits = common.parseNumber(digits); + if (common.anyIsError(number, digits)) { + return error$1.value; + } + var sign = (number > 0) ? 1 : -1; + return sign * (Math.floor(Math.abs(number) * Math.pow(10, digits))) / Math.pow(10, digits); +}; +}); + +var bessel = createCommonjsModule(function (module, exports) { +(function (factory) { + /*jshint ignore:start */ + if(typeof DO_NOT_EXPORT_BESSEL === 'undefined') { + { + factory(exports); + } + } else { + factory({}); + } + /*jshint ignore:end */ +}(function(BESSEL) { +BESSEL.version = '1.0.2'; +var M = Math; + +function _horner(arr, v) { for(var i = 0, z = 0; i < arr.length; ++i) z = v * z + arr[i]; return z; } +function _bessel_iter(x, n, f0, f1, sign) { + if(n === 0) return f0; + if(n === 1) return f1; + var tdx = 2 / x, f2 = f1; + for(var o = 1; o < n; ++o) { + f2 = f1 * o * tdx + sign * f0; + f0 = f1; f1 = f2; + } + return f2; +} +function _bessel_wrap(bessel0, bessel1, name, nonzero, sign) { + return function bessel(x,n) { + if(nonzero) { + if(x === 0) return (nonzero == 1 ? -Infinity : Infinity); + else if(x < 0) return NaN; + } + if(n === 0) return bessel0(x); + if(n === 1) return bessel1(x); + if(n < 0) return NaN; + n|=0; + var b0 = bessel0(x), b1 = bessel1(x); + return _bessel_iter(x, n, b0, b1, sign); + }; +} +var besselj = (function() { + var W = 0.636619772; // 2 / Math.PI + + var b0_a1a = [57568490574.0, -13362590354.0, 651619640.7, -11214424.18, 77392.33017, -184.9052456].reverse(); + var b0_a2a = [57568490411.0, 1029532985.0, 9494680.718, 59272.64853, 267.8532712, 1.0].reverse(); + var b0_a1b = [1.0, -0.1098628627e-2, 0.2734510407e-4, -0.2073370639e-5, 0.2093887211e-6].reverse(); + var b0_a2b = [-0.1562499995e-1, 0.1430488765e-3, -0.6911147651e-5, 0.7621095161e-6, -0.934935152e-7].reverse(); + + function bessel0(x) { + var a=0, a1=0, a2=0, y = x * x; + if(x < 8) { + a1 = _horner(b0_a1a, y); + a2 = _horner(b0_a2a, y); + a = a1 / a2; + } else { + var xx = x - 0.785398164; + y = 64 / y; + a1 = _horner(b0_a1b, y); + a2 = _horner(b0_a2b, y); + a = M.sqrt(W/x)*(M.cos(xx)*a1-M.sin(xx)*a2*8/x); + } + return a; + } + + var b1_a1a = [72362614232.0, -7895059235.0, 242396853.1, -2972611.439, 15704.48260, -30.16036606].reverse(); + var b1_a2a = [144725228442.0, 2300535178.0, 18583304.74, 99447.43394, 376.9991397, 1.0].reverse(); + var b1_a1b = [1.0, 0.183105e-2, -0.3516396496e-4, 0.2457520174e-5, -0.240337019e-6].reverse(); + var b1_a2b = [0.04687499995, -0.2002690873e-3, 0.8449199096e-5, -0.88228987e-6, 0.105787412e-6].reverse(); + + function bessel1(x) { + var a=0, a1=0, a2=0, y = x*x, xx = M.abs(x) - 2.356194491; + if(Math.abs(x)< 8) { + a1 = x*_horner(b1_a1a, y); + a2 = _horner(b1_a2a, y); + a = a1 / a2; + } else { + y = 64 / y; + a1=_horner(b1_a1b, y); + a2=_horner(b1_a2b, y); + a=M.sqrt(W/M.abs(x))*(M.cos(xx)*a1-M.sin(xx)*a2*8/M.abs(x)); + if(x < 0) a = -a; + } + return a; + } + + return function besselj(x, n) { + n = Math.round(n); + if(!isFinite(x)) return isNaN(x) ? x : 0; + if(n < 0) return ((n%2)?-1:1)*besselj(x, -n); + if(x < 0) return ((n%2)?-1:1)*besselj(-x, n); + if(n === 0) return bessel0(x); + if(n === 1) return bessel1(x); + if(x === 0) return 0; + + var ret=0.0; + if(x > n) { + ret = _bessel_iter(x, n, bessel0(x), bessel1(x),-1); + } else { + var m=2*M.floor((n+M.floor(M.sqrt(40*n)))/2); + var jsum=false; + var bjp=0.0, sum=0.0; + var bj=1.0, bjm = 0.0; + var tox = 2 / x; + for (var j=m;j>0;j--) { + bjm=j*tox*bj-bjp; + bjp=bj; + bj=bjm; + if (M.abs(bj) > 1E10) { + bj *= 1E-10; + bjp *= 1E-10; + ret *= 1E-10; + sum *= 1E-10; + } + if (jsum) sum += bj; + jsum=!jsum; + if (j == n) ret=bjp; + } + sum=2.0*sum-bj; + ret /= sum; + } + return ret; + }; +})(); +var bessely = (function() { + var W = 0.636619772; + + var b0_a1a = [-2957821389.0, 7062834065.0, -512359803.6, 10879881.29, -86327.92757, 228.4622733].reverse(); + var b0_a2a = [40076544269.0, 745249964.8, 7189466.438, 47447.26470, 226.1030244, 1.0].reverse(); + var b0_a1b = [1.0, -0.1098628627e-2, 0.2734510407e-4, -0.2073370639e-5, 0.2093887211e-6].reverse(); + var b0_a2b = [-0.1562499995e-1, 0.1430488765e-3, -0.6911147651e-5, 0.7621095161e-6, -0.934945152e-7].reverse(); + + function bessel0(x) { + var a=0, a1=0, a2=0, y = x * x, xx = x - 0.785398164; + if(x < 8) { + a1 = _horner(b0_a1a, y); + a2 = _horner(b0_a2a, y); + a = a1/a2 + W * besselj(x,0) * M.log(x); + } else { + y = 64 / y; + a1 = _horner(b0_a1b, y); + a2 = _horner(b0_a2b, y); + a = M.sqrt(W/x)*(M.sin(xx)*a1+M.cos(xx)*a2*8/x); + } + return a; + } + + var b1_a1a = [-0.4900604943e13, 0.1275274390e13, -0.5153438139e11, 0.7349264551e9, -0.4237922726e7, 0.8511937935e4].reverse(); + var b1_a2a = [0.2499580570e14, 0.4244419664e12, 0.3733650367e10, 0.2245904002e8, 0.1020426050e6, 0.3549632885e3, 1].reverse(); + var b1_a1b = [1.0, 0.183105e-2, -0.3516396496e-4, 0.2457520174e-5, -0.240337019e-6].reverse(); + var b1_a2b = [0.04687499995, -0.2002690873e-3, 0.8449199096e-5, -0.88228987e-6, 0.105787412e-6].reverse(); + + function bessel1(x) { + var a=0, a1=0, a2=0, y = x*x, xx = x - 2.356194491; + if(x < 8) { + a1 = x*_horner(b1_a1a, y); + a2 = _horner(b1_a2a, y); + a = a1/a2 + W * (besselj(x,1) * M.log(x) - 1 / x); + } else { + y = 64 / y; + a1=_horner(b1_a1b, y); + a2=_horner(b1_a2b, y); + a=M.sqrt(W/x)*(M.sin(xx)*a1+M.cos(xx)*a2*8/x); + } + return a; + } + + return _bessel_wrap(bessel0, bessel1, 'BESSELY', 1, -1); +})(); +var besseli = (function() { + var b0_a = [1.0, 3.5156229, 3.0899424, 1.2067492, 0.2659732, 0.360768e-1, 0.45813e-2].reverse(); + var b0_b = [0.39894228, 0.1328592e-1, 0.225319e-2, -0.157565e-2, 0.916281e-2, -0.2057706e-1, 0.2635537e-1, -0.1647633e-1, 0.392377e-2].reverse(); + + function bessel0(x) { + if(x <= 3.75) return _horner(b0_a, x*x/(3.75*3.75)); + return M.exp(M.abs(x))/M.sqrt(M.abs(x))*_horner(b0_b, 3.75/M.abs(x)); + } + + var b1_a = [0.5, 0.87890594, 0.51498869, 0.15084934, 0.2658733e-1, 0.301532e-2, 0.32411e-3].reverse(); + var b1_b = [0.39894228, -0.3988024e-1, -0.362018e-2, 0.163801e-2, -0.1031555e-1, 0.2282967e-1, -0.2895312e-1, 0.1787654e-1, -0.420059e-2].reverse(); + + function bessel1(x) { + if(x < 3.75) return x * _horner(b1_a, x*x/(3.75*3.75)); + return (x < 0 ? -1 : 1) * M.exp(M.abs(x))/M.sqrt(M.abs(x))*_horner(b1_b, 3.75/M.abs(x)); + } + + return function besseli(x, n) { + n = Math.round(n); + if(n === 0) return bessel0(x); + if(n === 1) return bessel1(x); + if(n < 0) return NaN; + if(M.abs(x) === 0) return 0; + if(x == Infinity) return Infinity; + + var ret = 0.0, j, tox = 2 / M.abs(x), bip = 0.0, bi=1.0, bim=0.0; + var m=2*M.round((n+M.round(M.sqrt(40*n)))/2); + for (j=m;j>0;j--) { + bim=j*tox*bi + bip; + bip=bi; bi=bim; + if (M.abs(bi) > 1E10) { + bi *= 1E-10; + bip *= 1E-10; + ret *= 1E-10; + } + if(j == n) ret = bip; + } + ret *= besseli(x, 0) / bi; + return x < 0 && (n%2) ? -ret : ret; + }; + +})(); + +var besselk = (function() { + var b0_a = [-0.57721566, 0.42278420, 0.23069756, 0.3488590e-1, 0.262698e-2, 0.10750e-3, 0.74e-5].reverse(); + var b0_b = [1.25331414, -0.7832358e-1, 0.2189568e-1, -0.1062446e-1, 0.587872e-2, -0.251540e-2, 0.53208e-3].reverse(); + + function bessel0(x) { + if(x <= 2) return -M.log(x/2) * besseli(x,0) + _horner(b0_a, x*x/4); + return M.exp(-x) / M.sqrt(x) * _horner(b0_b, 2/x); + } + + var b1_a = [1.0, 0.15443144, -0.67278579, -0.18156897, -0.1919402e-1, -0.110404e-2, -0.4686e-4].reverse(); + var b1_b = [1.25331414, 0.23498619, -0.3655620e-1, 0.1504268e-1, -0.780353e-2, 0.325614e-2, -0.68245e-3].reverse(); + + function bessel1(x) { + if(x <= 2) return M.log(x/2) * besseli(x,1) + (1/x) * _horner(b1_a, x*x/4); + return M.exp(-x)/M.sqrt(x)*_horner(b1_b, 2/x); + } + + return _bessel_wrap(bessel0, bessel1, 'BESSELK', 2, 1); +})(); +BESSEL.besselj = besselj; +BESSEL.bessely = bessely; +BESSEL.besseli = besseli; +BESSEL.besselk = besselk; +})); +}); + +var engineering = createCommonjsModule(function (module, exports) { +function isValidBinaryNumber(number) { + return (/^[01]{1,10}$/).test(number); +} + +exports.BESSELI = function(x, n) { + x = common.parseNumber(x); + n = common.parseNumber(n); + if (common.anyIsError(x, n)) { + return error$1.value; + } + + return bessel.besseli(x, n); +}; + +exports.BESSELJ = function(x, n) { + x = common.parseNumber(x); + n = common.parseNumber(n); + if (common.anyIsError(x, n)) { + return error$1.value; + } + + return bessel.besselj(x, n); +}; + +exports.BESSELK = function(x, n) { + x = common.parseNumber(x); + n = common.parseNumber(n); + if (common.anyIsError(x, n)) { + return error$1.value; + } + + return bessel.besselk(x, n); +}; + +exports.BESSELY = function(x, n) { + x = common.parseNumber(x); + n = common.parseNumber(n); + if (common.anyIsError(x, n)) { + return error$1.value; + } + + return bessel.bessely(x, n); +}; + +exports.BIN2DEC = function(number) { + // Return error if number is not binary or contains more than 10 characters (10 digits) + if (!isValidBinaryNumber(number)) { + return error$1.num; + } + + // Convert binary number to decimal + var result = parseInt(number, 2); + + // Handle negative numbers + var stringified = number.toString(); + if (stringified.length === 10 && stringified.substring(0, 1) === '1') { + return parseInt(stringified.substring(1), 2) - 512; + } else { + return result; + } +}; + + +exports.BIN2HEX = function(number, places) { + // Return error if number is not binary or contains more than 10 characters (10 digits) + if (!isValidBinaryNumber(number)) { + return error$1.num; + } + + // Ignore places and return a 10-character hexadecimal number if number is negative + var stringified = number.toString(); + if (stringified.length === 10 && stringified.substring(0, 1) === '1') { + return (1099511627264 + parseInt(stringified.substring(1), 2)).toString(16); + } + + // Convert binary number to hexadecimal + var result = parseInt(number, 2).toString(16); + + // Return hexadecimal number using the minimum number of characters necessary if places is undefined + if (places === undefined) { + return result; + } else { + // Return error if places is nonnumeric + if (isNaN(places)) { + return error$1.value; + } + + // Return error if places is negative + if (places < 0) { + return error$1.num; + } + + // Truncate places in case it is not an integer + places = Math.floor(places); + + // Pad return value with leading 0s (zeros) if necessary (using Underscore.string) + return (places >= result.length) ? text$1.REPT('0', places - result.length) + result : error$1.num; + } +}; + +exports.BIN2OCT = function(number, places) { + // Return error if number is not binary or contains more than 10 characters (10 digits) + if (!isValidBinaryNumber(number)) { + return error$1.num; + } + + // Ignore places and return a 10-character octal number if number is negative + var stringified = number.toString(); + if (stringified.length === 10 && stringified.substring(0, 1) === '1') { + return (1073741312 + parseInt(stringified.substring(1), 2)).toString(8); + } + + // Convert binary number to octal + var result = parseInt(number, 2).toString(8); + + // Return octal number using the minimum number of characters necessary if places is undefined + if (places === undefined) { + return result; + } else { + // Return error if places is nonnumeric + if (isNaN(places)) { + return error$1.value; + } + + // Return error if places is negative + if (places < 0) { + return error$1.num; + } + + // Truncate places in case it is not an integer + places = Math.floor(places); + + // Pad return value with leading 0s (zeros) if necessary (using Underscore.string) + return (places >= result.length) ? text$1.REPT('0', places - result.length) + result : error$1.num; + } +}; + +exports.BITAND = function(number1, number2) { + // Return error if either number is a non-numeric value + number1 = common.parseNumber(number1); + number2 = common.parseNumber(number2); + if (common.anyIsError(number1, number2)) { + return error$1.value; + } + + // Return error if either number is less than 0 + if (number1 < 0 || number2 < 0) { + return error$1.num; + } + + // Return error if either number is a non-integer + if (Math.floor(number1) !== number1 || Math.floor(number2) !== number2) { + return error$1.num; + } + + // Return error if either number is greater than (2^48)-1 + if (number1 > 281474976710655 || number2 > 281474976710655) { + return error$1.num; + } + + // Return bitwise AND of two numbers + return number1 & number2; +}; + +exports.BITLSHIFT = function(number, shift) { + number = common.parseNumber(number); + shift = common.parseNumber(shift); + if (common.anyIsError(number, shift)) { + return error$1.value; + } + + // Return error if number is less than 0 + if (number < 0) { + return error$1.num; + } + + // Return error if number is a non-integer + if (Math.floor(number) !== number) { + return error$1.num; + } + + // Return error if number is greater than (2^48)-1 + if (number > 281474976710655) { + return error$1.num; + } + + // Return error if the absolute value of shift is greater than 53 + if (Math.abs(shift) > 53) { + return error$1.num; + } + + // Return number shifted by shift bits to the left or to the right if shift is negative + return (shift >= 0) ? number << shift : number >> -shift; +}; + +exports.BITOR = function(number1, number2) { + number1 = common.parseNumber(number1); + number2 = common.parseNumber(number2); + if (common.anyIsError(number1, number2)) { + return error$1.value; + } + + // Return error if either number is less than 0 + if (number1 < 0 || number2 < 0) { + return error$1.num; + } + + // Return error if either number is a non-integer + if (Math.floor(number1) !== number1 || Math.floor(number2) !== number2) { + return error$1.num; + } + + // Return error if either number is greater than (2^48)-1 + if (number1 > 281474976710655 || number2 > 281474976710655) { + return error$1.num; + } + + // Return bitwise OR of two numbers + return number1 | number2; +}; + +exports.BITRSHIFT = function(number, shift) { + number = common.parseNumber(number); + shift = common.parseNumber(shift); + if (common.anyIsError(number, shift)) { + return error$1.value; + } + + // Return error if number is less than 0 + if (number < 0) { + return error$1.num; + } + + // Return error if number is a non-integer + if (Math.floor(number) !== number) { + return error$1.num; + } + + // Return error if number is greater than (2^48)-1 + if (number > 281474976710655) { + return error$1.num; + } + + // Return error if the absolute value of shift is greater than 53 + if (Math.abs(shift) > 53) { + return error$1.num; + } + + // Return number shifted by shift bits to the right or to the left if shift is negative + return (shift >= 0) ? number >> shift : number << -shift; +}; + +exports.BITXOR = function(number1, number2) { + number1 = common.parseNumber(number1); + number2 = common.parseNumber(number2); + if (common.anyIsError(number1, number2)) { + return error$1.value; + } + + // Return error if either number is less than 0 + if (number1 < 0 || number2 < 0) { + return error$1.num; + } + + // Return error if either number is a non-integer + if (Math.floor(number1) !== number1 || Math.floor(number2) !== number2) { + return error$1.num; + } + + // Return error if either number is greater than (2^48)-1 + if (number1 > 281474976710655 || number2 > 281474976710655) { + return error$1.num; + } + + // Return bitwise XOR of two numbers + return number1 ^ number2; +}; + +exports.COMPLEX = function(real, imaginary, suffix) { + real = common.parseNumber(real); + imaginary = common.parseNumber(imaginary); + if (common.anyIsError(real, imaginary)) { + return real; + } + + // Set suffix + suffix = (suffix === undefined) ? 'i' : suffix; + + // Return error if suffix is neither "i" nor "j" + if (suffix !== 'i' && suffix !== 'j') { + return error$1.value; + } + + // Return complex number + if (real === 0 && imaginary === 0) { + return 0; + } else if (real === 0) { + return (imaginary === 1) ? suffix : imaginary.toString() + suffix; + } else if (imaginary === 0) { + return real.toString(); + } else { + var sign = (imaginary > 0) ? '+' : ''; + return real.toString() + sign + ((imaginary === 1) ? suffix : imaginary.toString() + suffix); + } +}; + +exports.CONVERT = function(number, from_unit, to_unit) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + + // List of units supported by CONVERT and units defined by the International System of Units + // [Name, Symbol, Alternate symbols, Quantity, ISU, CONVERT, Conversion ratio] + var units = [ + ["a.u. of action", "?", null, "action", false, false, 1.05457168181818e-34], + ["a.u. of charge", "e", null, "electric_charge", false, false, 1.60217653141414e-19], + ["a.u. of energy", "Eh", null, "energy", false, false, 4.35974417757576e-18], + ["a.u. of length", "a?", null, "length", false, false, 5.29177210818182e-11], + ["a.u. of mass", "m?", null, "mass", false, false, 9.10938261616162e-31], + ["a.u. of time", "?/Eh", null, "time", false, false, 2.41888432650516e-17], + ["admiralty knot", "admkn", null, "speed", false, true, 0.514773333], + ["ampere", "A", null, "electric_current", true, false, 1], + ["ampere per meter", "A/m", null, "magnetic_field_intensity", true, false, 1], + ["ångström", "Å", ["ang"], "length", false, true, 1e-10], + ["are", "ar", null, "area", false, true, 100], + ["astronomical unit", "ua", null, "length", false, false, 1.49597870691667e-11], + ["bar", "bar", null, "pressure", false, false, 100000], + ["barn", "b", null, "area", false, false, 1e-28], + ["becquerel", "Bq", null, "radioactivity", true, false, 1], + ["bit", "bit", ["b"], "information", false, true, 1], + ["btu", "BTU", ["btu"], "energy", false, true, 1055.05585262], + ["byte", "byte", null, "information", false, true, 8], + ["candela", "cd", null, "luminous_intensity", true, false, 1], + ["candela per square metre", "cd/m?", null, "luminance", true, false, 1], + ["coulomb", "C", null, "electric_charge", true, false, 1], + ["cubic ångström", "ang3", ["ang^3"], "volume", false, true, 1e-30], + ["cubic foot", "ft3", ["ft^3"], "volume", false, true, 0.028316846592], + ["cubic inch", "in3", ["in^3"], "volume", false, true, 0.000016387064], + ["cubic light-year", "ly3", ["ly^3"], "volume", false, true, 8.46786664623715e-47], + ["cubic metre", "m?", null, "volume", true, true, 1], + ["cubic mile", "mi3", ["mi^3"], "volume", false, true, 4168181825.44058], + ["cubic nautical mile", "Nmi3", ["Nmi^3"], "volume", false, true, 6352182208], + ["cubic Pica", "Pica3", ["Picapt3", "Pica^3", "Picapt^3"], "volume", false, true, 7.58660370370369e-8], + ["cubic yard", "yd3", ["yd^3"], "volume", false, true, 0.764554857984], + ["cup", "cup", null, "volume", false, true, 0.0002365882365], + ["dalton", "Da", ["u"], "mass", false, false, 1.66053886282828e-27], + ["day", "d", ["day"], "time", false, true, 86400], + ["degree", "°", null, "angle", false, false, 0.0174532925199433], + ["degrees Rankine", "Rank", null, "temperature", false, true, 0.555555555555556], + ["dyne", "dyn", ["dy"], "force", false, true, 0.00001], + ["electronvolt", "eV", ["ev"], "energy", false, true, 1.60217656514141], + ["ell", "ell", null, "length", false, true, 1.143], + ["erg", "erg", ["e"], "energy", false, true, 1e-7], + ["farad", "F", null, "electric_capacitance", true, false, 1], + ["fluid ounce", "oz", null, "volume", false, true, 0.0000295735295625], + ["foot", "ft", null, "length", false, true, 0.3048], + ["foot-pound", "flb", null, "energy", false, true, 1.3558179483314], + ["gal", "Gal", null, "acceleration", false, false, 0.01], + ["gallon", "gal", null, "volume", false, true, 0.003785411784], + ["gauss", "G", ["ga"], "magnetic_flux_density", false, true, 1], + ["grain", "grain", null, "mass", false, true, 0.0000647989], + ["gram", "g", null, "mass", false, true, 0.001], + ["gray", "Gy", null, "absorbed_dose", true, false, 1], + ["gross registered ton", "GRT", ["regton"], "volume", false, true, 2.8316846592], + ["hectare", "ha", null, "area", false, true, 10000], + ["henry", "H", null, "inductance", true, false, 1], + ["hertz", "Hz", null, "frequency", true, false, 1], + ["horsepower", "HP", ["h"], "power", false, true, 745.69987158227], + ["horsepower-hour", "HPh", ["hh", "hph"], "energy", false, true, 2684519.538], + ["hour", "h", ["hr"], "time", false, true, 3600], + ["imperial gallon (U.K.)", "uk_gal", null, "volume", false, true, 0.00454609], + ["imperial hundredweight", "lcwt", ["uk_cwt", "hweight"], "mass", false, true, 50.802345], + ["imperial quart (U.K)", "uk_qt", null, "volume", false, true, 0.0011365225], + ["imperial ton", "brton", ["uk_ton", "LTON"], "mass", false, true, 1016.046909], + ["inch", "in", null, "length", false, true, 0.0254], + ["international acre", "uk_acre", null, "area", false, true, 4046.8564224], + ["IT calorie", "cal", null, "energy", false, true, 4.1868], + ["joule", "J", null, "energy", true, true, 1], + ["katal", "kat", null, "catalytic_activity", true, false, 1], + ["kelvin", "K", ["kel"], "temperature", true, true, 1], + ["kilogram", "kg", null, "mass", true, true, 1], + ["knot", "kn", null, "speed", false, true, 0.514444444444444], + ["light-year", "ly", null, "length", false, true, 9460730472580800], + ["litre", "L", ["l", "lt"], "volume", false, true, 0.001], + ["lumen", "lm", null, "luminous_flux", true, false, 1], + ["lux", "lx", null, "illuminance", true, false, 1], + ["maxwell", "Mx", null, "magnetic_flux", false, false, 1e-18], + ["measurement ton", "MTON", null, "volume", false, true, 1.13267386368], + ["meter per hour", "m/h", ["m/hr"], "speed", false, true, 0.00027777777777778], + ["meter per second", "m/s", ["m/sec"], "speed", true, true, 1], + ["meter per second squared", "m?s??", null, "acceleration", true, false, 1], + ["parsec", "pc", ["parsec"], "length", false, true, 30856775814671900], + ["meter squared per second", "m?/s", null, "kinematic_viscosity", true, false, 1], + ["metre", "m", null, "length", true, true, 1], + ["miles per hour", "mph", null, "speed", false, true, 0.44704], + ["millimetre of mercury", "mmHg", null, "pressure", false, false, 133.322], + ["minute", "?", null, "angle", false, false, 0.000290888208665722], + ["minute", "min", ["mn"], "time", false, true, 60], + ["modern teaspoon", "tspm", null, "volume", false, true, 0.000005], + ["mole", "mol", null, "amount_of_substance", true, false, 1], + ["morgen", "Morgen", null, "area", false, true, 2500], + ["n.u. of action", "?", null, "action", false, false, 1.05457168181818e-34], + ["n.u. of mass", "m?", null, "mass", false, false, 9.10938261616162e-31], + ["n.u. of speed", "c?", null, "speed", false, false, 299792458], + ["n.u. of time", "?/(me?c??)", null, "time", false, false, 1.28808866778687e-21], + ["nautical mile", "M", ["Nmi"], "length", false, true, 1852], + ["newton", "N", null, "force", true, true, 1], + ["œrsted", "Oe ", null, "magnetic_field_intensity", false, false, 79.5774715459477], + ["ohm", "Ω", null, "electric_resistance", true, false, 1], + ["ounce mass", "ozm", null, "mass", false, true, 0.028349523125], + ["pascal", "Pa", null, "pressure", true, false, 1], + ["pascal second", "Pa?s", null, "dynamic_viscosity", true, false, 1], + ["pferdestärke", "PS", null, "power", false, true, 735.49875], + ["phot", "ph", null, "illuminance", false, false, 0.0001], + ["pica (1/6 inch)", "pica", null, "length", false, true, 0.00035277777777778], + ["pica (1/72 inch)", "Pica", ["Picapt"], "length", false, true, 0.00423333333333333], + ["poise", "P", null, "dynamic_viscosity", false, false, 0.1], + ["pond", "pond", null, "force", false, true, 0.00980665], + ["pound force", "lbf", null, "force", false, true, 4.4482216152605], + ["pound mass", "lbm", null, "mass", false, true, 0.45359237], + ["quart", "qt", null, "volume", false, true, 0.000946352946], + ["radian", "rad", null, "angle", true, false, 1], + ["second", "?", null, "angle", false, false, 0.00000484813681109536], + ["second", "s", ["sec"], "time", true, true, 1], + ["short hundredweight", "cwt", ["shweight"], "mass", false, true, 45.359237], + ["siemens", "S", null, "electrical_conductance", true, false, 1], + ["sievert", "Sv", null, "equivalent_dose", true, false, 1], + ["slug", "sg", null, "mass", false, true, 14.59390294], + ["square ångström", "ang2", ["ang^2"], "area", false, true, 1e-20], + ["square foot", "ft2", ["ft^2"], "area", false, true, 0.09290304], + ["square inch", "in2", ["in^2"], "area", false, true, 0.00064516], + ["square light-year", "ly2", ["ly^2"], "area", false, true, 8.95054210748189e+31], + ["square meter", "m?", null, "area", true, true, 1], + ["square mile", "mi2", ["mi^2"], "area", false, true, 2589988.110336], + ["square nautical mile", "Nmi2", ["Nmi^2"], "area", false, true, 3429904], + ["square Pica", "Pica2", ["Picapt2", "Pica^2", "Picapt^2"], "area", false, true, 0.00001792111111111], + ["square yard", "yd2", ["yd^2"], "area", false, true, 0.83612736], + ["statute mile", "mi", null, "length", false, true, 1609.344], + ["steradian", "sr", null, "solid_angle", true, false, 1], + ["stilb", "sb", null, "luminance", false, false, 0.0001], + ["stokes", "St", null, "kinematic_viscosity", false, false, 0.0001], + ["stone", "stone", null, "mass", false, true, 6.35029318], + ["tablespoon", "tbs", null, "volume", false, true, 0.0000147868], + ["teaspoon", "tsp", null, "volume", false, true, 0.00000492892], + ["tesla", "T", null, "magnetic_flux_density", true, true, 1], + ["thermodynamic calorie", "c", null, "energy", false, true, 4.184], + ["ton", "ton", null, "mass", false, true, 907.18474], + ["tonne", "t", null, "mass", false, false, 1000], + ["U.K. pint", "uk_pt", null, "volume", false, true, 0.00056826125], + ["U.S. bushel", "bushel", null, "volume", false, true, 0.03523907], + ["U.S. oil barrel", "barrel", null, "volume", false, true, 0.158987295], + ["U.S. pint", "pt", ["us_pt"], "volume", false, true, 0.000473176473], + ["U.S. survey mile", "survey_mi", null, "length", false, true, 1609.347219], + ["U.S. survey/statute acre", "us_acre", null, "area", false, true, 4046.87261], + ["volt", "V", null, "voltage", true, false, 1], + ["watt", "W", null, "power", true, true, 1], + ["watt-hour", "Wh", ["wh"], "energy", false, true, 3600], + ["weber", "Wb", null, "magnetic_flux", true, false, 1], + ["yard", "yd", null, "length", false, true, 0.9144], + ["year", "yr", null, "time", false, true, 31557600] + ]; + + // Binary prefixes + // [Name, Prefix power of 2 value, Previx value, Abbreviation, Derived from] + var binary_prefixes = { + Yi: ["yobi", 80, 1208925819614629174706176, "Yi", "yotta"], + Zi: ["zebi", 70, 1180591620717411303424, "Zi", "zetta"], + Ei: ["exbi", 60, 1152921504606846976, "Ei", "exa"], + Pi: ["pebi", 50, 1125899906842624, "Pi", "peta"], + Ti: ["tebi", 40, 1099511627776, "Ti", "tera"], + Gi: ["gibi", 30, 1073741824, "Gi", "giga"], + Mi: ["mebi", 20, 1048576, "Mi", "mega"], + ki: ["kibi", 10, 1024, "ki", "kilo"] + }; + + // Unit prefixes + // [Name, Multiplier, Abbreviation] + var unit_prefixes = { + Y: ["yotta", 1e+24, "Y"], + Z: ["zetta", 1e+21, "Z"], + E: ["exa", 1e+18, "E"], + P: ["peta", 1e+15, "P"], + T: ["tera", 1e+12, "T"], + G: ["giga", 1e+09, "G"], + M: ["mega", 1e+06, "M"], + k: ["kilo", 1e+03, "k"], + h: ["hecto", 1e+02, "h"], + e: ["dekao", 1e+01, "e"], + d: ["deci", 1e-01, "d"], + c: ["centi", 1e-02, "c"], + m: ["milli", 1e-03, "m"], + u: ["micro", 1e-06, "u"], + n: ["nano", 1e-09, "n"], + p: ["pico", 1e-12, "p"], + f: ["femto", 1e-15, "f"], + a: ["atto", 1e-18, "a"], + z: ["zepto", 1e-21, "z"], + y: ["yocto", 1e-24, "y"] + }; + + // Initialize units and multipliers + var from = null; + var to = null; + var base_from_unit = from_unit; + var base_to_unit = to_unit; + var from_multiplier = 1; + var to_multiplier = 1; + var alt; + + // Lookup from and to units + for (var i = 0; i < units.length; i++) { + alt = (units[i][2] === null) ? [] : units[i][2]; + if (units[i][1] === base_from_unit || alt.indexOf(base_from_unit) >= 0) { + from = units[i]; + } + if (units[i][1] === base_to_unit || alt.indexOf(base_to_unit) >= 0) { + to = units[i]; + } + } + + // Lookup from prefix + if (from === null) { + var from_binary_prefix = binary_prefixes[from_unit.substring(0, 2)]; + var from_unit_prefix = unit_prefixes[from_unit.substring(0, 1)]; + + // Handle dekao unit prefix (only unit prefix with two characters) + if (from_unit.substring(0, 2) === 'da') { + from_unit_prefix = ["dekao", 1e+01, "da"]; + } + + // Handle binary prefixes first (so that 'Yi' is processed before 'Y') + if (from_binary_prefix) { + from_multiplier = from_binary_prefix[2]; + base_from_unit = from_unit.substring(2); + } else if (from_unit_prefix) { + from_multiplier = from_unit_prefix[1]; + base_from_unit = from_unit.substring(from_unit_prefix[2].length); + } + + // Lookup from unit + for (var j = 0; j < units.length; j++) { + alt = (units[j][2] === null) ? [] : units[j][2]; + if (units[j][1] === base_from_unit || alt.indexOf(base_from_unit) >= 0) { + from = units[j]; + } + } + } + + // Lookup to prefix + if (to === null) { + var to_binary_prefix = binary_prefixes[to_unit.substring(0, 2)]; + var to_unit_prefix = unit_prefixes[to_unit.substring(0, 1)]; + + // Handle dekao unit prefix (only unit prefix with two characters) + if (to_unit.substring(0, 2) === 'da') { + to_unit_prefix = ["dekao", 1e+01, "da"]; + } + + // Handle binary prefixes first (so that 'Yi' is processed before 'Y') + if (to_binary_prefix) { + to_multiplier = to_binary_prefix[2]; + base_to_unit = to_unit.substring(2); + } else if (to_unit_prefix) { + to_multiplier = to_unit_prefix[1]; + base_to_unit = to_unit.substring(to_unit_prefix[2].length); + } + + // Lookup to unit + for (var k = 0; k < units.length; k++) { + alt = (units[k][2] === null) ? [] : units[k][2]; + if (units[k][1] === base_to_unit || alt.indexOf(base_to_unit) >= 0) { + to = units[k]; + } + } + } + + // Return error if a unit does not exist + if (from === null || to === null) { + return error$1.na; + } + + // Return error if units represent different quantities + if (from[3] !== to[3]) { + return error$1.na; + } + + // Return converted number + return number * from[6] * from_multiplier / (to[6] * to_multiplier); +}; + +exports.DEC2BIN = function(number, places) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + + // Return error if number is not decimal, is lower than -512, or is greater than 511 + if (!/^-?[0-9]{1,3}$/.test(number) || number < -512 || number > 511) { + return error$1.num; + } + + // Ignore places and return a 10-character binary number if number is negative + if (number < 0) { + return '1' + text$1.REPT('0', 9 - (512 + number).toString(2).length) + (512 + number).toString(2); + } + + // Convert decimal number to binary + var result = parseInt(number, 10).toString(2); + + // Return binary number using the minimum number of characters necessary if places is undefined + if (typeof places === 'undefined') { + return result; + } else { + // Return error if places is nonnumeric + if (isNaN(places)) { + return error$1.value; + } + + // Return error if places is negative + if (places < 0) { + return error$1.num; + } + + // Truncate places in case it is not an integer + places = Math.floor(places); + + // Pad return value with leading 0s (zeros) if necessary (using Underscore.string) + return (places >= result.length) ? text$1.REPT('0', places - result.length) + result : error$1.num; + } +}; + +exports.DEC2HEX = function(number, places) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + + // Return error if number is not decimal, is lower than -549755813888, or is greater than 549755813887 + if (!/^-?[0-9]{1,12}$/.test(number) || number < -549755813888 || number > 549755813887) { + return error$1.num; + } + + // Ignore places and return a 10-character hexadecimal number if number is negative + if (number < 0) { + return (1099511627776 + number).toString(16); + } + + // Convert decimal number to hexadecimal + var result = parseInt(number, 10).toString(16); + + // Return hexadecimal number using the minimum number of characters necessary if places is undefined + if (typeof places === 'undefined') { + return result; + } else { + // Return error if places is nonnumeric + if (isNaN(places)) { + return error$1.value; + } + + // Return error if places is negative + if (places < 0) { + return error$1.num; + } + + // Truncate places in case it is not an integer + places = Math.floor(places); + + // Pad return value with leading 0s (zeros) if necessary (using Underscore.string) + return (places >= result.length) ? text$1.REPT('0', places - result.length) + result : error$1.num; + } +}; + +exports.DEC2OCT = function(number, places) { + number = common.parseNumber(number); + if (number instanceof Error) { + return number; + } + + // Return error if number is not decimal, is lower than -549755813888, or is greater than 549755813887 + if (!/^-?[0-9]{1,9}$/.test(number) || number < -536870912 || number > 536870911) { + return error$1.num; + } + + // Ignore places and return a 10-character octal number if number is negative + if (number < 0) { + return (1073741824 + number).toString(8); + } + + // Convert decimal number to octal + var result = parseInt(number, 10).toString(8); + + // Return octal number using the minimum number of characters necessary if places is undefined + if (typeof places === 'undefined') { + return result; + } else { + // Return error if places is nonnumeric + if (isNaN(places)) { + return error$1.value; + } + + // Return error if places is negative + if (places < 0) { + return error$1.num; + } + + // Truncate places in case it is not an integer + places = Math.floor(places); + + // Pad return value with leading 0s (zeros) if necessary (using Underscore.string) + return (places >= result.length) ? text$1.REPT('0', places - result.length) + result : error$1.num; + } +}; + +exports.DELTA = function(number1, number2) { + // Set number2 to zero if undefined + number2 = (number2 === undefined) ? 0 : number2; + number1 = common.parseNumber(number1); + number2 = common.parseNumber(number2); + if (common.anyIsError(number1, number2)) { + return error$1.value; + } + + // Return delta + return (number1 === number2) ? 1 : 0; +}; + +// TODO: why is upper_bound not used ? The excel documentation has no examples with upper_bound +exports.ERF = function(lower_bound, upper_bound) { + // Set number2 to zero if undefined + upper_bound = (upper_bound === undefined) ? 0 : upper_bound; + + lower_bound = common.parseNumber(lower_bound); + upper_bound = common.parseNumber(upper_bound); + if (common.anyIsError(lower_bound, upper_bound)) { + return error$1.value; + } + + return jstat.erf(lower_bound); +}; + +// TODO +exports.ERF.PRECISE = function() { + throw new Error('ERF.PRECISE is not implemented'); +}; + +exports.ERFC = function(x) { + // Return error if x is not a number + if (isNaN(x)) { + return error$1.value; + } + + return jstat.erfc(x); +}; + +// TODO +exports.ERFC.PRECISE = function() { + throw new Error('ERFC.PRECISE is not implemented'); +}; + +exports.GESTEP = function(number, step) { + step = step || 0; + number = common.parseNumber(number); + if (common.anyIsError(step, number)) { + return number; + } + + // Return delta + return (number >= step) ? 1 : 0; +}; + +exports.HEX2BIN = function(number, places) { + // Return error if number is not hexadecimal or contains more than ten characters (10 digits) + if (!/^[0-9A-Fa-f]{1,10}$/.test(number)) { + return error$1.num; + } + + // Check if number is negative + var negative = (number.length === 10 && number.substring(0, 1).toLowerCase() === 'f') ? true : false; + + // Convert hexadecimal number to decimal + var decimal = (negative) ? parseInt(number, 16) - 1099511627776 : parseInt(number, 16); + + // Return error if number is lower than -512 or greater than 511 + if (decimal < -512 || decimal > 511) { + return error$1.num; + } + + // Ignore places and return a 10-character binary number if number is negative + if (negative) { + return '1' + text$1.REPT('0', 9 - (512 + decimal).toString(2).length) + (512 + decimal).toString(2); + } + + // Convert decimal number to binary + var result = decimal.toString(2); + + // Return binary number using the minimum number of characters necessary if places is undefined + if (places === undefined) { + return result; + } else { + // Return error if places is nonnumeric + if (isNaN(places)) { + return error$1.value; + } + + // Return error if places is negative + if (places < 0) { + return error$1.num; + } + + // Truncate places in case it is not an integer + places = Math.floor(places); + + // Pad return value with leading 0s (zeros) if necessary (using Underscore.string) + return (places >= result.length) ? text$1.REPT('0', places - result.length) + result : error$1.num; + } +}; + +exports.HEX2DEC = function(number) { + // Return error if number is not hexadecimal or contains more than ten characters (10 digits) + if (!/^[0-9A-Fa-f]{1,10}$/.test(number)) { + return error$1.num; + } + + // Convert hexadecimal number to decimal + var decimal = parseInt(number, 16); + + // Return decimal number + return (decimal >= 549755813888) ? decimal - 1099511627776 : decimal; +}; + +exports.HEX2OCT = function(number, places) { + // Return error if number is not hexadecimal or contains more than ten characters (10 digits) + if (!/^[0-9A-Fa-f]{1,10}$/.test(number)) { + return error$1.num; + } + + // Convert hexadecimal number to decimal + var decimal = parseInt(number, 16); + + // Return error if number is positive and greater than 0x1fffffff (536870911) + if (decimal > 536870911 && decimal < 1098974756864) { + return error$1.num; + } + + // Ignore places and return a 10-character octal number if number is negative + if (decimal >= 1098974756864) { + return (decimal - 1098437885952).toString(8); + } + + // Convert decimal number to octal + var result = decimal.toString(8); + + // Return octal number using the minimum number of characters necessary if places is undefined + if (places === undefined) { + return result; + } else { + // Return error if places is nonnumeric + if (isNaN(places)) { + return error$1.value; + } + + // Return error if places is negative + if (places < 0) { + return error$1.num; + } + + // Truncate places in case it is not an integer + places = Math.floor(places); + + // Pad return value with leading 0s (zeros) if necessary (using Underscore.string) + return (places >= result.length) ? text$1.REPT('0', places - result.length) + result : error$1.num; + } +}; + +exports.IMABS = function(inumber) { + // Lookup real and imaginary coefficients using exports.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + // Return error if either coefficient is not a number + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Return absolute value of complex number + return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)); +}; + +exports.IMAGINARY = function(inumber) { + if (inumber === undefined || inumber === true || inumber === false) { + return error$1.value; + } + + // Return 0 if inumber is equal to 0 + if (inumber === 0 || inumber === '0') { + return 0; + } + + // Handle special cases + if (['i', 'j'].indexOf(inumber) >= 0) { + return 1; + } + + // Normalize imaginary coefficient + inumber = inumber.replace('+i', '+1i').replace('-i', '-1i').replace('+j', '+1j').replace('-j', '-1j'); + + // Lookup sign + var plus = inumber.indexOf('+'); + var minus = inumber.indexOf('-'); + if (plus === 0) { + plus = inumber.indexOf('+', 1); + } + + if (minus === 0) { + minus = inumber.indexOf('-', 1); + } + + // Lookup imaginary unit + var last = inumber.substring(inumber.length - 1, inumber.length); + var unit = (last === 'i' || last === 'j'); + + if (plus >= 0 || minus >= 0) { + // Return error if imaginary unit is neither i nor j + if (!unit) { + return error$1.num; + } + + // Return imaginary coefficient of complex number + if (plus >= 0) { + return (isNaN(inumber.substring(0, plus)) || isNaN(inumber.substring(plus + 1, inumber.length - 1))) ? + error$1.num : + Number(inumber.substring(plus + 1, inumber.length - 1)); + } else { + return (isNaN(inumber.substring(0, minus)) || isNaN(inumber.substring(minus + 1, inumber.length - 1))) ? + error$1.num : + -Number(inumber.substring(minus + 1, inumber.length - 1)); + } + } else { + if (unit) { + return (isNaN(inumber.substring(0, inumber.length - 1))) ? error$1.num : inumber.substring(0, inumber.length - 1); + } else { + return (isNaN(inumber)) ? error$1.num : 0; + } + } +}; + +exports.IMARGUMENT = function(inumber) { + // Lookup real and imaginary coefficients using exports.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + // Return error if either coefficient is not a number + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Return error if inumber is equal to zero + if (x === 0 && y === 0) { + return error$1.div0; + } + + // Return PI/2 if x is equal to zero and y is positive + if (x === 0 && y > 0) { + return Math.PI / 2; + } + + // Return -PI/2 if x is equal to zero and y is negative + if (x === 0 && y < 0) { + return -Math.PI / 2; + } + + // Return zero if x is negative and y is equal to zero + if (y === 0 && x > 0) { + return 0; + } + + // Return zero if x is negative and y is equal to zero + if (y === 0 && x < 0) { + return -Math.PI; + } + + // Return argument of complex number + if (x > 0) { + return Math.atan(y / x); + } else if (x < 0 && y >= 0) { + return Math.atan(y / x) + Math.PI; + } else { + return Math.atan(y / x) - Math.PI; + } +}; + +exports.IMCONJUGATE = function(inumber) { + // Lookup real and imaginary coefficients using exports.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Return conjugate of complex number + return (y !== 0) ? exports.COMPLEX(x, -y, unit) : inumber; +}; + +exports.IMCOS = function(inumber) { + // Lookup real and imaginary coefficients using exports.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Return cosine of complex number + return exports.COMPLEX(Math.cos(x) * (Math.exp(y) + Math.exp(-y)) / 2, -Math.sin(x) * (Math.exp(y) - Math.exp(-y)) / 2, unit); +}; + +exports.IMCOSH = function(inumber) { + // Lookup real and imaginary coefficients using exports.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Return hyperbolic cosine of complex number + return exports.COMPLEX(Math.cos(y) * (Math.exp(x) + Math.exp(-x)) / 2, Math.sin(y) * (Math.exp(x) - Math.exp(-x)) / 2, unit); +}; + +exports.IMCOT = function(inumber) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Return cotangent of complex number + return exports.IMDIV(exports.IMCOS(inumber), exports.IMSIN(inumber)); +}; + +exports.IMDIV = function(inumber1, inumber2) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var a = exports.IMREAL(inumber1); + var b = exports.IMAGINARY(inumber1); + var c = exports.IMREAL(inumber2); + var d = exports.IMAGINARY(inumber2); + + if (common.anyIsError(a, b, c, d)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit1 = inumber1.substring(inumber1.length - 1); + var unit2 = inumber2.substring(inumber2.length - 1); + var unit = 'i'; + if (unit1 === 'j') { + unit = 'j'; + } else if (unit2 === 'j') { + unit = 'j'; + } + + // Return error if inumber2 is null + if (c === 0 && d === 0) { + return error$1.num; + } + + // Return exponential of complex number + var den = c * c + d * d; + return exports.COMPLEX((a * c + b * d) / den, (b * c - a * d) / den, unit); +}; + +exports.IMEXP = function(inumber) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Return exponential of complex number + var e = Math.exp(x); + return exports.COMPLEX(e * Math.cos(y), e * Math.sin(y), unit); +}; + +exports.IMLN = function(inumber) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Return exponential of complex number + return exports.COMPLEX(Math.log(Math.sqrt(x * x + y * y)), Math.atan(y / x), unit); +}; + +exports.IMLOG10 = function(inumber) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Return exponential of complex number + return exports.COMPLEX(Math.log(Math.sqrt(x * x + y * y)) / Math.log(10), Math.atan(y / x) / Math.log(10), unit); +}; + +exports.IMLOG2 = function(inumber) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Return exponential of complex number + return exports.COMPLEX(Math.log(Math.sqrt(x * x + y * y)) / Math.log(2), Math.atan(y / x) / Math.log(2), unit); +}; + +exports.IMPOWER = function(inumber, number) { + number = common.parseNumber(number); + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + if (common.anyIsError(number, x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Calculate power of modulus + var p = Math.pow(exports.IMABS(inumber), number); + + // Calculate argument + var t = exports.IMARGUMENT(inumber); + + // Return exponential of complex number + return exports.COMPLEX(p * Math.cos(number * t), p * Math.sin(number * t), unit); +}; + +exports.IMPRODUCT = function() { + // Initialize result + var result = arguments[0]; + + if (!arguments.length) { + return error$1.value; + } + + // Loop on all numbers + for (var i = 1; i < arguments.length; i++) { + // Lookup coefficients of two complex numbers + var a = exports.IMREAL(result); + var b = exports.IMAGINARY(result); + var c = exports.IMREAL(arguments[i]); + var d = exports.IMAGINARY(arguments[i]); + + if (common.anyIsError(a, b, c, d)) { + return error$1.value; + } + + // Complute product of two complex numbers + result = exports.COMPLEX(a * c - b * d, a * d + b * c); + } + + // Return product of complex numbers + return result; +}; + +exports.IMREAL = function(inumber) { + if (inumber === undefined || inumber === true || inumber === false) { + return error$1.value; + } + + // Return 0 if inumber is equal to 0 + if (inumber === 0 || inumber === '0') { + return 0; + } + + // Handle special cases + if (['i', '+i', '1i', '+1i', '-i', '-1i', 'j', '+j', '1j', '+1j', '-j', '-1j'].indexOf(inumber) >= 0) { + return 0; + } + + // Lookup sign + var plus = inumber.indexOf('+'); + var minus = inumber.indexOf('-'); + if (plus === 0) { + plus = inumber.indexOf('+', 1); + } + if (minus === 0) { + minus = inumber.indexOf('-', 1); + } + + // Lookup imaginary unit + var last = inumber.substring(inumber.length - 1, inumber.length); + var unit = (last === 'i' || last === 'j'); + + if (plus >= 0 || minus >= 0) { + // Return error if imaginary unit is neither i nor j + if (!unit) { + return error$1.num; + } + + // Return real coefficient of complex number + if (plus >= 0) { + return (isNaN(inumber.substring(0, plus)) || isNaN(inumber.substring(plus + 1, inumber.length - 1))) ? + error$1.num : + Number(inumber.substring(0, plus)); + } else { + return (isNaN(inumber.substring(0, minus)) || isNaN(inumber.substring(minus + 1, inumber.length - 1))) ? + error$1.num : + Number(inumber.substring(0, minus)); + } + } else { + if (unit) { + return (isNaN(inumber.substring(0, inumber.length - 1))) ? error$1.num : 0; + } else { + return (isNaN(inumber)) ? error$1.num : inumber; + } + } +}; + +exports.IMSEC = function(inumber) { + // Return error if inumber is a logical value + if (inumber === true || inumber === false) { + return error$1.value; + } + + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Return secant of complex number + return exports.IMDIV('1', exports.IMCOS(inumber)); +}; + +exports.IMSECH = function(inumber) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Return hyperbolic secant of complex number + return exports.IMDIV('1', exports.IMCOSH(inumber)); +}; + +exports.IMSIN = function(inumber) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Return sine of complex number + return exports.COMPLEX(Math.sin(x) * (Math.exp(y) + Math.exp(-y)) / 2, Math.cos(x) * (Math.exp(y) - Math.exp(-y)) / 2, unit); +}; + +exports.IMSINH = function(inumber) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Return hyperbolic sine of complex number + return exports.COMPLEX(Math.cos(y) * (Math.exp(x) - Math.exp(-x)) / 2, Math.sin(y) * (Math.exp(x) + Math.exp(-x)) / 2, unit); +}; + +exports.IMSQRT = function(inumber) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit = inumber.substring(inumber.length - 1); + unit = (unit === 'i' || unit === 'j') ? unit : 'i'; + + // Calculate power of modulus + var s = Math.sqrt(exports.IMABS(inumber)); + + // Calculate argument + var t = exports.IMARGUMENT(inumber); + + // Return exponential of complex number + return exports.COMPLEX(s * Math.cos(t / 2), s * Math.sin(t / 2), unit); +}; + +exports.IMCSC = function (inumber) { + // Return error if inumber is a logical value + if (inumber === true || inumber === false) { + return error$1.value; + } + + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + // Return error if either coefficient is not a number + if (common.anyIsError(x, y)) { + return error$1.num; + } + + // Return cosecant of complex number + return exports.IMDIV('1', exports.IMSIN(inumber)); +}; + +exports.IMCSCH = function (inumber) { + // Return error if inumber is a logical value + if (inumber === true || inumber === false) { + return error$1.value; + } + + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + // Return error if either coefficient is not a number + if (common.anyIsError(x, y)) { + return error$1.num; + } + + // Return hyperbolic cosecant of complex number + return exports.IMDIV('1', exports.IMSINH(inumber)); +}; + +exports.IMSUB = function(inumber1, inumber2) { + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var a = this.IMREAL(inumber1); + var b = this.IMAGINARY(inumber1); + var c = this.IMREAL(inumber2); + var d = this.IMAGINARY(inumber2); + + if (common.anyIsError(a, b, c, d)) { + return error$1.value; + } + + // Lookup imaginary unit + var unit1 = inumber1.substring(inumber1.length - 1); + var unit2 = inumber2.substring(inumber2.length - 1); + var unit = 'i'; + if (unit1 === 'j') { + unit = 'j'; + } else if (unit2 === 'j') { + unit = 'j'; + } + + // Return _ of two complex numbers + return this.COMPLEX(a - c, b - d, unit); +}; + +exports.IMSUM = function() { + if (!arguments.length) { + return error$1.value; + } + var args = common.flatten(arguments); + + // Initialize result + var result = args[0]; + + // Loop on all numbers + for (var i = 1; i < args.length; i++) { + // Lookup coefficients of two complex numbers + var a = this.IMREAL(result); + var b = this.IMAGINARY(result); + var c = this.IMREAL(args[i]); + var d = this.IMAGINARY(args[i]); + + if (common.anyIsError(a, b, c, d)) { + return error$1.value; + } + + // Complute product of two complex numbers + result = this.COMPLEX(a + c, b + d); + } + + // Return sum of complex numbers + return result; +}; + +exports.IMTAN = function(inumber) { + // Return error if inumber is a logical value + if (inumber === true || inumber === false) { + return error$1.value; + } + + // Lookup real and imaginary coefficients using Formula.js [http://formulajs.org] + var x = exports.IMREAL(inumber); + var y = exports.IMAGINARY(inumber); + + if (common.anyIsError(x, y)) { + return error$1.value; + } + + // Return tangent of complex number + return this.IMDIV(this.IMSIN(inumber), this.IMCOS(inumber)); +}; + +exports.OCT2BIN = function(number, places) { + // Return error if number is not hexadecimal or contains more than ten characters (10 digits) + if (!/^[0-7]{1,10}$/.test(number)) { + return error$1.num; + } + + // Check if number is negative + var negative = (number.length === 10 && number.substring(0, 1) === '7') ? true : false; + + // Convert octal number to decimal + var decimal = (negative) ? parseInt(number, 8) - 1073741824 : parseInt(number, 8); + + // Return error if number is lower than -512 or greater than 511 + if (decimal < -512 || decimal > 511) { + return error$1.num; + } + + // Ignore places and return a 10-character binary number if number is negative + if (negative) { + return '1' + text$1.REPT('0', 9 - (512 + decimal).toString(2).length) + (512 + decimal).toString(2); + } + + // Convert decimal number to binary + var result = decimal.toString(2); + + // Return binary number using the minimum number of characters necessary if places is undefined + if (typeof places === 'undefined') { + return result; + } else { + // Return error if places is nonnumeric + if (isNaN(places)) { + return error$1.value; + } + + // Return error if places is negative + if (places < 0) { + return error$1.num; + } + + // Truncate places in case it is not an integer + places = Math.floor(places); + + // Pad return value with leading 0s (zeros) if necessary (using Underscore.string) + return (places >= result.length) ? text$1.REPT('0', places - result.length) + result : error$1.num; + } +}; + +exports.OCT2DEC = function(number) { + // Return error if number is not octal or contains more than ten characters (10 digits) + if (!/^[0-7]{1,10}$/.test(number)) { + return error$1.num; + } + + // Convert octal number to decimal + var decimal = parseInt(number, 8); + + // Return decimal number + return (decimal >= 536870912) ? decimal - 1073741824 : decimal; +}; + +exports.OCT2HEX = function(number, places) { + // Return error if number is not octal or contains more than ten characters (10 digits) + if (!/^[0-7]{1,10}$/.test(number)) { + return error$1.num; + } + + // Convert octal number to decimal + var decimal = parseInt(number, 8); + + // Ignore places and return a 10-character octal number if number is negative + if (decimal >= 536870912) { + return 'ff' + (decimal + 3221225472).toString(16); + } + + // Convert decimal number to hexadecimal + var result = decimal.toString(16); + + // Return hexadecimal number using the minimum number of characters necessary if places is undefined + if (places === undefined) { + return result; + } else { + // Return error if places is nonnumeric + if (isNaN(places)) { + return error$1.value; + } + + // Return error if places is negative + if (places < 0) { + return error$1.num; + } + + // Truncate places in case it is not an integer + places = Math.floor(places); + + // Pad return value with leading 0s (zeros) if necessary (using Underscore.string) + return (places >= result.length) ? text$1.REPT('0', places - result.length) + result : error$1.num; + } +}; +}); + +var dateTime = createCommonjsModule(function (module, exports) { +var d1900 = new Date(Date.UTC(1900, 0, 1)); +var WEEK_STARTS = [ + undefined, + 0, + 1, + undefined, + undefined, + undefined, + undefined, + undefined, + undefined, + undefined, + undefined, + undefined, + 1, + 2, + 3, + 4, + 5, + 6, + 0 +]; +var WEEK_TYPES = [ + [], + [1, 2, 3, 4, 5, 6, 7], + [7, 1, 2, 3, 4, 5, 6], + [6, 0, 1, 2, 3, 4, 5], + [], + [], + [], + [], + [], + [], + [], + [7, 1, 2, 3, 4, 5, 6], + [6, 7, 1, 2, 3, 4, 5], + [5, 6, 7, 1, 2, 3, 4], + [4, 5, 6, 7, 1, 2, 3], + [3, 4, 5, 6, 7, 1, 2], + [2, 3, 4, 5, 6, 7, 1], + [1, 2, 3, 4, 5, 6, 7] +]; +var WEEKEND_TYPES = [ + [], + [6, 0], + [0, 1], + [1, 2], + [2, 3], + [3, 4], + [4, 5], + [5, 6], + undefined, + undefined, + undefined, [0, 0], + [1, 1], + [2, 2], + [3, 3], + [4, 4], + [5, 5], + [6, 6] +]; + +exports.DATE = function(year, month, day) { + var result; + + year = common.parseNumber(year); + month = common.parseNumber(month); + day = common.parseNumber(day); + + if (common.anyIsError(year, month, day)) { + result = error$1.value; + + } else if (year < 0 || month < 0 || day < 0) { + result = error$1.num; + + } else { + result = new Date(year, month - 1, day); + } + + return result; +}; + +exports.DATEVALUE = function(date_text) { + var modifier = 2; + var date; + + if (typeof date_text !== 'string') { + return error$1.value; + } + + date = Date.parse(date_text); + + if (isNaN(date)) { + return error$1.value; + } + + if (date <= -2203891200000) { + modifier = 1; + } + + return Math.ceil((date - d1900) / 86400000) + modifier; +}; + +exports.DAY = function(serial_number) { + var date = common.parseDate(serial_number); + if (date instanceof Error) { + return date; + } + + return date.getDate(); +}; + +exports.DAYS = function(end_date, start_date) { + end_date = common.parseDate(end_date); + start_date = common.parseDate(start_date); + + if (end_date instanceof Error) { + return end_date; + } + if (start_date instanceof Error) { + return start_date; + } + + return serial(end_date) - serial(start_date); +}; + +exports.DAYS360 = function(start_date, end_date, method) { + method = common.parseBool(method); + start_date = common.parseDate(start_date); + end_date = common.parseDate(end_date); + + if (start_date instanceof Error) { + return start_date; + } + if (end_date instanceof Error) { + return end_date; + } + if (method instanceof Error) { + return method; + } + var sm = start_date.getMonth(); + var em = end_date.getMonth(); + var sd, ed; + + if (method) { + sd = start_date.getDate() === 31 ? 30 : start_date.getDate(); + ed = end_date.getDate() === 31 ? 30 : end_date.getDate(); + } else { + var smd = new Date(start_date.getFullYear(), sm + 1, 0).getDate(); + var emd = new Date(end_date.getFullYear(), em + 1, 0).getDate(); + sd = start_date.getDate() === smd ? 30 : start_date.getDate(); + if (end_date.getDate() === emd) { + if (sd < 30) { + em++; + ed = 1; + } else { + ed = 30; + } + } else { + ed = end_date.getDate(); + } + } + + return 360 * (end_date.getFullYear() - start_date.getFullYear()) + + 30 * (em - sm) + (ed - sd); +}; + +exports.EDATE = function(start_date, months) { + start_date = common.parseDate(start_date); + + if (start_date instanceof Error) { + return start_date; + } + if (isNaN(months)) { + return error$1.value; + } + months = parseInt(months, 10); + start_date.setMonth(start_date.getMonth() + months); + + return serial(start_date); +}; + +exports.EOMONTH = function(start_date, months) { + start_date = common.parseDate(start_date); + + if (start_date instanceof Error) { + return start_date; + } + if (isNaN(months)) { + return error$1.value; + } + months = parseInt(months, 10); + + return serial(new Date(start_date.getFullYear(), start_date.getMonth() + months + 1, 0)); +}; + +exports.HOUR = function(serial_number) { + serial_number = common.parseDate(serial_number); + + if (serial_number instanceof Error) { + return serial_number; + } + + return serial_number.getHours(); +}; + +exports.INTERVAL = function (second) { + if (typeof second !== 'number' && typeof second !== 'string') { + return error$1.value; + } else { + second = parseInt(second, 10); + } + + var year = Math.floor(second/946080000); + second = second%946080000; + var month = Math.floor(second/2592000); + second = second%2592000; + var day = Math.floor(second/86400); + second = second%86400; + + var hour = Math.floor(second/3600); + second = second%3600; + var min = Math.floor(second/60); + second = second%60; + var sec = second; + + year = (year > 0) ? year + 'Y' : ''; + month = (month > 0) ? month + 'M' : ''; + day = (day > 0) ? day + 'D' : ''; + hour = (hour > 0) ? hour + 'H' : ''; + min = (min > 0) ? min + 'M' : ''; + sec = (sec > 0) ? sec + 'S' : ''; + + return 'P' + year + month + day + 'T' + hour + min + sec; +}; + +exports.ISOWEEKNUM = function(date) { + date = common.parseDate(date); + + if (date instanceof Error) { + return date; + } + + date.setHours(0, 0, 0); + date.setDate(date.getDate() + 4 - (date.getDay() || 7)); + var yearStart = new Date(date.getFullYear(), 0, 1); + + return Math.ceil((((date - yearStart) / 86400000) + 1) / 7); +}; + +exports.MINUTE = function(serial_number) { + serial_number = common.parseDate(serial_number); + + if (serial_number instanceof Error) { + return serial_number; + } + + return serial_number.getMinutes(); +}; + +exports.MONTH = function(serial_number) { + serial_number = common.parseDate(serial_number); + + if (serial_number instanceof Error) { + return serial_number; + } + + return serial_number.getMonth() + 1; +}; + +exports.NETWORKDAYS = function(start_date, end_date, holidays) { + return this.NETWORKDAYS.INTL(start_date, end_date, 1, holidays); +}; + +exports.NETWORKDAYS.INTL = function(start_date, end_date, weekend, holidays) { + start_date = common.parseDate(start_date); + + if (start_date instanceof Error) { + return start_date; + } + end_date = common.parseDate(end_date); + + if (end_date instanceof Error) { + return end_date; + } + if (weekend === undefined) { + weekend = WEEKEND_TYPES[1]; + } else { + weekend = WEEKEND_TYPES[weekend]; + } + if (!(weekend instanceof Array)) { + return error$1.value; + } + if (holidays === undefined) { + holidays = []; + } else if (!(holidays instanceof Array)) { + holidays = [holidays]; + } + + for (var i = 0; i < holidays.length; i++) { + var h = common.parseDate(holidays[i]); + if (h instanceof Error) { + return h; + } + holidays[i] = h; + } + var days = (end_date - start_date) / (1000 * 60 * 60 * 24) + 1; + var total = days; + var day = start_date; + for (i = 0; i < days; i++) { + var d = (new Date().getTimezoneOffset() > 0) ? day.getUTCDay() : day.getDay(); + var dec = false; + if (d === weekend[0] || d === weekend[1]) { + dec = true; + } + for (var j = 0; j < holidays.length; j++) { + var holiday = holidays[j]; + if (holiday.getDate() === day.getDate() && + holiday.getMonth() === day.getMonth() && + holiday.getFullYear() === day.getFullYear()) { + dec = true; + break; + } + } + if (dec) { + total--; + } + day.setDate(day.getDate() + 1); + } + + return total; +}; + +exports.NOW = function() { + return new Date(); +}; + +exports.SECOND = function(serial_number) { + serial_number = common.parseDate(serial_number); + if (serial_number instanceof Error) { + return serial_number; + } + + return serial_number.getSeconds(); +}; + +exports.TIME = function(hour, minute, second) { + hour = common.parseNumber(hour); + minute = common.parseNumber(minute); + second = common.parseNumber(second); + if (common.anyIsError(hour, minute, second)) { + return error$1.value; + } + if (hour < 0 || minute < 0 || second < 0) { + return error$1.num; + } + + return (3600 * hour + 60 * minute + second) / 86400; +}; + +exports.TIMEVALUE = function(time_text) { + time_text = common.parseDate(time_text); + + if (time_text instanceof Error) { + return time_text; + } + + return (3600 * time_text.getHours() + 60 * time_text.getMinutes() + time_text.getSeconds()) / 86400; +}; + +exports.TODAY = function() { + return new Date(); +}; + +exports.WEEKDAY = function(serial_number, return_type) { + serial_number = common.parseDate(serial_number); + if (serial_number instanceof Error) { + return serial_number; + } + if (return_type === undefined) { + return_type = 1; + } + var day = serial_number.getDay(); + + return WEEK_TYPES[return_type][day]; +}; + +exports.WEEKNUM = function(serial_number, return_type) { + serial_number = common.parseDate(serial_number); + if (serial_number instanceof Error) { + return serial_number; + } + if (return_type === undefined) { + return_type = 1; + } + if (return_type === 21) { + return this.ISOWEEKNUM(serial_number); + } + var week_start = WEEK_STARTS[return_type]; + var jan = new Date(serial_number.getFullYear(), 0, 1); + var inc = jan.getDay() < week_start ? 1 : 0; + jan -= Math.abs(jan.getDay() - week_start) * 24 * 60 * 60 * 1000; + + return Math.floor(((serial_number - jan) / (1000 * 60 * 60 * 24)) / 7 + 1) + inc; +}; + +exports.WORKDAY = function(start_date, days, holidays) { + return this.WORKDAY.INTL(start_date, days, 1, holidays); +}; + +exports.WORKDAY.INTL = function(start_date, days, weekend, holidays) { + start_date = common.parseDate(start_date); + if (start_date instanceof Error) { + return start_date; + } + days = common.parseNumber(days); + if (days instanceof Error) { + return days; + } + if (days < 0) { + return error$1.num; + } + if (weekend === undefined) { + weekend = WEEKEND_TYPES[1]; + } else { + weekend = WEEKEND_TYPES[weekend]; + } + if (!(weekend instanceof Array)) { + return error$1.value; + } + if (holidays === undefined) { + holidays = []; + } else if (!(holidays instanceof Array)) { + holidays = [holidays]; + } + for (var i = 0; i < holidays.length; i++) { + var h = common.parseDate(holidays[i]); + if (h instanceof Error) { + return h; + } + holidays[i] = h; + } + var d = 0; + while (d < days) { + start_date.setDate(start_date.getDate() + 1); + var day = start_date.getDay(); + if (day === weekend[0] || day === weekend[1]) { + continue; + } + for (var j = 0; j < holidays.length; j++) { + var holiday = holidays[j]; + if (holiday.getDate() === start_date.getDate() && + holiday.getMonth() === start_date.getMonth() && + holiday.getFullYear() === start_date.getFullYear()) { + d--; + break; + } + } + d++; + } + + return start_date; +}; + +exports.YEAR = function(serial_number) { + serial_number = common.parseDate(serial_number); + + if (serial_number instanceof Error) { + return serial_number; + } + + return serial_number.getFullYear(); +}; + +function isLeapYear(year) { + return new Date(year, 1, 29).getMonth() === 1; +} + +// TODO : Use DAYS ? +function daysBetween(start_date, end_date) { + return Math.ceil((end_date - start_date) / 1000 / 60 / 60 / 24); +} + +exports.YEARFRAC = function(start_date, end_date, basis) { + start_date = common.parseDate(start_date); + if (start_date instanceof Error) { + return start_date; + } + end_date = common.parseDate(end_date); + if (end_date instanceof Error) { + return end_date; + } + + basis = basis || 0; + var sd = start_date.getDate(); + var sm = start_date.getMonth() + 1; + var sy = start_date.getFullYear(); + var ed = end_date.getDate(); + var em = end_date.getMonth() + 1; + var ey = end_date.getFullYear(); + + switch (basis) { + case 0: + // US (NASD) 30/360 + if (sd === 31 && ed === 31) { + sd = 30; + ed = 30; + } else if (sd === 31) { + sd = 30; + } else if (sd === 30 && ed === 31) { + ed = 30; + } + return ((ed + em * 30 + ey * 360) - (sd + sm * 30 + sy * 360)) / 360; + case 1: + // Actual/actual + var feb29Between = function(date1, date2) { + var year1 = date1.getFullYear(); + var mar1year1 = new Date(year1, 2, 1); + if (isLeapYear(year1) && date1 < mar1year1 && date2 >= mar1year1) { + return true; + } + var year2 = date2.getFullYear(); + var mar1year2 = new Date(year2, 2, 1); + return (isLeapYear(year2) && date2 >= mar1year2 && date1 < mar1year2); + }; + var ylength = 365; + if (sy === ey || ((sy + 1) === ey) && ((sm > em) || ((sm === em) && (sd >= ed)))) { + if ((sy === ey && isLeapYear(sy)) || + feb29Between(start_date, end_date) || + (em === 1 && ed === 29)) { + ylength = 366; + } + return daysBetween(start_date, end_date) / ylength; + } + var years = (ey - sy) + 1; + var days = (new Date(ey + 1, 0, 1) - new Date(sy, 0, 1)) / 1000 / 60 / 60 / 24; + var average = days / years; + return daysBetween(start_date, end_date) / average; + case 2: + // Actual/360 + return daysBetween(start_date, end_date) / 360; + case 3: + // Actual/365 + return daysBetween(start_date, end_date) / 365; + case 4: + // European 30/360 + return ((ed + em * 30 + ey * 360) - (sd + sm * 30 + sy * 360)) / 360; + } +}; + +function serial(date) { + var addOn = (date > -2203891200000) ? 2 : 1; + + return Math.ceil((date - d1900) / 86400000) + addOn; +} +}); + +var compatibility = createCommonjsModule(function (module, exports) { +function set(fn, root) { + if (root) { + for (var i in root) { + fn[i] = root[i]; + } + } + + return fn; +} + +exports.BETADIST = statistical.BETA.DIST; +exports.BETAINV = statistical.BETA.INV; +exports.BINOMDIST = statistical.BINOM.DIST; +exports.CEILING = exports.ISOCEILING = set(mathTrig.CEILING.MATH, mathTrig.CEILING); +exports.CEILINGMATH = mathTrig.CEILING.MATH; +exports.CEILINGPRECISE = mathTrig.CEILING.PRECISE; +exports.CHIDIST = statistical.CHISQ.DIST; +exports.CHIDISTRT = statistical.CHISQ.DIST.RT; +exports.CHIINV = statistical.CHISQ.INV; +exports.CHIINVRT = statistical.CHISQ.INV.RT; +exports.CHITEST = statistical.CHISQ.TEST; +exports.CONFIDENCE = set(statistical.CONFIDENCE.NORM, statistical.CONFIDENCE); +exports.COVAR = statistical.COVARIANCE.P; +exports.COVARIANCEP = statistical.COVARIANCE.P; +exports.COVARIANCES = statistical.COVARIANCE.S; +exports.CRITBINOM = statistical.BINOM.INV; +exports.EXPONDIST = statistical.EXPON.DIST; +exports.ERFCPRECISE = engineering.ERFC.PRECISE; +exports.ERFPRECISE = engineering.ERF.PRECISE; +exports.FDIST = statistical.F.DIST; +exports.FDISTRT = statistical.F.DIST.RT; +exports.FINVRT = statistical.F.INV.RT; +exports.FINV = statistical.F.INV; +exports.FLOOR = set(mathTrig.FLOOR.MATH, mathTrig.FLOOR); +exports.FLOORMATH = mathTrig.FLOOR.MATH; +exports.FLOORPRECISE = mathTrig.FLOOR.PRECISE; +exports.FTEST = statistical.F.TEST; +exports.GAMMADIST = statistical.GAMMA.DIST; +exports.GAMMAINV = statistical.GAMMA.INV; +exports.GAMMALNPRECISE = statistical.GAMMALN.PRECISE; +exports.HYPGEOMDIST = statistical.HYPGEOM.DIST; +exports.LOGINV = statistical.LOGNORM.INV; +exports.LOGNORMINV = statistical.LOGNORM.INV; +exports.LOGNORMDIST = statistical.LOGNORM.DIST; +exports.MODE = set(statistical.MODE.SNGL, statistical.MODE); +exports.MODEMULT = statistical.MODE.MULT; +exports.MODESNGL = statistical.MODE.SNGL; +exports.NEGBINOMDIST = statistical.NEGBINOM.DIST; +exports.NETWORKDAYSINTL = dateTime.NETWORKDAYS.INTL; +exports.NORMDIST = statistical.NORM.DIST; +exports.NORMINV = statistical.NORM.INV; +exports.NORMSDIST = statistical.NORM.S.DIST; +exports.NORMSINV = statistical.NORM.S.INV; +exports.PERCENTILE = set(statistical.PERCENTILE.EXC, statistical.PERCENTILE); +exports.PERCENTILEEXC = statistical.PERCENTILE.EXC; +exports.PERCENTILEINC = statistical.PERCENTILE.INC; +exports.PERCENTRANK = set(statistical.PERCENTRANK.INC, statistical.PERCENTRANK); +exports.PERCENTRANKEXC = statistical.PERCENTRANK.EXC; +exports.PERCENTRANKINC = statistical.PERCENTRANK.INC; +exports.POISSON = set(statistical.POISSON.DIST, statistical.POISSON); +exports.POISSONDIST = statistical.POISSON.DIST; +exports.QUARTILE = set(statistical.QUARTILE.INC, statistical.QUARTILE); +exports.QUARTILEEXC = statistical.QUARTILE.EXC; +exports.QUARTILEINC = statistical.QUARTILE.INC; +exports.RANK = set(statistical.RANK.EQ, statistical.RANK); +exports.RANKAVG = statistical.RANK.AVG; +exports.RANKEQ = statistical.RANK.EQ; +exports.SKEWP = statistical.SKEW.P; +exports.STDEV = set(statistical.STDEV.S, statistical.STDEV); +exports.STDEVP = statistical.STDEV.P; +exports.STDEVS = statistical.STDEV.S; +exports.TDIST = statistical.T.DIST; +exports.TDISTRT = statistical.T.DIST.RT; +exports.TINV = statistical.T.INV; +exports.TTEST = statistical.T.TEST; +exports.VAR = set(statistical.VAR.S, statistical.VAR); +exports.VARP = statistical.VAR.P; +exports.VARS = statistical.VAR.S; +exports.WEIBULL = set(statistical.WEIBULL.DIST, statistical.WEIBULL); +exports.WEIBULLDIST = statistical.WEIBULL.DIST; +exports.WORKDAYINTL = dateTime.WORKDAY.INTL; +exports.ZTEST = statistical.Z.TEST; +}); + +var database = createCommonjsModule(function (module, exports) { +function compact(array) { + var result = []; + + common.arrayEach(array, function(value) { + if (value) { + result.push(value); + } + }); + + return result; +} + +exports.FINDFIELD = function(database, title) { + var index = null; + + common.arrayEach(database, function(value, i) { + if (value[0] === title) { + index = i; + return false; + } + }); + + // Return error if the input field title is incorrect + if (index == null) { + return error$1.value; + } + + return index; +}; + +function findResultIndex(database, criterias) { + var matches = {}; + for (var i = 1; i < database[0].length; ++i) { + matches[i] = true; + } + var maxCriteriaLength = criterias[0].length; + for (i = 1; i < criterias.length; ++i) { + if (criterias[i].length > maxCriteriaLength) { + maxCriteriaLength = criterias[i].length; + } + } + + for (var k = 1; k < database.length; ++k) { + for (var l = 1; l < database[k].length; ++l) { + var currentCriteriaResult = false; + var hasMatchingCriteria = false; + for (var j = 0; j < criterias.length; ++j) { + var criteria = criterias[j]; + if (criteria.length < maxCriteriaLength) { + continue; + } + + var criteriaField = criteria[0]; + if (database[k][0] !== criteriaField) { + continue; + } + hasMatchingCriteria = true; + for (var p = 1; p < criteria.length; ++p) { + if (!currentCriteriaResult) { + var isWildcard = criteria[p] === void 0 || criteria[p] === '*'; + + if (isWildcard) { + currentCriteriaResult = true; + } else { + var tokenizedCriteria = criteriaEval.parse(criteria[p] + ''); + var tokens = [criteriaEval.createToken(database[k][l], criteriaEval.TOKEN_TYPE_LITERAL)].concat(tokenizedCriteria); + + currentCriteriaResult = criteriaEval.compute(tokens); + } + } + } + } + if (hasMatchingCriteria) { + matches[l] = matches[l] && currentCriteriaResult; + } + } + } + + var result = []; + for (var n = 0; n < database[0].length; ++n) { + if (matches[n]) { + result.push(n - 1); + } + } + + return result; +} + +// Database functions +exports.DAVERAGE = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + var sum = 0; + + common.arrayEach(resultIndexes, function(value) { + sum += targetFields[value]; + }); + + return resultIndexes.length === 0 ? error$1.div0 : sum / resultIndexes.length; +}; + +exports.DCOUNT = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + + var targetValues = []; + + common.arrayEach(resultIndexes, function(value) { + targetValues.push(targetFields[value]); + }); + + return statistical.COUNT(targetValues); +}; + +exports.DCOUNTA = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + + var targetValues = []; + + common.arrayEach(resultIndexes, function(value) { + targetValues.push(targetFields[value]); + }); + + return statistical.COUNTA(targetValues); +}; + +exports.DGET = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + + // Return error if no record meets the criteria + if (resultIndexes.length === 0) { + return error$1.value; + } + // Returns the #NUM! error value because more than one record meets the + // criteria + if (resultIndexes.length > 1) { + return error$1.num; + } + + return targetFields[resultIndexes[0]]; +}; + +exports.DMAX = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + + var maxValue = targetFields[resultIndexes[0]]; + + common.arrayEach(resultIndexes, function(value) { + if (maxValue < targetFields[value]) { + maxValue = targetFields[value]; + } + }); + + return maxValue; +}; + +exports.DMIN = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + + var minValue = targetFields[resultIndexes[0]]; + + common.arrayEach(resultIndexes, function(value) { + if (minValue > targetFields[value]) { + minValue = targetFields[value]; + } + }); + + return minValue; +}; + +exports.DPRODUCT = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + + var targetValues = []; + + common.arrayEach(resultIndexes, function(value) { + targetValues.push(targetFields[value]); + }); + targetValues = compact(targetValues); + + var result = 1; + + common.arrayEach(targetValues, function(value) { + result *= value; + }); + + return result; +}; + +exports.DSTDEV = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + var targetValues = []; + + common.arrayEach(resultIndexes, function(value) { + targetValues.push(targetFields[value]); + }); + targetValues = compact(targetValues); + + return statistical.STDEV.S(targetValues); +}; + +exports.DSTDEVP = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + + var targetValues = []; + + common.arrayEach(resultIndexes, function(value) { + targetValues.push(targetFields[value]); + }); + targetValues = compact(targetValues); + + return statistical.STDEV.P(targetValues); +}; + +exports.DSUM = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + + var targetValues = []; + + common.arrayEach(resultIndexes, function(value) { + targetValues.push(targetFields[value]); + }); + + return mathTrig.SUM(targetValues); +}; + +exports.DVAR = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + var targetValues = []; + + common.arrayEach(resultIndexes, function(value) { + targetValues.push(targetFields[value]); + }); + + return statistical.VAR.S(targetValues); +}; + +exports.DVARP = function(database, field, criteria) { + // Return error if field is not a number and not a string + if (isNaN(field) && (typeof field !== "string")) { + return error$1.value; + } + var resultIndexes = findResultIndex(database, criteria); + var targetFields = []; + + if (typeof field === "string") { + var index = exports.FINDFIELD(database, field); + targetFields = common.rest(database[index]); + } else { + targetFields = common.rest(database[field]); + } + var targetValues = []; + + common.arrayEach(resultIndexes, function(value) { + targetValues.push(targetFields[value]); + }); + + return statistical.VAR.P(targetValues); +}; +}); + +var AND = function() { + var args = common.flatten(arguments); + var result = true; + for (var i = 0; i < args.length; i++) { + if (!args[i]) { + result = false; + } + } + return result; +}; + +var CHOOSE = function() { + if (arguments.length < 2) { + return error$1.na; + } + + var index = arguments[0]; + if (index < 1 || index > 254) { + return error$1.value; + } + + if (arguments.length < index + 1) { + return error$1.value; + } + + return arguments[index]; +}; + +var FALSE = function() { + return false; +}; + +var IF = function(test, then_value, otherwise_value) { + return test ? then_value : otherwise_value; +}; + +var IFERROR = function(value, valueIfError) { + if (information.ISERROR(value)) { + return valueIfError; + } + return value; +}; + +var IFNA = function(value, value_if_na) { + return value === error$1.na ? value_if_na : value; +}; + +var NOT = function(logical) { + return !logical; +}; + +var OR = function() { + var args = common.flatten(arguments); + var result = false; + for (var i = 0; i < args.length; i++) { + if (args[i]) { + result = true; + } + } + return result; +}; + +var TRUE = function() { + return true; +}; + +var XOR = function() { + var args = common.flatten(arguments); + var result = 0; + for (var i = 0; i < args.length; i++) { + if (args[i]) { + result++; + } + } + return (Math.floor(Math.abs(result)) & 1) ? true : false; +}; + +var SWITCH = function () { + var result; + + if (arguments.length > 0) { + var targetValue = arguments[0]; + var argc = arguments.length - 1; + var switchCount = Math.floor(argc / 2); + var switchSatisfied = false; + var hasDefaultClause = argc % 2 !== 0; + var defaultClause = argc % 2 === 0 ? null : arguments[arguments.length - 1]; + + if (switchCount) { + for (var index = 0; index < switchCount; index++) { + if (targetValue === arguments[index * 2 + 1]) { + result = arguments[index * 2 + 2]; + switchSatisfied = true; + break; + } + } + } + + if (!switchSatisfied) { + result = hasDefaultClause ? defaultClause : error$1.na; + } + } else { + result = error$1.value; + } + + return result; +}; + +var logical = { + AND: AND, + CHOOSE: CHOOSE, + FALSE: FALSE, + IF: IF, + IFERROR: IFERROR, + IFNA: IFNA, + NOT: NOT, + OR: OR, + TRUE: TRUE, + XOR: XOR, + SWITCH: SWITCH +}; + +var financial = createCommonjsModule(function (module, exports) { +function validDate(d) { + return d && d.getTime && !isNaN(d.getTime()); +} + +function ensureDate(d) { + return (d instanceof Date)?d:new Date(d); +} + +exports.ACCRINT = function(issue, first, settlement, rate, par, frequency, basis) { + // Return error if either date is invalid + issue = ensureDate(issue); + first = ensureDate(first); + settlement = ensureDate(settlement); + if (!validDate(issue) || !validDate(first) || !validDate(settlement)) { + return error$1.value; + } + + // Return error if either rate or par are lower than or equal to zero + if (rate <= 0 || par <= 0) { + return error$1.num; + } + + // Return error if frequency is neither 1, 2, or 4 + if ([1, 2, 4].indexOf(frequency) === -1) { + return error$1.num; + } + + // Return error if basis is neither 0, 1, 2, 3, or 4 + if ([0, 1, 2, 3, 4].indexOf(basis) === -1) { + return error$1.num; + } + + // Return error if settlement is before or equal to issue + if (settlement <= issue) { + return error$1.num; + } + + // Set default values + par = par || 0; + basis = basis || 0; + + // Compute accrued interest + return par * rate * dateTime.YEARFRAC(issue, settlement, basis); +}; + +// TODO +exports.ACCRINTM = function() { + throw new Error('ACCRINTM is not implemented'); +}; + +// TODO +exports.AMORDEGRC = function() { + throw new Error('AMORDEGRC is not implemented'); +}; + +// TODO +exports.AMORLINC = function() { + throw new Error('AMORLINC is not implemented'); +}; + +// TODO +exports.COUPDAYBS = function() { + throw new Error('COUPDAYBS is not implemented'); +}; + +// TODO +exports.COUPDAYS = function() { + throw new Error('COUPDAYS is not implemented'); +}; + +// TODO +exports.COUPDAYSNC = function() { + throw new Error('COUPDAYSNC is not implemented'); +}; + +// TODO +exports.COUPNCD = function() { + throw new Error('COUPNCD is not implemented'); +}; + +// TODO +exports.COUPNUM = function() { + throw new Error('COUPNUM is not implemented'); +}; + +// TODO +exports.COUPPCD = function() { + throw new Error('COUPPCD is not implemented'); +}; + +exports.CUMIPMT = function(rate, periods, value, start, end, type) { + // Credits: algorithm inspired by Apache OpenOffice + // Credits: Hannes Stiebitzhofer for the translations of function and variable names + // Requires exports.FV() and exports.PMT() from exports.js [http://stoic.com/exports/] + + rate = common.parseNumber(rate); + periods = common.parseNumber(periods); + value = common.parseNumber(value); + if (common.anyIsError(rate, periods, value)) { + return error$1.value; + } + + // Return error if either rate, periods, or value are lower than or equal to zero + if (rate <= 0 || periods <= 0 || value <= 0) { + return error$1.num; + } + + // Return error if start < 1, end < 1, or start > end + if (start < 1 || end < 1 || start > end) { + return error$1.num; + } + + // Return error if type is neither 0 nor 1 + if (type !== 0 && type !== 1) { + return error$1.num; + } + + // Compute cumulative interest + var payment = exports.PMT(rate, periods, value, 0, type); + var interest = 0; + + if (start === 1) { + if (type === 0) { + interest = -value; + start++; + } + } + + for (var i = start; i <= end; i++) { + if (type === 1) { + interest += exports.FV(rate, i - 2, payment, value, 1) - payment; + } else { + interest += exports.FV(rate, i - 1, payment, value, 0); + } + } + interest *= rate; + + // Return cumulative interest + return interest; +}; + +exports.CUMPRINC = function(rate, periods, value, start, end, type) { + // Credits: algorithm inspired by Apache OpenOffice + // Credits: Hannes Stiebitzhofer for the translations of function and variable names + + rate = common.parseNumber(rate); + periods = common.parseNumber(periods); + value = common.parseNumber(value); + if (common.anyIsError(rate, periods, value)) { + return error$1.value; + } + + // Return error if either rate, periods, or value are lower than or equal to zero + if (rate <= 0 || periods <= 0 || value <= 0) { + return error$1.num; + } + + // Return error if start < 1, end < 1, or start > end + if (start < 1 || end < 1 || start > end) { + return error$1.num; + } + + // Return error if type is neither 0 nor 1 + if (type !== 0 && type !== 1) { + return error$1.num; + } + + // Compute cumulative principal + var payment = exports.PMT(rate, periods, value, 0, type); + var principal = 0; + if (start === 1) { + if (type === 0) { + principal = payment + value * rate; + } else { + principal = payment; + } + start++; + } + for (var i = start; i <= end; i++) { + if (type > 0) { + principal += payment - (exports.FV(rate, i - 2, payment, value, 1) - payment) * rate; + } else { + principal += payment - exports.FV(rate, i - 1, payment, value, 0) * rate; + } + } + + // Return cumulative principal + return principal; +}; + +exports.DB = function(cost, salvage, life, period, month) { + // Initialize month + month = (month === undefined) ? 12 : month; + + cost = common.parseNumber(cost); + salvage = common.parseNumber(salvage); + life = common.parseNumber(life); + period = common.parseNumber(period); + month = common.parseNumber(month); + if (common.anyIsError(cost, salvage, life, period, month)) { + return error$1.value; + } + + // Return error if any of the parameters is negative + if (cost < 0 || salvage < 0 || life < 0 || period < 0) { + return error$1.num; + } + + // Return error if month is not an integer between 1 and 12 + if ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].indexOf(month) === -1) { + return error$1.num; + } + + // Return error if period is greater than life + if (period > life) { + return error$1.num; + } + + // Return 0 (zero) if salvage is greater than or equal to cost + if (salvage >= cost) { + return 0; + } + + // Rate is rounded to three decimals places + var rate = (1 - Math.pow(salvage / cost, 1 / life)).toFixed(3); + + // Compute initial depreciation + var initial = cost * rate * month / 12; + + // Compute total depreciation + var total = initial; + var current = 0; + var ceiling = (period === life) ? life - 1 : period; + for (var i = 2; i <= ceiling; i++) { + current = (cost - total) * rate; + total += current; + } + + // Depreciation for the first and last periods are special cases + if (period === 1) { + // First period + return initial; + } else if (period === life) { + // Last period + return (cost - total) * rate; + } else { + return current; + } +}; + +exports.DDB = function(cost, salvage, life, period, factor) { + // Initialize factor + factor = (factor === undefined) ? 2 : factor; + + cost = common.parseNumber(cost); + salvage = common.parseNumber(salvage); + life = common.parseNumber(life); + period = common.parseNumber(period); + factor = common.parseNumber(factor); + if (common.anyIsError(cost, salvage, life, period, factor)) { + return error$1.value; + } + + // Return error if any of the parameters is negative or if factor is null + if (cost < 0 || salvage < 0 || life < 0 || period < 0 || factor <= 0) { + return error$1.num; + } + + // Return error if period is greater than life + if (period > life) { + return error$1.num; + } + + // Return 0 (zero) if salvage is greater than or equal to cost + if (salvage >= cost) { + return 0; + } + + // Compute depreciation + var total = 0; + var current = 0; + for (var i = 1; i <= period; i++) { + current = Math.min((cost - total) * (factor / life), (cost - salvage - total)); + total += current; + } + + // Return depreciation + return current; +}; + +// TODO +exports.DISC = function() { + throw new Error('DISC is not implemented'); +}; + +exports.DOLLARDE = function(dollar, fraction) { + // Credits: algorithm inspired by Apache OpenOffice + + dollar = common.parseNumber(dollar); + fraction = common.parseNumber(fraction); + if (common.anyIsError(dollar, fraction)) { + return error$1.value; + } + + // Return error if fraction is negative + if (fraction < 0) { + return error$1.num; + } + + // Return error if fraction is greater than or equal to 0 and less than 1 + if (fraction >= 0 && fraction < 1) { + return error$1.div0; + } + + // Truncate fraction if it is not an integer + fraction = parseInt(fraction, 10); + + // Compute integer part + var result = parseInt(dollar, 10); + + // Add decimal part + result += (dollar % 1) * Math.pow(10, Math.ceil(Math.log(fraction) / Math.LN10)) / fraction; + + // Round result + var power = Math.pow(10, Math.ceil(Math.log(fraction) / Math.LN2) + 1); + result = Math.round(result * power) / power; + + // Return converted dollar price + return result; +}; + +exports.DOLLARFR = function(dollar, fraction) { + // Credits: algorithm inspired by Apache OpenOffice + + dollar = common.parseNumber(dollar); + fraction = common.parseNumber(fraction); + if (common.anyIsError(dollar, fraction)) { + return error$1.value; + } + + // Return error if fraction is negative + if (fraction < 0) { + return error$1.num; + } + + // Return error if fraction is greater than or equal to 0 and less than 1 + if (fraction >= 0 && fraction < 1) { + return error$1.div0; + } + + // Truncate fraction if it is not an integer + fraction = parseInt(fraction, 10); + + // Compute integer part + var result = parseInt(dollar, 10); + + // Add decimal part + result += (dollar % 1) * Math.pow(10, -Math.ceil(Math.log(fraction) / Math.LN10)) * fraction; + + // Return converted dollar price + return result; +}; + +// TODO +exports.DURATION = function() { + throw new Error('DURATION is not implemented'); +}; + +exports.EFFECT = function(rate, periods) { + rate = common.parseNumber(rate); + periods = common.parseNumber(periods); + if (common.anyIsError(rate, periods)) { + return error$1.value; + } + + // Return error if rate <=0 or periods < 1 + if (rate <= 0 || periods < 1) { + return error$1.num; + } + + // Truncate periods if it is not an integer + periods = parseInt(periods, 10); + + // Return effective annual interest rate + return Math.pow(1 + rate / periods, periods) - 1; +}; + +exports.FV = function(rate, periods, payment, value, type) { + // Credits: algorithm inspired by Apache OpenOffice + + value = value || 0; + type = type || 0; + + rate = common.parseNumber(rate); + periods = common.parseNumber(periods); + payment = common.parseNumber(payment); + value = common.parseNumber(value); + type = common.parseNumber(type); + if (common.anyIsError(rate, periods, payment, value, type)) { + return error$1.value; + } + + // Return future value + var result; + if (rate === 0) { + result = value + payment * periods; + } else { + var term = Math.pow(1 + rate, periods); + if (type === 1) { + result = value * term + payment * (1 + rate) * (term - 1) / rate; + } else { + result = value * term + payment * (term - 1) / rate; + } + } + return -result; +}; + +exports.FVSCHEDULE = function(principal, schedule) { + principal = common.parseNumber(principal); + schedule = common.parseNumberArray(common.flatten(schedule)); + if (common.anyIsError(principal, schedule)) { + return error$1.value; + } + + var n = schedule.length; + var future = principal; + + // Apply all interests in schedule + for (var i = 0; i < n; i++) { + // Apply scheduled interest + future *= 1 + schedule[i]; + } + + // Return future value + return future; +}; + +// TODO +exports.INTRATE = function() { + throw new Error('INTRATE is not implemented'); +}; + +exports.IPMT = function(rate, period, periods, present, future, type) { + // Credits: algorithm inspired by Apache OpenOffice + + future = future || 0; + type = type || 0; + + rate = common.parseNumber(rate); + period = common.parseNumber(period); + periods = common.parseNumber(periods); + present = common.parseNumber(present); + future = common.parseNumber(future); + type = common.parseNumber(type); + if (common.anyIsError(rate, period, periods, present, future, type)) { + return error$1.value; + } + + // Compute payment + var payment = exports.PMT(rate, periods, present, future, type); + + // Compute interest + var interest; + if (period === 1) { + if (type === 1) { + interest = 0; + } else { + interest = -present; + } + } else { + if (type === 1) { + interest = exports.FV(rate, period - 2, payment, present, 1) - payment; + } else { + interest = exports.FV(rate, period - 1, payment, present, 0); + } + } + + // Return interest + return interest * rate; +}; + +exports.IRR = function(values, guess) { + // Credits: algorithm inspired by Apache OpenOffice + + guess = guess || 0; + + values = common.parseNumberArray(common.flatten(values)); + guess = common.parseNumber(guess); + if (common.anyIsError(values, guess)) { + return error$1.value; + } + + // Calculates the resulting amount + var irrResult = function(values, dates, rate) { + var r = rate + 1; + var result = values[0]; + for (var i = 1; i < values.length; i++) { + result += values[i] / Math.pow(r, (dates[i] - dates[0]) / 365); + } + return result; + }; + + // Calculates the first derivation + var irrResultDeriv = function(values, dates, rate) { + var r = rate + 1; + var result = 0; + for (var i = 1; i < values.length; i++) { + var frac = (dates[i] - dates[0]) / 365; + result -= frac * values[i] / Math.pow(r, frac + 1); + } + return result; + }; + + // Initialize dates and check that values contains at least one positive value and one negative value + var dates = []; + var positive = false; + var negative = false; + for (var i = 0; i < values.length; i++) { + dates[i] = (i === 0) ? 0 : dates[i - 1] + 365; + if (values[i] > 0) { + positive = true; + } + if (values[i] < 0) { + negative = true; + } + } + + // Return error if values does not contain at least one positive value and one negative value + if (!positive || !negative) { + return error$1.num; + } + + // Initialize guess and resultRate + guess = (guess === undefined) ? 0.1 : guess; + var resultRate = guess; + + // Set maximum epsilon for end of iteration + var epsMax = 1e-10; + + // Implement Newton's method + var newRate, epsRate, resultValue; + var contLoop = true; + do { + resultValue = irrResult(values, dates, resultRate); + newRate = resultRate - resultValue / irrResultDeriv(values, dates, resultRate); + epsRate = Math.abs(newRate - resultRate); + resultRate = newRate; + contLoop = (epsRate > epsMax) && (Math.abs(resultValue) > epsMax); + } while (contLoop); + + // Return internal rate of return + return resultRate; +}; + +exports.ISPMT = function(rate, period, periods, value) { + rate = common.parseNumber(rate); + period = common.parseNumber(period); + periods = common.parseNumber(periods); + value = common.parseNumber(value); + if (common.anyIsError(rate, period, periods, value)) { + return error$1.value; + } + + // Return interest + return value * rate * (period / periods - 1); +}; + +// TODO +exports.MDURATION = function() { + throw new Error('MDURATION is not implemented'); +}; + +exports.MIRR = function(values, finance_rate, reinvest_rate) { + values = common.parseNumberArray(common.flatten(values)); + finance_rate = common.parseNumber(finance_rate); + reinvest_rate = common.parseNumber(reinvest_rate); + if (common.anyIsError(values, finance_rate, reinvest_rate)) { + return error$1.value; + } + + // Initialize number of values + var n = values.length; + + // Lookup payments (negative values) and incomes (positive values) + var payments = []; + var incomes = []; + for (var i = 0; i < n; i++) { + if (values[i] < 0) { + payments.push(values[i]); + } else { + incomes.push(values[i]); + } + } + + // Return modified internal rate of return + var num = -exports.NPV(reinvest_rate, incomes) * Math.pow(1 + reinvest_rate, n - 1); + var den = exports.NPV(finance_rate, payments) * (1 + finance_rate); + return Math.pow(num / den, 1 / (n - 1)) - 1; +}; + +exports.NOMINAL = function(rate, periods) { + rate = common.parseNumber(rate); + periods = common.parseNumber(periods); + if (common.anyIsError(rate, periods)) { + return error$1.value; + } + + // Return error if rate <=0 or periods < 1 + if (rate <= 0 || periods < 1) { + return error$1.num; + } + + // Truncate periods if it is not an integer + periods = parseInt(periods, 10); + + // Return nominal annual interest rate + return (Math.pow(rate + 1, 1 / periods) - 1) * periods; +}; + +exports.NPER = function(rate, payment, present, future, type) { + type = (type === undefined) ? 0 : type; + future = (future === undefined) ? 0 : future; + + rate = common.parseNumber(rate); + payment = common.parseNumber(payment); + present = common.parseNumber(present); + future = common.parseNumber(future); + type = common.parseNumber(type); + if (common.anyIsError(rate, payment, present, future, type)) { + return error$1.value; + } + + // Return number of periods + var num = payment * (1 + rate * type) - future * rate; + var den = (present * rate + payment * (1 + rate * type)); + return Math.log(num / den) / Math.log(1 + rate); +}; + +exports.NPV = function() { + var args = common.parseNumberArray(common.flatten(arguments)); + if (args instanceof Error) { + return args; + } + + // Lookup rate + var rate = args[0]; + + // Initialize net present value + var value = 0; + + // Loop on all values + for (var j = 1; j < args.length; j++) { + value += args[j] / Math.pow(1 + rate, j); + } + + // Return net present value + return value; +}; + +// TODO +exports.ODDFPRICE = function() { + throw new Error('ODDFPRICE is not implemented'); +}; + +// TODO +exports.ODDFYIELD = function() { + throw new Error('ODDFYIELD is not implemented'); +}; + +// TODO +exports.ODDLPRICE = function() { + throw new Error('ODDLPRICE is not implemented'); +}; + +// TODO +exports.ODDLYIELD = function() { + throw new Error('ODDLYIELD is not implemented'); +}; + +exports.PDURATION = function(rate, present, future) { + rate = common.parseNumber(rate); + present = common.parseNumber(present); + future = common.parseNumber(future); + if (common.anyIsError(rate, present, future)) { + return error$1.value; + } + + // Return error if rate <=0 + if (rate <= 0) { + return error$1.num; + } + + // Return number of periods + return (Math.log(future) - Math.log(present)) / Math.log(1 + rate); +}; + +exports.PMT = function(rate, periods, present, future, type) { + // Credits: algorithm inspired by Apache OpenOffice + + future = future || 0; + type = type || 0; + + rate = common.parseNumber(rate); + periods = common.parseNumber(periods); + present = common.parseNumber(present); + future = common.parseNumber(future); + type = common.parseNumber(type); + if (common.anyIsError(rate, periods, present, future, type)) { + return error$1.value; + } + + // Return payment + var result; + if (rate === 0) { + result = (present + future) / periods; + } else { + var term = Math.pow(1 + rate, periods); + if (type === 1) { + result = (future * rate / (term - 1) + present * rate / (1 - 1 / term)) / (1 + rate); + } else { + result = future * rate / (term - 1) + present * rate / (1 - 1 / term); + } + } + return -result; +}; + +exports.PPMT = function(rate, period, periods, present, future, type) { + future = future || 0; + type = type || 0; + + rate = common.parseNumber(rate); + periods = common.parseNumber(periods); + present = common.parseNumber(present); + future = common.parseNumber(future); + type = common.parseNumber(type); + if (common.anyIsError(rate, periods, present, future, type)) { + return error$1.value; + } + + return exports.PMT(rate, periods, present, future, type) - exports.IPMT(rate, period, periods, present, future, type); +}; + +// TODO +exports.PRICE = function() { + throw new Error('PRICE is not implemented'); +}; + +// TODO +exports.PRICEDISC = function() { + throw new Error('PRICEDISC is not implemented'); +}; + +// TODO +exports.PRICEMAT = function() { + throw new Error('PRICEMAT is not implemented'); +}; + +exports.PV = function(rate, periods, payment, future, type) { + future = future || 0; + type = type || 0; + + rate = common.parseNumber(rate); + periods = common.parseNumber(periods); + payment = common.parseNumber(payment); + future = common.parseNumber(future); + type = common.parseNumber(type); + if (common.anyIsError(rate, periods, payment, future, type)) { + return error$1.value; + } + + // Return present value + if (rate === 0) { + return -payment * periods - future; + } else { + return (((1 - Math.pow(1 + rate, periods)) / rate) * payment * (1 + rate * type) - future) / Math.pow(1 + rate, periods); + } +}; + +exports.RATE = function(periods, payment, present, future, type, guess) { + // Credits: rabugento + + guess = (guess === undefined) ? 0.01 : guess; + future = (future === undefined) ? 0 : future; + type = (type === undefined) ? 0 : type; + + periods = common.parseNumber(periods); + payment = common.parseNumber(payment); + present = common.parseNumber(present); + future = common.parseNumber(future); + type = common.parseNumber(type); + guess = common.parseNumber(guess); + if (common.anyIsError(periods, payment, present, future, type, guess)) { + return error$1.value; + } + + // Set maximum epsilon for end of iteration + var epsMax = 1e-10; + + // Set maximum number of iterations + var iterMax = 50; + + // Implement Newton's method + var y, y0, y1, x0, x1 = 0, + f = 0, + i = 0; + var rate = guess; + if (Math.abs(rate) < epsMax) { + y = present * (1 + periods * rate) + payment * (1 + rate * type) * periods + future; + } else { + f = Math.exp(periods * Math.log(1 + rate)); + y = present * f + payment * (1 / rate + type) * (f - 1) + future; + } + y0 = present + payment * periods + future; + y1 = present * f + payment * (1 / rate + type) * (f - 1) + future; + i = x0 = 0; + x1 = rate; + while ((Math.abs(y0 - y1) > epsMax) && (i < iterMax)) { + rate = (y1 * x0 - y0 * x1) / (y1 - y0); + x0 = x1; + x1 = rate; + if (Math.abs(rate) < epsMax) { + y = present * (1 + periods * rate) + payment * (1 + rate * type) * periods + future; + } else { + f = Math.exp(periods * Math.log(1 + rate)); + y = present * f + payment * (1 / rate + type) * (f - 1) + future; + } + y0 = y1; + y1 = y; + ++i; + } + return rate; +}; + +// TODO +exports.RECEIVED = function() { + throw new Error('RECEIVED is not implemented'); +}; + +exports.RRI = function(periods, present, future) { + periods = common.parseNumber(periods); + present = common.parseNumber(present); + future = common.parseNumber(future); + if (common.anyIsError(periods, present, future)) { + return error$1.value; + } + + // Return error if periods or present is equal to 0 (zero) + if (periods === 0 || present === 0) { + return error$1.num; + } + + // Return equivalent interest rate + return Math.pow(future / present, 1 / periods) - 1; +}; + +exports.SLN = function(cost, salvage, life) { + cost = common.parseNumber(cost); + salvage = common.parseNumber(salvage); + life = common.parseNumber(life); + if (common.anyIsError(cost, salvage, life)) { + return error$1.value; + } + + // Return error if life equal to 0 (zero) + if (life === 0) { + return error$1.num; + } + + // Return straight-line depreciation + return (cost - salvage) / life; +}; + +exports.SYD = function(cost, salvage, life, period) { + // Return error if any of the parameters is not a number + cost = common.parseNumber(cost); + salvage = common.parseNumber(salvage); + life = common.parseNumber(life); + period = common.parseNumber(period); + if (common.anyIsError(cost, salvage, life, period)) { + return error$1.value; + } + + // Return error if life equal to 0 (zero) + if (life === 0) { + return error$1.num; + } + + // Return error if period is lower than 1 or greater than life + if (period < 1 || period > life) { + return error$1.num; + } + + // Truncate period if it is not an integer + period = parseInt(period, 10); + + // Return straight-line depreciation + return ((cost - salvage) * (life - period + 1) * 2) / (life * (life + 1)); +}; + +exports.TBILLEQ = function(settlement, maturity, discount) { + settlement = common.parseDate(settlement); + maturity = common.parseDate(maturity); + discount = common.parseNumber(discount); + if (common.anyIsError(settlement, maturity, discount)) { + return error$1.value; + } + + // Return error if discount is lower than or equal to zero + if (discount <= 0) { + return error$1.num; + } + + // Return error if settlement is greater than maturity + if (settlement > maturity) { + return error$1.num; + } + + // Return error if maturity is more than one year after settlement + if (maturity - settlement > 365 * 24 * 60 * 60 * 1000) { + return error$1.num; + } + + // Return bond-equivalent yield + return (365 * discount) / (360 - discount * dateTime.DAYS360(settlement, maturity, false)); +}; + +exports.TBILLPRICE = function(settlement, maturity, discount) { + settlement = common.parseDate(settlement); + maturity = common.parseDate(maturity); + discount = common.parseNumber(discount); + if (common.anyIsError(settlement, maturity, discount)) { + return error$1.value; + } + + // Return error if discount is lower than or equal to zero + if (discount <= 0) { + return error$1.num; + } + + // Return error if settlement is greater than maturity + if (settlement > maturity) { + return error$1.num; + } + + // Return error if maturity is more than one year after settlement + if (maturity - settlement > 365 * 24 * 60 * 60 * 1000) { + return error$1.num; + } + + // Return bond-equivalent yield + return 100 * (1 - discount * dateTime.DAYS360(settlement, maturity, false) / 360); +}; + +exports.TBILLYIELD = function(settlement, maturity, price) { + settlement = common.parseDate(settlement); + maturity = common.parseDate(maturity); + price = common.parseNumber(price); + if (common.anyIsError(settlement, maturity, price)) { + return error$1.value; + } + + // Return error if price is lower than or equal to zero + if (price <= 0) { + return error$1.num; + } + + // Return error if settlement is greater than maturity + if (settlement > maturity) { + return error$1.num; + } + + // Return error if maturity is more than one year after settlement + if (maturity - settlement > 365 * 24 * 60 * 60 * 1000) { + return error$1.num; + } + + // Return bond-equivalent yield + return (100 - price) * 360 / (price * dateTime.DAYS360(settlement, maturity, false)); +}; + +// TODO +exports.VDB = function() { + throw new Error('VDB is not implemented'); +}; + +// TODO needs better support for date +// exports.XIRR = function(values, dates, guess) { +// // Credits: algorithm inspired by Apache OpenOffice +// +// values = utils.parseNumberArray(utils.flatten(values)); +// dates = utils.parseDateArray(utils.flatten(dates)); +// guess = utils.parseNumber(guess); +// +// if (utils.anyIsError(values, dates, guess)) { +// return error.value; +// } +// +// // Calculates the resulting amount +// var irrResult = function(values, dates, rate) { +// var r = rate + 1; +// var result = values[0]; +// for (var i = 1; i < values.length; i++) { +// result += values[i] / Math.pow(r, dateTime.DAYS(dates[i], dates[0]) / 365); +// } +// return result; +// }; +// +// // Calculates the first derivation +// var irrResultDeriv = function(values, dates, rate) { +// var r = rate + 1; +// var result = 0; +// for (var i = 1; i < values.length; i++) { +// var frac = dateTime.DAYS(dates[i], dates[0]) / 365; +// result -= frac * values[i] / Math.pow(r, frac + 1); +// } +// return result; +// }; +// +// // Check that values contains at least one positive value and one negative value +// var positive = false; +// var negative = false; +// for (var i = 0; i < values.length; i++) { +// if (values[i] > 0) { +// positive = true; +// } +// if (values[i] < 0) { +// negative = true; +// } +// } +// +// // Return error if values does not contain at least one positive value and one negative value +// if (!positive || !negative) { +// return error.num; +// } +// +// // Initialize guess and resultRate +// guess = guess || 0.1; +// var resultRate = guess; +// +// // Set maximum epsilon for end of iteration +// var epsMax = 1e-10; +// +// // Implement Newton's method +// var newRate, epsRate, resultValue; +// var contLoop = true; +// do { +// resultValue = irrResult(values, dates, resultRate); +// newRate = resultRate - resultValue / irrResultDeriv(values, dates, resultRate); +// epsRate = Math.abs(newRate - resultRate); +// resultRate = newRate; +// contLoop = (epsRate > epsMax) && (Math.abs(resultValue) > epsMax); +// } while (contLoop); +// +// // Return internal rate of return +// return resultRate; +// }; + +exports.XNPV = function(rate, values, dates) { + rate = common.parseNumber(rate); + values = common.parseNumberArray(common.flatten(values)); + dates = common.parseDateArray(common.flatten(dates)); + if (common.anyIsError(rate, values, dates)) { + return error$1.value; + } + + var result = 0; + for (var i = 0; i < values.length; i++) { + result += values[i] / Math.pow(1 + rate, dateTime.DAYS(dates[i], dates[0]) / 365); + } + return result; +}; + +// TODO +exports.YIELD = function() { + throw new Error('YIELD is not implemented'); +}; + +// TODO +exports.YIELDDISC = function() { + throw new Error('YIELDDISC is not implemented'); +}; + +// TODO +exports.YIELDMAT = function() { + throw new Error('YIELDMAT is not implemented'); +}; +}); + +var MATCH$3 = function(lookupValue, lookupArray, matchType) { + if (!lookupValue && !lookupArray) { + return error$1.na; + } + + if (arguments.length === 2) { + matchType = 1; + } + if (!(lookupArray instanceof Array)) { + return error$1.na; + } + + if (matchType !== -1 && matchType !== 0 && matchType !== 1) { + return error$1.na; + } + var index; + var indexValue; + for (var idx = 0; idx < lookupArray.length; idx++) { + if (matchType === 1) { + if (lookupArray[idx] === lookupValue) { + return idx + 1; + } else if (lookupArray[idx] < lookupValue) { + if (!indexValue) { + index = idx + 1; + indexValue = lookupArray[idx]; + } else if (lookupArray[idx] > indexValue) { + index = idx + 1; + indexValue = lookupArray[idx]; + } + } + } else if (matchType === 0) { + if (typeof lookupValue === 'string') { + lookupValue = lookupValue.replace(/\?/g, '.'); + if (lookupArray[idx].toLowerCase().match(lookupValue.toLowerCase())) { + return idx + 1; + } + } else { + if (lookupArray[idx] === lookupValue) { + return idx + 1; + } + } + } else if (matchType === -1) { + if (lookupArray[idx] === lookupValue) { + return idx + 1; + } else if (lookupArray[idx] > lookupValue) { + if (!indexValue) { + index = idx + 1; + indexValue = lookupArray[idx]; + } else if (lookupArray[idx] < indexValue) { + index = idx + 1; + indexValue = lookupArray[idx]; + } + } + } + } + + return index ? index : error$1.na; +}; + +var VLOOKUP = function (needle, table, index, rangeLookup) { + if (!needle || !table || !index) { + return error$1.na; + } + + rangeLookup = rangeLookup || false; + for (var i = 0; i < table.length; i++) { + var row = table[i]; + if ((!rangeLookup && row[0] === needle) || + ((row[0] === needle) || + (rangeLookup && typeof row[0] === "string" && row[0].toLowerCase().indexOf(needle.toLowerCase()) !== -1))) { + return (index < (row.length + 1) ? row[index - 1] : error$1.ref); + } + } + + return error$1.na; +}; + +var HLOOKUP = function (needle, table, index, rangeLookup) { + if (!needle || !table || !index) { + return error$1.na; + } + + rangeLookup = rangeLookup || false; + + var transposedTable = common.transpose(table); + + for (var i = 0; i < transposedTable.length; i++) { + var row = transposedTable[i]; + if ((!rangeLookup && row[0] === needle) || + ((row[0] === needle) || + (rangeLookup && typeof row[0] === "string" && row[0].toLowerCase().indexOf(needle.toLowerCase()) !== -1))) { + return (index < (row.length + 1) ? row[index - 1] : error$1.ref); + } + } + + return error$1.na; +}; + +var lookupReference = { + MATCH: MATCH$3, + VLOOKUP: VLOOKUP, + HLOOKUP: HLOOKUP +}; + +var formulajs = createCommonjsModule(function (module, exports) { +var categories = [ + compatibility, + database, + engineering, + logical, + mathTrig, + text$1, + dateTime, + financial, + information, + lookupReference, + statistical, + miscellaneous +]; + +for (var c in categories) { + var category = categories[c]; + for (var f in category) { + exports[f] = exports[f] || category[f]; + } +} +}); + +var supportedFormulas = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = void 0; +var SUPPORTED_FORMULAS = ['ABS', 'ACCRINT', 'ACOS', 'ACOSH', 'ACOT', 'ACOTH', 'ADD', 'AGGREGATE', 'AND', 'ARABIC', 'ARGS2ARRAY', 'ASIN', 'ASINH', 'ATAN', 'ATAN2', 'ATANH', 'AVEDEV', 'AVERAGE', 'AVERAGEA', 'AVERAGEIF', 'AVERAGEIFS', 'BASE', 'BESSELI', 'BESSELJ', 'BESSELK', 'BESSELY', 'BETA.DIST', 'BETA.INV', 'BETADIST', 'BETAINV', 'BIN2DEC', 'BIN2HEX', 'BIN2OCT', 'BINOM.DIST', 'BINOM.DIST.RANGE', 'BINOM.INV', 'BINOMDIST', 'BITAND', 'BITLSHIFT', 'BITOR', 'BITRSHIFT', 'BITXOR', 'CEILING', 'CEILINGMATH', 'CEILINGPRECISE', 'CHAR', 'CHISQ.DIST', 'CHISQ.DIST.RT', 'CHISQ.INV', 'CHISQ.INV.RT', 'CHOOSE', 'CHOOSE', 'CLEAN', 'CODE', 'COLUMN', 'COLUMNS', 'COMBIN', 'COMBINA', 'COMPLEX', 'CONCATENATE', 'CONFIDENCE', 'CONFIDENCE.NORM', 'CONFIDENCE.T', 'CONVERT', 'CORREL', 'COS', 'COSH', 'COT', 'COTH', 'COUNT', 'COUNTA', 'COUNTBLANK', 'COUNTIF', 'COUNTIFS', 'COUNTIN', 'COUNTUNIQUE', 'COVARIANCE.P', 'COVARIANCE.S', 'CSC', 'CSCH', 'CUMIPMT', 'CUMPRINC', 'DATE', 'DATEVALUE', 'DAY', 'DAYS', 'DAYS360', 'DB', 'DDB', 'DEC2BIN', 'DEC2HEX', 'DEC2OCT', 'DECIMAL', 'DEGREES', 'DELTA', 'DEVSQ', 'DIVIDE', 'DOLLARDE', 'DOLLARFR', 'E', 'EDATE', 'EFFECT', 'EOMONTH', 'EQ', 'ERF', 'ERFC', 'EVEN', 'EXACT', 'EXP', 'EXPON.DIST', 'EXPONDIST', 'F.DIST', 'F.DIST.RT', 'F.INV', 'F.INV.RT', 'FACT', 'FACTDOUBLE', 'FALSE', 'FDIST', 'FDISTRT', 'FIND', 'FINV', 'FINVRT', 'FISHER', 'FISHERINV', 'FLATTEN', 'FLOOR', 'FORECAST', 'FREQUENCY', 'FV', 'FVSCHEDULE', 'GAMMA', 'GAMMA.DIST', 'GAMMA.INV', 'GAMMADIST', 'GAMMAINV', 'GAMMALN', 'GAMMALN.PRECISE', 'GAUSS', 'GCD', 'GEOMEAN', 'GESTEP', 'GROWTH', 'GTE', 'HARMEAN', 'HEX2BIN', 'HEX2DEC', 'HEX2OCT', 'HOUR', 'HTML2TEXT', 'HYPGEOM.DIST', 'HYPGEOMDIST', 'IF', 'IMABS', 'IMAGINARY', 'IMARGUMENT', 'IMCONJUGATE', 'IMCOS', 'IMCOSH', 'IMCOT', 'IMCSC', 'IMCSCH', 'IMDIV', 'IMEXP', 'IMLN', 'IMLOG10', 'IMLOG2', 'IMPOWER', 'IMPRODUCT', 'IMREAL', 'IMSEC', 'IMSECH', 'IMSIN', 'IMSINH', 'IMSQRT', 'IMSUB', 'IMSUM', 'IMTAN', 'INT', 'INTERCEPT', 'INTERVAL', 'IPMT', 'IRR', 'ISBINARY', 'ISBLANK', 'ISEVEN', 'ISLOGICAL', 'ISNONTEXT', 'ISNUMBER', 'ISODD', 'ISODD', 'ISOWEEKNUM', 'ISPMT', 'ISTEXT', 'JOIN', 'KURT', 'LARGE', 'LCM', 'LEFT', 'LEN', 'LINEST', 'LN', 'LOG', 'LOG10', 'LOGEST', 'LOGNORM.DIST', 'LOGNORM.INV', 'LOGNORMDIST', 'LOGNORMINV', 'LOWER', 'LT', 'LTE', 'MATCH', 'MAX', 'MAXA', 'MEDIAN', 'MID', 'MIN', 'MINA', 'MINUS', 'MINUTE', 'MIRR', 'MOD', 'MODE.MULT', 'MODE.SNGL', 'MODEMULT', 'MODESNGL', 'MONTH', 'MROUND', 'MULTINOMIAL', 'MULTIPLY', 'NE', 'NEGBINOM.DIST', 'NEGBINOMDIST', 'NETWORKDAYS', 'NOMINAL', 'NORM.DIST', 'NORM.INV', 'NORM.S.DIST', 'NORM.S.INV', 'NORMDIST', 'NORMINV', 'NORMSDIST', 'NORMSINV', 'NOT', 'NOW', 'NPER', 'NPV', 'NUMBERS', 'OCT2BIN', 'OCT2DEC', 'OCT2HEX', 'ODD', 'OR', 'PDURATION', 'PEARSON', 'PERCENTILEEXC', 'PERCENTILEINC', 'PERCENTRANKEXC', 'PERCENTRANKINC', 'PERMUT', 'PERMUTATIONA', 'PHI', 'PI', 'PMT', 'POISSON.DIST', 'POISSONDIST', 'POW', 'POWER', 'PPMT', 'PROB', 'PRODUCT', 'PROPER', 'PV', 'QUARTILE.EXC', 'QUARTILE.INC', 'QUARTILEEXC', 'QUARTILEINC', 'QUOTIENT', 'RADIANS', 'RAND', 'RANDBETWEEN', 'RANK.AVG', 'RANK.EQ', 'RANKAVG', 'RANKEQ', 'RATE', 'REFERENCE', 'REGEXEXTRACT', 'REGEXMATCH', 'REGEXREPLACE', 'REPLACE', 'REPT', 'RIGHT', 'ROMAN', 'ROUND', 'ROUNDDOWN', 'ROUNDUP', 'ROW', 'ROWS', 'RRI', 'RSQ', 'SEARCH', 'SEC', 'SECH', 'SECOND', 'SERIESSUM', 'SIGN', 'SIN', 'SINH', 'SKEW', 'SKEW.P', 'SKEWP', 'SLN', 'SLOPE', 'SMALL', 'SPLIT', 'SPLIT', 'SQRT', 'SQRTPI', 'STANDARDIZE', 'STDEV.P', 'STDEV.S', 'STDEVA', 'STDEVP', 'STDEVPA', 'STDEVS', 'STEYX', 'SUBSTITUTE', 'SUBTOTAL', 'SUM', 'SUMIF', 'SUMIFS', 'SUMPRODUCT', 'SUMSQ', 'SUMX2MY2', 'SUMX2PY2', 'SUMXMY2', 'SWITCH', 'SYD', 'T', 'T.DIST', 'T.DIST.2T', 'T.DIST.RT', 'T.INV', 'T.INV.2T', 'TAN', 'TANH', 'TBILLEQ', 'TBILLPRICE', 'TBILLYIELD', 'TDIST', 'TDIST2T', 'TDISTRT', 'TIME', 'TIMEVALUE', 'TINV', 'TINV2T', 'TODAY', 'TRANSPOSE', 'TREND', 'TRIM', 'TRIMMEAN', 'TRUE', 'TRUNC', 'UNICHAR', 'UNICODE', 'UNIQUE', 'UPPER', 'VAR.P', 'VAR.S', 'VARA', 'VARP', 'VARPA', 'VARS', 'WEEKDAY', 'WEEKNUM', 'WEIBULL.DIST', 'WEIBULLDIST', 'WORKDAY', 'XIRR', 'XNPV', 'XOR', 'YEAR', 'YEARFRAC']; +var _default = SUPPORTED_FORMULAS; +exports["default"] = _default; +}); + +var formulaFunction = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; + +var _formulajs = _interopRequireDefault(formulajs); + +var _supportedFormulas = _interopRequireDefault(supportedFormulas); + + + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +var SYMBOL = _supportedFormulas["default"]; +exports.SYMBOL = SYMBOL; + +function func(symbol) { + return function __formulaFunction() { + symbol = symbol.toUpperCase(); + var symbolParts = symbol.split('.'); + var foundFormula = false; + var result; + + if (symbolParts.length === 1) { + if (_formulajs["default"][symbolParts[0]]) { + foundFormula = true; + result = _formulajs["default"][symbolParts[0]].apply(_formulajs["default"], arguments); + } + } else { + var length = symbolParts.length; + var index = 0; + var nestedFormula = _formulajs["default"]; + + while (index < length) { + nestedFormula = nestedFormula[symbolParts[index]]; + index++; + + if (!nestedFormula) { + nestedFormula = null; + break; + } + } + + if (nestedFormula) { + foundFormula = true; + result = nestedFormula.apply(void 0, arguments); + } + } + + if (!foundFormula) { + throw Error(error_1.ERROR_NAME); + } + + return result; + }; +} + +func.isFactory = true; +func.SYMBOL = SYMBOL; +}); + +var greaterThan = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; +var SYMBOL = '>'; +exports.SYMBOL = SYMBOL; + +function func(exp1, exp2) { + return exp1 > exp2; +} + +func.SYMBOL = SYMBOL; +}); + +var greaterThanOrEqual = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; +var SYMBOL = '>='; +exports.SYMBOL = SYMBOL; + +function func(exp1, exp2) { + return exp1 >= exp2; +} + +func.SYMBOL = SYMBOL; +}); + +var lessThan = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; +var SYMBOL = '<'; +exports.SYMBOL = SYMBOL; + +function func(exp1, exp2) { + return exp1 < exp2; +} + +func.SYMBOL = SYMBOL; +}); + +var lessThanOrEqual = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; +var SYMBOL = '<='; +exports.SYMBOL = SYMBOL; + +function func(exp1, exp2) { + return exp1 <= exp2; +} + +func.SYMBOL = SYMBOL; +}); + +var minus = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; + + + + + +var SYMBOL = '-'; +exports.SYMBOL = SYMBOL; + +function func(first) { + for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + rest[_key - 1] = arguments[_key]; + } + + var result = rest.reduce(function (acc, value) { + return acc - (0, number.toNumber)(value); + }, (0, number.toNumber)(first)); + + if (isNaN(result)) { + throw Error(error_1.ERROR_VALUE); + } + + return result; +} + +func.SYMBOL = SYMBOL; +}); + +var multiply$1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; + + + + + +var SYMBOL = '*'; +exports.SYMBOL = SYMBOL; + +function func(first) { + for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + rest[_key - 1] = arguments[_key]; + } + + var result = rest.reduce(function (acc, value) { + return acc * (0, number.toNumber)(value); + }, (0, number.toNumber)(first)); + + if (isNaN(result)) { + throw Error(error_1.ERROR_VALUE); + } + + return result; +} + +func.SYMBOL = SYMBOL; +}); + +var notEqual = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; +var SYMBOL = '<>'; +exports.SYMBOL = SYMBOL; + +function func(exp1, exp2) { + return exp1 !== exp2; +} + +func.SYMBOL = SYMBOL; +}); + +var power = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = func; +exports.SYMBOL = void 0; + + + + + +var SYMBOL = '^'; +exports.SYMBOL = SYMBOL; + +function func(exp1, exp2) { + var result = Math.pow((0, number.toNumber)(exp1), (0, number.toNumber)(exp2)); + + if (isNaN(result)) { + throw Error(error_1.ERROR_VALUE); + } + + return result; +} + +func.SYMBOL = SYMBOL; +}); + +var evaluateByOperator_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports["default"] = evaluateByOperator; +exports.registerOperation = registerOperation; + +var _add = _interopRequireDefault(add); + +var _ampersand = _interopRequireDefault(ampersand); + +var _divide = _interopRequireDefault(divide$1); + +var _equal = _interopRequireDefault(equal); + +var _formulaFunction = _interopRequireDefault(formulaFunction); + +var _greaterThan = _interopRequireDefault(greaterThan); + +var _greaterThanOrEqual = _interopRequireDefault(greaterThanOrEqual); + +var _lessThan = _interopRequireDefault(lessThan); + +var _lessThanOrEqual = _interopRequireDefault(lessThanOrEqual); + +var _minus = _interopRequireDefault(minus); + +var _multiply = _interopRequireDefault(multiply$1); + +var _notEqual = _interopRequireDefault(notEqual); + +var _power = _interopRequireDefault(power); + + + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } + +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +var availableOperators = Object.create(null); +/** + * Evaluate values by operator id.git + * + * @param {String} operator Operator id. + * @param {Array} [params=[]] Arguments to evaluate. + * @returns {*} + */ + +function evaluateByOperator(operator) { + var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + operator = operator.toUpperCase(); + + if (!availableOperators[operator]) { + throw Error(error_1.ERROR_NAME); + } + + return availableOperators[operator].apply(availableOperators, _toConsumableArray(params)); +} +/** + * Register operator. + * + * @param {String|Array} symbol Symbol to register. + * @param {Function} func Logic to register for this symbol. + */ + + +function registerOperation(symbol, func) { + if (!Array.isArray(symbol)) { + symbol = [symbol.toUpperCase()]; + } + + symbol.forEach(function (s) { + if (func.isFactory) { + availableOperators[s] = func(s); + } else { + availableOperators[s] = func; + } + }); +} + +registerOperation(_add["default"].SYMBOL, _add["default"]); +registerOperation(_ampersand["default"].SYMBOL, _ampersand["default"]); +registerOperation(_divide["default"].SYMBOL, _divide["default"]); +registerOperation(_equal["default"].SYMBOL, _equal["default"]); +registerOperation(_power["default"].SYMBOL, _power["default"]); +registerOperation(_formulaFunction["default"].SYMBOL, _formulaFunction["default"]); +registerOperation(_greaterThan["default"].SYMBOL, _greaterThan["default"]); +registerOperation(_greaterThanOrEqual["default"].SYMBOL, _greaterThanOrEqual["default"]); +registerOperation(_lessThan["default"].SYMBOL, _lessThan["default"]); +registerOperation(_lessThanOrEqual["default"].SYMBOL, _lessThanOrEqual["default"]); +registerOperation(_multiply["default"].SYMBOL, _multiply["default"]); +registerOperation(_notEqual["default"].SYMBOL, _notEqual["default"]); +registerOperation(_minus["default"].SYMBOL, _minus["default"]); +}); + +var grammarParser = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.Parser = Parser; + +/* parser generated by jison 0.4.18 */ + +/* + Returns a Parser object of the following structure: + + Parser: { + yy: {} + } + + Parser.prototype: { + yy: {}, + trace: function(), + symbols_: {associative list: name ==> number}, + terminals_: {associative list: number ==> name}, + productions_: [...], + performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$), + table: [...], + defaultActions: {...}, + parseError: function(str, hash), + parse: function(input), + + lexer: { + EOF: 1, + parseError: function(str, hash), + setInput: function(input), + input: function(), + unput: function(str), + more: function(), + less: function(n), + pastInput: function(), + upcomingInput: function(), + showPosition: function(), + test_match: function(regex_match_array, rule_index), + next: function(), + lex: function(), + begin: function(condition), + popState: function(), + _currentRules: function(), + topState: function(), + pushState: function(condition), + + options: { + ranges: boolean (optional: true ==> token location info will include a .range[] member) + flex: boolean (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match) + backtrack_lexer: boolean (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code) + }, + + performAction: function(yy, yy_, $avoiding_name_collisions, YY_START), + rules: [...], + conditions: {associative list: name ==> set}, + } + } + + + token location info (@$, _$, etc.): { + first_line: n, + last_line: n, + first_column: n, + last_column: n, + range: [start_number, end_number] (where the numbers are indexes into the input string, regular zero-based) + } + + + the parseError function receives a 'hash' object with these members for lexer and parser errors: { + text: (matched text) + token: (the produced terminal token, if any) + line: (yylineno) + } + while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: { + loc: (yylloc) + expected: (string describing the set of expected tokens) + recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error) + } +*/ +var o = function o(k, v, _o, l) { + for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) { + } + + return _o; +}, + $V0 = [1, 5], + $V1 = [1, 8], + $V2 = [1, 6], + $V3 = [1, 7], + $V4 = [1, 9], + $V5 = [1, 14], + $V6 = [1, 15], + $V7 = [1, 16], + $V8 = [1, 12], + $V9 = [1, 13], + $Va = [1, 17], + $Vb = [1, 19], + $Vc = [1, 20], + $Vd = [1, 21], + $Ve = [1, 22], + $Vf = [1, 23], + $Vg = [1, 24], + $Vh = [1, 25], + $Vi = [1, 26], + $Vj = [1, 27], + $Vk = [1, 28], + $Vl = [5, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 29, 30], + $Vm = [5, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 29, 30, 32], + $Vn = [5, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 29, 30, 34], + $Vo = [5, 10, 11, 13, 14, 15, 16, 17, 29, 30], + $Vp = [5, 10, 13, 14, 15, 16, 29, 30], + $Vq = [5, 10, 11, 13, 14, 15, 16, 17, 18, 19, 29, 30], + $Vr = [13, 29, 30]; + +var parser = { + trace: function trace() {}, + yy: {}, + symbols_: { + "error": 2, + "expressions": 3, + "expression": 4, + "EOF": 5, + "variableSequence": 6, + "number": 7, + "STRING": 8, + "&": 9, + "=": 10, + "+": 11, + "(": 12, + ")": 13, + "<": 14, + ">": 15, + "NOT": 16, + "-": 17, + "*": 18, + "/": 19, + "^": 20, + "FUNCTION": 21, + "expseq": 22, + "cell": 23, + "ABSOLUTE_CELL": 24, + "RELATIVE_CELL": 25, + "MIXED_CELL": 26, + ":": 27, + "ARRAY": 28, + ";": 29, + ",": 30, + "VARIABLE": 31, + "DECIMAL": 32, + "NUMBER": 33, + "%": 34, + "ERROR": 35, + "$accept": 0, + "$end": 1 + }, + terminals_: { + 5: "EOF", + 8: "STRING", + 9: "&", + 10: "=", + 11: "+", + 12: "(", + 13: ")", + 14: "<", + 15: ">", + 16: "NOT", + 17: "-", + 18: "*", + 19: "/", + 20: "^", + 21: "FUNCTION", + 24: "ABSOLUTE_CELL", + 25: "RELATIVE_CELL", + 26: "MIXED_CELL", + 27: ":", + 28: "ARRAY", + 29: ";", + 30: ",", + 31: "VARIABLE", + 32: "DECIMAL", + 33: "NUMBER", + 34: "%", + 35: "ERROR" + }, + productions_: [0, [3, 2], [4, 1], [4, 1], [4, 1], [4, 3], [4, 3], [4, 3], [4, 3], [4, 4], [4, 4], [4, 4], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 3], [4, 2], [4, 2], [4, 3], [4, 4], [4, 1], [4, 1], [4, 2], [23, 1], [23, 1], [23, 1], [23, 3], [23, 3], [23, 3], [23, 3], [23, 3], [23, 3], [23, 3], [23, 3], [23, 3], [22, 1], [22, 1], [22, 3], [22, 3], [6, 1], [6, 3], [7, 1], [7, 3], [7, 2], [2, 1]], + performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate + /* action[1] */ + , $$ + /* vstack */ + , _$ + /* lstack */ + ) { + /* this == yyval */ + var $0 = $$.length - 1; + + switch (yystate) { + case 1: + return $$[$0 - 1]; + + case 2: + this.$ = yy.callVariable($$[$0][0]); + break; + + case 3: + this.$ = yy.toNumber($$[$0]); + break; + + case 4: + this.$ = yy.trimEdges($$[$0]); + break; + + case 5: + this.$ = yy.evaluateByOperator('&', [$$[$0 - 2], $$[$0]]); + break; + + case 6: + this.$ = yy.evaluateByOperator('=', [$$[$0 - 2], $$[$0]]); + break; + + case 7: + this.$ = yy.evaluateByOperator('+', [$$[$0 - 2], $$[$0]]); + break; + + case 8: + this.$ = $$[$0 - 1]; + break; + + case 9: + this.$ = yy.evaluateByOperator('<=', [$$[$0 - 3], $$[$0]]); + break; + + case 10: + this.$ = yy.evaluateByOperator('>=', [$$[$0 - 3], $$[$0]]); + break; + + case 11: + this.$ = yy.evaluateByOperator('<>', [$$[$0 - 3], $$[$0]]); + break; + + case 12: + this.$ = yy.evaluateByOperator('NOT', [$$[$0 - 2], $$[$0]]); + break; + + case 13: + this.$ = yy.evaluateByOperator('>', [$$[$0 - 2], $$[$0]]); + break; + + case 14: + this.$ = yy.evaluateByOperator('<', [$$[$0 - 2], $$[$0]]); + break; + + case 15: + this.$ = yy.evaluateByOperator('-', [$$[$0 - 2], $$[$0]]); + break; + + case 16: + this.$ = yy.evaluateByOperator('*', [$$[$0 - 2], $$[$0]]); + break; + + case 17: + this.$ = yy.evaluateByOperator('/', [$$[$0 - 2], $$[$0]]); + break; + + case 18: + this.$ = yy.evaluateByOperator('^', [$$[$0 - 2], $$[$0]]); + break; + + case 19: + var n1 = yy.invertNumber($$[$0]); + this.$ = n1; + + if (isNaN(this.$)) { + this.$ = 0; + } + + break; + + case 20: + var n1 = yy.toNumber($$[$0]); + this.$ = n1; + + if (isNaN(this.$)) { + this.$ = 0; + } + + break; + + case 21: + this.$ = yy.callFunction($$[$0 - 2]); + break; + + case 22: + this.$ = yy.callFunction($$[$0 - 3], $$[$0 - 1]); + break; + + case 26: + case 27: + case 28: + this.$ = yy.cellValue($$[$0]); + break; + + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + this.$ = yy.rangeValue($$[$0 - 2], $$[$0]); + break; + + case 38: + case 42: + this.$ = [$$[$0]]; + break; + + case 39: + this.$ = yy.trimEdges(yytext).split(','); + break; + + case 40: + case 41: + $$[$0 - 2].push($$[$0]); + this.$ = $$[$0 - 2]; + break; + + case 43: + this.$ = Array.isArray($$[$0 - 2]) ? $$[$0 - 2] : [$$[$0 - 2]]; + this.$.push($$[$0]); + break; + + case 44: + this.$ = $$[$0]; + break; + + case 45: + this.$ = ($$[$0 - 2] + '.' + $$[$0]) * 1; + break; + + case 46: + this.$ = $$[$0 - 1] * 0.01; + break; + + case 47: + this.$ = yy.throwError($$[$0]); + break; + } + }, + table: [{ + 2: 11, + 3: 1, + 4: 2, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 1: [3] + }, { + 5: [1, 18], + 9: $Vb, + 10: $Vc, + 11: $Vd, + 14: $Ve, + 15: $Vf, + 16: $Vg, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }, o($Vl, [2, 2], { + 32: [1, 29] + }), o($Vl, [2, 3], { + 34: [1, 30] + }), o($Vl, [2, 4]), { + 2: 11, + 4: 31, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 32, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 33, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 12: [1, 34] + }, o($Vl, [2, 23]), o($Vl, [2, 24], { + 2: 35, + 35: $Va + }), o($Vm, [2, 42]), o($Vn, [2, 44], { + 32: [1, 36] + }), o($Vl, [2, 26], { + 27: [1, 37] + }), o($Vl, [2, 27], { + 27: [1, 38] + }), o($Vl, [2, 28], { + 27: [1, 39] + }), o([5, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 29, 30, 35], [2, 47]), { + 1: [2, 1] + }, { + 2: 11, + 4: 40, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 41, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 42, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 45, + 6: 3, + 7: 4, + 8: $V0, + 10: [1, 43], + 11: $V1, + 12: $V2, + 15: [1, 44], + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 47, + 6: 3, + 7: 4, + 8: $V0, + 10: [1, 46], + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 48, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 49, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 50, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 51, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 52, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 31: [1, 53] + }, o($Vn, [2, 46]), { + 9: $Vb, + 10: $Vc, + 11: $Vd, + 13: [1, 54], + 14: $Ve, + 15: $Vf, + 16: $Vg, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }, o($Vo, [2, 19], { + 9: $Vb, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o($Vo, [2, 20], { + 9: $Vb, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), { + 2: 11, + 4: 57, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 13: [1, 55], + 17: $V3, + 21: $V4, + 22: 56, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 28: [1, 58], + 31: $V8, + 33: $V9, + 35: $Va + }, o($Vl, [2, 25]), { + 33: [1, 59] + }, { + 24: [1, 60], + 25: [1, 61], + 26: [1, 62] + }, { + 24: [1, 63], + 25: [1, 64], + 26: [1, 65] + }, { + 24: [1, 66], + 25: [1, 67], + 26: [1, 68] + }, o($Vl, [2, 5]), o([5, 10, 13, 29, 30], [2, 6], { + 9: $Vb, + 11: $Vd, + 14: $Ve, + 15: $Vf, + 16: $Vg, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o($Vo, [2, 7], { + 9: $Vb, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), { + 2: 11, + 4: 69, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 70, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, o($Vp, [2, 14], { + 9: $Vb, + 11: $Vd, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), { + 2: 11, + 4: 71, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, o($Vp, [2, 13], { + 9: $Vb, + 11: $Vd, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o([5, 10, 13, 16, 29, 30], [2, 12], { + 9: $Vb, + 11: $Vd, + 14: $Ve, + 15: $Vf, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o($Vo, [2, 15], { + 9: $Vb, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o($Vq, [2, 16], { + 9: $Vb, + 20: $Vk + }), o($Vq, [2, 17], { + 9: $Vb, + 20: $Vk + }), o([5, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 29, 30], [2, 18], { + 9: $Vb + }), o($Vm, [2, 43]), o($Vl, [2, 8]), o($Vl, [2, 21]), { + 13: [1, 72], + 29: [1, 73], + 30: [1, 74] + }, o($Vr, [2, 38], { + 9: $Vb, + 10: $Vc, + 11: $Vd, + 14: $Ve, + 15: $Vf, + 16: $Vg, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o($Vr, [2, 39]), o($Vn, [2, 45]), o($Vl, [2, 29]), o($Vl, [2, 30]), o($Vl, [2, 31]), o($Vl, [2, 32]), o($Vl, [2, 33]), o($Vl, [2, 34]), o($Vl, [2, 35]), o($Vl, [2, 36]), o($Vl, [2, 37]), o($Vp, [2, 9], { + 9: $Vb, + 11: $Vd, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o($Vp, [2, 11], { + 9: $Vb, + 11: $Vd, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o($Vp, [2, 10], { + 9: $Vb, + 11: $Vd, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o($Vl, [2, 22]), { + 2: 11, + 4: 75, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, { + 2: 11, + 4: 76, + 6: 3, + 7: 4, + 8: $V0, + 11: $V1, + 12: $V2, + 17: $V3, + 21: $V4, + 23: 10, + 24: $V5, + 25: $V6, + 26: $V7, + 31: $V8, + 33: $V9, + 35: $Va + }, o($Vr, [2, 40], { + 9: $Vb, + 10: $Vc, + 11: $Vd, + 14: $Ve, + 15: $Vf, + 16: $Vg, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + }), o($Vr, [2, 41], { + 9: $Vb, + 10: $Vc, + 11: $Vd, + 14: $Ve, + 15: $Vf, + 16: $Vg, + 17: $Vh, + 18: $Vi, + 19: $Vj, + 20: $Vk + })], + defaultActions: { + 18: [2, 1] + }, + parseError: function parseError(str, hash) { + if (hash.recoverable) { + this.trace(str); + } else { + var error = new Error(str); + error.hash = hash; + throw error; + } + }, + parse: function parse(input) { + var self = this, + stack = [0], + // token stack + vstack = [null], + // semantic value stack + lstack = [], + // location stack + table = this.table, + yytext = '', + yylineno = 0, + yyleng = 0, + recovering = 0, + TERROR = 2, + EOF = 1; + var args = lstack.slice.call(arguments, 1); //this.reductionCount = this.shiftCount = 0; + + var lexer = Object.create(this.lexer); + var sharedState = { + yy: {} + }; // copy state + + for (var k in this.yy) { + if (Object.prototype.hasOwnProperty.call(this.yy, k)) { + sharedState.yy[k] = this.yy[k]; + } + } + + lexer.setInput(input, sharedState.yy); + sharedState.yy.lexer = lexer; + sharedState.yy.parser = this; + + if (typeof lexer.yylloc == 'undefined') { + lexer.yylloc = {}; + } + + var yyloc = lexer.yylloc; + lstack.push(yyloc); + var ranges = lexer.options && lexer.options.ranges; + + if (typeof sharedState.yy.parseError === 'function') { + this.parseError = sharedState.yy.parseError; + } else { + this.parseError = Object.getPrototypeOf(this).parseError; + } + + function popStack(n) { + stack.length = stack.length - 2 * n; + vstack.length = vstack.length - n; + lstack.length = lstack.length - n; + } + + var lex = function lex() { + var token; + token = lexer.lex() || EOF; // if token isn't its numeric value, convert + + if (typeof token !== 'number') { + token = self.symbols_[token] || token; + } + + return token; + }; + + var symbol, + preErrorSymbol, + state, + action, + r, + yyval = {}, + p, + len, + newState, + expected; + + while (true) { + // retreive state number from top of stack + state = stack[stack.length - 1]; // use default actions if available + + if (this.defaultActions[state]) { + action = this.defaultActions[state]; + } else { + if (symbol === null || typeof symbol == 'undefined') { + symbol = lex(); + } // read action for current state and first input + + + action = table[state] && table[state][symbol]; + } // handle parse error + + + if (typeof action === 'undefined' || !action.length || !action[0]) { + // Return the rule stack depth where the nearest error rule can be found. + // Return FALSE when no error recovery rule was found. + var locateNearestErrorRecoveryRule = function locateNearestErrorRecoveryRule(state) { + var stack_probe = stack.length - 1; + var depth = 0; // try to recover from error + + for (;;) { + // check for error recovery rule in this state + if (TERROR.toString() in table[state]) { + return depth; + } + + if (state === 0 || stack_probe < 2) { + return false; // No suitable error recovery rule available. + } + + stack_probe -= 2; // popStack(1): [symbol, action] + + state = stack[stack_probe]; + ++depth; + } + }; + + var error_rule_depth; + var errStr = ''; + + if (!recovering) { + // first see if there's any chance at hitting an error recovery rule: + error_rule_depth = locateNearestErrorRecoveryRule(state); // Report error + + expected = []; + + for (p in table[state]) { + if (this.terminals_[p] && p > TERROR) { + expected.push("'" + this.terminals_[p] + "'"); + } + } + + if (lexer.showPosition) { + errStr = 'Parse error on line ' + (yylineno + 1) + ":\n" + lexer.showPosition() + "\nExpecting " + expected.join(', ') + ", got '" + (this.terminals_[symbol] || symbol) + "'"; + } else { + errStr = 'Parse error on line ' + (yylineno + 1) + ": Unexpected " + (symbol == EOF ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'"); + } + + this.parseError(errStr, { + text: lexer.match, + token: this.terminals_[symbol] || symbol, + line: lexer.yylineno, + loc: yyloc, + expected: expected, + recoverable: error_rule_depth !== false + }); + } else if (preErrorSymbol !== EOF) { + error_rule_depth = locateNearestErrorRecoveryRule(state); + } // just recovered from another error + + + if (recovering == 3) { + if (symbol === EOF || preErrorSymbol === EOF) { + throw new Error(errStr || 'Parsing halted while starting to recover from another error.'); + } // discard current lookahead and grab another + + + yyleng = lexer.yyleng; + yytext = lexer.yytext; + yylineno = lexer.yylineno; + yyloc = lexer.yylloc; + symbol = lex(); + } // try to recover from error + + + if (error_rule_depth === false) { + throw new Error(errStr || 'Parsing halted. No suitable error recovery rule available.'); + } + + popStack(error_rule_depth); + preErrorSymbol = symbol == TERROR ? null : symbol; // save the lookahead token + + symbol = TERROR; // insert generic error symbol as new lookahead + + state = stack[stack.length - 1]; + action = table[state] && table[state][TERROR]; + recovering = 3; // allow 3 real symbols to be shifted before reporting a new error + } // this shouldn't happen, unless resolve defaults are off + + + if (action[0] instanceof Array && action.length > 1) { + throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol); + } + + switch (action[0]) { + case 1: + // shift + //this.shiftCount++; + stack.push(symbol); + vstack.push(lexer.yytext); + lstack.push(lexer.yylloc); + stack.push(action[1]); // push state + + symbol = null; + + if (!preErrorSymbol) { + // normal execution/no error + yyleng = lexer.yyleng; + yytext = lexer.yytext; + yylineno = lexer.yylineno; + yyloc = lexer.yylloc; + + if (recovering > 0) { + recovering--; + } + } else { + // error just occurred, resume old lookahead f/ before error + symbol = preErrorSymbol; + preErrorSymbol = null; + } + + break; + + case 2: + // reduce + //this.reductionCount++; + len = this.productions_[action[1]][1]; // perform semantic action + + yyval.$ = vstack[vstack.length - len]; // default to $$ = $1 + // default location, uses first token for firsts, last for lasts + + yyval._$ = { + first_line: lstack[lstack.length - (len || 1)].first_line, + last_line: lstack[lstack.length - 1].last_line, + first_column: lstack[lstack.length - (len || 1)].first_column, + last_column: lstack[lstack.length - 1].last_column + }; + + if (ranges) { + yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]]; + } + + r = this.performAction.apply(yyval, [yytext, yyleng, yylineno, sharedState.yy, action[1], vstack, lstack].concat(args)); + + if (typeof r !== 'undefined') { + return r; + } // pop off stack + + + if (len) { + stack = stack.slice(0, -1 * len * 2); + vstack = vstack.slice(0, -1 * len); + lstack = lstack.slice(0, -1 * len); + } + + stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce) + + vstack.push(yyval.$); + lstack.push(yyval._$); // goto new state = table[STATE][NONTERMINAL] + + newState = table[stack[stack.length - 2]][stack[stack.length - 1]]; + stack.push(newState); + break; + + case 3: + // accept + return true; + } + } + + return true; + } +}; +/* generated by jison-lex 0.3.4 */ + +var lexer = function () { + var lexer = { + EOF: 1, + parseError: function parseError(str, hash) { + if (this.yy.parser) { + this.yy.parser.parseError(str, hash); + } else { + throw new Error(str); + } + }, + // resets the lexer, sets new input + setInput: function setInput(input, yy) { + this.yy = yy || this.yy || {}; + this._input = input; + this._more = this._backtrack = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ''; + this.conditionStack = ['INITIAL']; + this.yylloc = { + first_line: 1, + first_column: 0, + last_line: 1, + last_column: 0 + }; + + if (this.options.ranges) { + this.yylloc.range = [0, 0]; + } + + this.offset = 0; + return this; + }, + // consumes and returns one char from the input + input: function input() { + var ch = this._input[0]; + this.yytext += ch; + this.yyleng++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + + if (this.options.ranges) { + this.yylloc.range[1]++; + } + + this._input = this._input.slice(1); + return ch; + }, + // unshifts one char (or a string) into the input + unput: function unput(ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length - len); //this.yyleng -= len; + + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length - 1); + this.matched = this.matched.substr(0, this.matched.length - 1); + + if (lines.length - 1) { + this.yylineno -= lines.length - 1; + } + + var r = this.yylloc.range; + this.yylloc = { + first_line: this.yylloc.first_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.first_column, + last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len + }; + + if (this.options.ranges) { + this.yylloc.range = [r[0], r[0] + this.yyleng - len]; + } + + this.yyleng = this.yytext.length; + return this; + }, + // When called from action, caches matched text and appends it on next action + more: function more() { + this._more = true; + return this; + }, + // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead. + reject: function reject() { + if (this.options.backtrack_lexer) { + this._backtrack = true; + } else { + return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + + return this; + }, + // retain first n characters of the match + less: function less(n) { + this.unput(this.match.slice(n)); + }, + // displays already matched input, i.e. for error messages + pastInput: function pastInput() { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, ""); + }, + // displays upcoming input, i.e. for error messages + upcomingInput: function upcomingInput() { + var next = this.match; + + if (next.length < 20) { + next += this._input.substr(0, 20 - next.length); + } + + return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, ""); + }, + // displays the character position where the lexing error occurred, i.e. for error messages + showPosition: function showPosition() { + var pre = this.pastInput(); + var c = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c + "^"; + }, + // test the lexed token: return FALSE when not a match, otherwise return token + test_match: function test_match(match, indexed_rule) { + var token, lines, backup; + + if (this.options.backtrack_lexer) { + // save context + backup = { + yylineno: this.yylineno, + yylloc: { + first_line: this.yylloc.first_line, + last_line: this.last_line, + first_column: this.yylloc.first_column, + last_column: this.yylloc.last_column + }, + yytext: this.yytext, + match: this.match, + matches: this.matches, + matched: this.matched, + yyleng: this.yyleng, + offset: this.offset, + _more: this._more, + _input: this._input, + yy: this.yy, + conditionStack: this.conditionStack.slice(0), + done: this.done + }; + + if (this.options.ranges) { + backup.yylloc.range = this.yylloc.range.slice(0); + } + } + + lines = match[0].match(/(?:\r\n?|\n).*/g); + + if (lines) { + this.yylineno += lines.length; + } + + this.yylloc = { + first_line: this.yylloc.last_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.last_column, + last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length + }; + this.yytext += match[0]; + this.match += match[0]; + this.matches = match; + this.yyleng = this.yytext.length; + + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + + this._more = false; + this._backtrack = false; + this._input = this._input.slice(match[0].length); + this.matched += match[0]; + token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]); + + if (this.done && this._input) { + this.done = false; + } + + if (token) { + return token; + } else if (this._backtrack) { + // recover context + for (var k in backup) { + this[k] = backup[k]; + } + + return false; // rule action called reject() implying the next rule should be tested instead. + } + + return false; + }, + // return next match in input + next: function next() { + if (this.done) { + return this.EOF; + } + + if (!this._input) { + this.done = true; + } + + var token, match, tempMatch, index; + + if (!this._more) { + this.yytext = ''; + this.match = ''; + } + + var rules = this._currentRules(); + + for (var i = 0; i < rules.length; i++) { + tempMatch = this._input.match(this.rules[rules[i]]); + + if (tempMatch && (!match || tempMatch[0].length > match[0].length)) { + match = tempMatch; + index = i; + + if (this.options.backtrack_lexer) { + token = this.test_match(tempMatch, rules[i]); + + if (token !== false) { + return token; + } else if (this._backtrack) { + match = false; + continue; // rule action called reject() implying a rule MISmatch. + } else { + // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace) + return false; + } + } else if (!this.options.flex) { + break; + } + } + } + + if (match) { + token = this.test_match(match, rules[index]); + + if (token !== false) { + return token; + } // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace) + + + return false; + } + + if (this._input === "") { + return this.EOF; + } else { + return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + }, + // return next match that has a token + lex: function lex() { + var r = this.next(); + + if (r) { + return r; + } else { + return this.lex(); + } + }, + // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack) + begin: function begin(condition) { + this.conditionStack.push(condition); + }, + // pop the previously active lexer condition state off the condition stack + popState: function popState() { + var n = this.conditionStack.length - 1; + + if (n > 0) { + return this.conditionStack.pop(); + } else { + return this.conditionStack[0]; + } + }, + // produce the lexer rule set which is active for the currently active lexer condition state + _currentRules: function _currentRules() { + if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) { + return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; + } else { + return this.conditions["INITIAL"].rules; + } + }, + // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available + topState: function topState(n) { + n = this.conditionStack.length - 1 - Math.abs(n || 0); + + if (n >= 0) { + return this.conditionStack[n]; + } else { + return "INITIAL"; + } + }, + // alias for begin(condition) + pushState: function pushState(condition) { + this.begin(condition); + }, + // return the number of states currently on the stack + stateStackSize: function stateStackSize() { + return this.conditionStack.length; + }, + options: {}, + performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) { + + switch ($avoiding_name_collisions) { + case 0: + /* skip whitespace */ + break; + + case 1: + return 8; + + case 2: + return 8; + + case 3: + return 21; + + case 4: + return 35; + + case 5: + return 24; + + case 6: + return 26; + + case 7: + return 26; + + case 8: + return 25; + + case 9: + return 21; + + case 10: + return 31; + + case 11: + return 31; + + case 12: + return 33; + + case 13: + return 28; + + case 14: + return 9; + + case 15: + return ' '; + + case 16: + return 32; + + case 17: + return 27; + + case 18: + return 29; + + case 19: + return 30; + + case 20: + return 18; + + case 21: + return 19; + + case 22: + return 17; + + case 23: + return 11; + + case 24: + return 20; + + case 25: + return 12; + + case 26: + return 13; + + case 27: + return 15; + + case 28: + return 14; + + case 29: + return 16; + + case 30: + return '"'; + + case 31: + return "'"; + + case 32: + return "!"; + + case 33: + return 10; + + case 34: + return 34; + + case 35: + return '#'; + + case 36: + return 5; + } + }, + rules: [/^(?:\s+)/, /^(?:"(\\["]|[^"])*")/, /^(?:'(\\[']|[^'])*')/, /^(?:[A-Za-z]{1,}[A-Za-z_0-9\.]+(?=[(]))/, /^(?:#[A-Z0-9\/]+(!|\?)?)/, /^(?:\$[A-Za-z]+\$[0-9]+)/, /^(?:\$[A-Za-z]+[0-9]+)/, /^(?:[A-Za-z]+\$[0-9]+)/, /^(?:[A-Za-z]+[0-9]+)/, /^(?:[A-Za-z\.]+(?=[(]))/, /^(?:[A-Za-z]{1,}[A-Za-z_0-9]+)/, /^(?:[A-Za-z_]+)/, /^(?:[0-9]+)/, /^(?:\[(.*)?\])/, /^(?:&)/, /^(?: )/, /^(?:[.])/, /^(?::)/, /^(?:;)/, /^(?:,)/, /^(?:\*)/, /^(?:\/)/, /^(?:-)/, /^(?:\+)/, /^(?:\^)/, /^(?:\()/, /^(?:\))/, /^(?:>)/, /^(?:<)/, /^(?:NOT\b)/, /^(?:")/, /^(?:')/, /^(?:!)/, /^(?:=)/, /^(?:%)/, /^(?:[#])/, /^(?:$)/], + conditions: { + "INITIAL": { + "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36], + "inclusive": true + } + } + }; + return lexer; +}(); + +parser.lexer = lexer; + +function Parser() { + this.yy = {}; +} + +Parser.prototype = parser; +parser.Parser = Parser; +}); + +var string = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.trimEdges = trimEdges; + +/* eslint-disable import/prefer-default-export */ + +/** + * Trim value by cutting character starting from the beginning and ending at the same time. + * + * @param {String} string String to trimming. + * @param {Number} [margin=1] Number of character to cut. + * @returns {String} + */ +function trimEdges(string) { + var margin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1; + string = string.substring(margin, string.length - margin); + return string; +} +}); + +var cell = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.rowLabelToIndex = rowLabelToIndex; +exports.rowIndexToLabel = rowIndexToLabel; +exports.columnLabelToIndex = columnLabelToIndex; +exports.columnIndexToLabel = columnIndexToLabel; +exports.extractLabel = extractLabel; +exports.toLabel = toLabel; + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +/** + * Convert row label to index. + * + * @param {String} label Row label (eq. '1', '5') + * @returns {Number} Returns -1 if label is not recognized otherwise proper row index. + */ +function rowLabelToIndex(label) { + var result = parseInt(label, 10); + + if (isNaN(result)) { + result = -1; + } else { + result = Math.max(result - 1, -1); + } + + return result; +} +/** + * Convert row index to label. + * + * @param {Number} row Row index. + * @returns {String} Returns row label (eq. '1', '7'). + */ + + +function rowIndexToLabel(row) { + var result = ''; + + if (row >= 0) { + result = "".concat(row + 1); + } + + return result; +} + +var COLUMN_LABEL_BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; +var COLUMN_LABEL_BASE_LENGTH = COLUMN_LABEL_BASE.length; +/** + * Convert column label to index. + * + * @param {String} label Column label (eq. 'ABB', 'CNQ') + * @returns {Number} Returns -1 if label is not recognized otherwise proper column index. + */ + +function columnLabelToIndex(label) { + var result = 0; + + if (typeof label === 'string') { + label = label.toUpperCase(); + + for (var i = 0, j = label.length - 1; i < label.length; i += 1, j -= 1) { + result += Math.pow(COLUMN_LABEL_BASE_LENGTH, j) * (COLUMN_LABEL_BASE.indexOf(label[i]) + 1); + } + } + + --result; + return result; +} +/** + * Convert column index to label. + * + * @param {Number} column Column index. + * @returns {String} Returns column label (eq. 'ABB', 'CNQ'). + */ + + +function columnIndexToLabel(column) { + var result = ''; + + while (column >= 0) { + result = String.fromCharCode(column % COLUMN_LABEL_BASE_LENGTH + 97) + result; + column = Math.floor(column / COLUMN_LABEL_BASE_LENGTH) - 1; + } + + return result.toUpperCase(); +} + +var LABEL_EXTRACT_REGEXP = /^([$])?([A-Za-z]+)([$])?([0-9]+)$/; +/** + * Extract cell coordinates. + * + * @param {String} label Cell coordinates (eq. 'A1', '$B6', '$N$98'). + * @returns {Array} Returns an array of objects. + */ + +function extractLabel(label) { + if (typeof label !== 'string' || !LABEL_EXTRACT_REGEXP.test(label)) { + return []; + } + + var _label$toUpperCase$ma = label.toUpperCase().match(LABEL_EXTRACT_REGEXP), + _label$toUpperCase$ma2 = _slicedToArray(_label$toUpperCase$ma, 5), + columnAbs = _label$toUpperCase$ma2[1], + column = _label$toUpperCase$ma2[2], + rowAbs = _label$toUpperCase$ma2[3], + row = _label$toUpperCase$ma2[4]; + + return [{ + index: rowLabelToIndex(row), + label: row, + isAbsolute: rowAbs === '$' + }, { + index: columnLabelToIndex(column), + label: column, + isAbsolute: columnAbs === '$' + }]; +} +/** + * Convert row and column indexes into cell label. + * + * @param {Object} row Object with `index` and `isAbsolute` properties. + * @param {Object} column Object with `index` and `isAbsolute` properties. + * @returns {String} Returns cell label. + */ + + +function toLabel(row, column) { + var rowLabel = (row.isAbsolute ? '$' : '') + rowIndexToLabel(row.index); + var columnLabel = (column.isAbsolute ? '$' : '') + columnIndexToLabel(column.index); + return columnLabel + rowLabel; +} +}); + +var parser = createCommonjsModule(function (module, exports) { + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +exports.__esModule = true; +exports["default"] = void 0; + +var _tinyEmitter = _interopRequireDefault(tinyEmitter); + +var _evaluateByOperator = _interopRequireDefault(evaluateByOperator_1); + + + + + + + +var _error = _interopRequireWildcard(error_1); + + + +function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +/** + * @class Parser + */ +var Parser = /*#__PURE__*/function (_Emitter) { + _inherits(Parser, _Emitter); + + var _super = _createSuper(Parser); + + function Parser() { + var _this; + + _classCallCheck(this, Parser); + + _this = _super.call(this); + _this.parser = new grammarParser.Parser(); + _this.parser.yy = { + toNumber: number.toNumber, + trimEdges: string.trimEdges, + invertNumber: number.invertNumber, + throwError: function throwError(errorName) { + return _this._throwError(errorName); + }, + callVariable: function callVariable(variable) { + return _this._callVariable(variable); + }, + evaluateByOperator: _evaluateByOperator["default"], + callFunction: function callFunction(name, params) { + return _this._callFunction(name, params); + }, + cellValue: function cellValue(value) { + return _this._callCellValue(value); + }, + rangeValue: function rangeValue(start, end) { + return _this._callRangeValue(start, end); + } + }; + _this.variables = Object.create(null); + _this.functions = Object.create(null); + + _this.setVariable('TRUE', true).setVariable('FALSE', false).setVariable('NULL', null); + + return _this; + } + /** + * Parse formula expression. + * + * @param {String} expression to parse. + * @return {*} Returns an object with tow properties `error` and `result`. + */ + + + _createClass(Parser, [{ + key: "parse", + value: function parse(expression) { + var result = null; + var error = null; + + try { + if (expression === '') { + result = ''; + } else { + result = this.parser.parse(expression); + } + } catch (ex) { + var message = (0, _error["default"])(ex.message); + + if (message) { + error = message; + } else { + error = (0, _error["default"])(_error.ERROR); + } + } + + if (result instanceof Error) { + error = (0, _error["default"])(result.message) || (0, _error["default"])(_error.ERROR); + result = null; + } + + return { + error: error, + result: result + }; + } + /** + * Set predefined variable name which can be visible while parsing formula expression. + * + * @param {String} name Variable name. + * @param {*} value Variable value. + * @returns {Parser} + */ + + }, { + key: "setVariable", + value: function setVariable(name, value) { + this.variables[name] = value; + return this; + } + /** + * Get variable name. + * + * @param {String} name Variable name. + * @returns {*} + */ + + }, { + key: "getVariable", + value: function getVariable(name) { + return this.variables[name]; + } + /** + * Retrieve variable value by its name. + * + * @param name Variable name. + * @returns {*} + * @private + */ + + }, { + key: "_callVariable", + value: function _callVariable(name) { + var value = this.getVariable(name); + this.emit('callVariable', name, function (newValue) { + if (newValue !== void 0) { + value = newValue; + } + }); + + if (value === void 0) { + throw Error(_error.ERROR_NAME); + } + + return value; + } + /** + * Set custom function which can be visible while parsing formula expression. + * + * @param {String} name Custom function name. + * @param {Function} fn Custom function. + * @returns {Parser} + */ + + }, { + key: "setFunction", + value: function setFunction(name, fn) { + this.functions[name] = fn; + return this; + } + /** + * Get custom function. + * + * @param {String} name Custom function name. + * @returns {*} + */ + + }, { + key: "getFunction", + value: function getFunction(name) { + return this.functions[name]; + } + /** + * Call function with provided params. + * + * @param name Function name. + * @param params Function params. + * @returns {*} + * @private + */ + + }, { + key: "_callFunction", + value: function _callFunction(name) { + var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + var fn = this.getFunction(name); + var value; + + if (fn) { + value = fn(params); + } + + this.emit('callFunction', name, params, function (newValue) { + if (newValue !== void 0) { + value = newValue; + } + }); + return value === void 0 ? (0, _evaluateByOperator["default"])(name, params) : value; + } + /** + * Retrieve value by its label (`B3`, `B$3`, `B$3`, `$B$3`). + * + * @param {String} label Coordinates. + * @returns {*} + * @private + */ + + }, { + key: "_callCellValue", + value: function _callCellValue(label) { + label = label.toUpperCase(); + + var _extractLabel = (0, cell.extractLabel)(label), + _extractLabel2 = _slicedToArray(_extractLabel, 2), + row = _extractLabel2[0], + column = _extractLabel2[1]; + + var value = void 0; + this.emit('callCellValue', { + label: label, + row: row, + column: column + }, function (_value) { + value = _value; + }); + return value; + } + /** + * Retrieve value by its label (`B3:A1`, `B$3:A1`, `B$3:$A1`, `$B$3:A$1`). + * + * @param {String} startLabel Coordinates of the first cell. + * @param {String} endLabel Coordinates of the last cell. + * @returns {Array} Returns an array of mixed values. + * @private + */ + + }, { + key: "_callRangeValue", + value: function _callRangeValue(startLabel, endLabel) { + startLabel = startLabel.toUpperCase(); + endLabel = endLabel.toUpperCase(); + + var _extractLabel3 = (0, cell.extractLabel)(startLabel), + _extractLabel4 = _slicedToArray(_extractLabel3, 2), + startRow = _extractLabel4[0], + startColumn = _extractLabel4[1]; + + var _extractLabel5 = (0, cell.extractLabel)(endLabel), + _extractLabel6 = _slicedToArray(_extractLabel5, 2), + endRow = _extractLabel6[0], + endColumn = _extractLabel6[1]; + + var startCell = {}; + var endCell = {}; + + if (startRow.index <= endRow.index) { + startCell.row = startRow; + endCell.row = endRow; + } else { + startCell.row = endRow; + endCell.row = startRow; + } + + if (startColumn.index <= endColumn.index) { + startCell.column = startColumn; + endCell.column = endColumn; + } else { + startCell.column = endColumn; + endCell.column = startColumn; + } + + startCell.label = (0, cell.toLabel)(startCell.row, startCell.column); + endCell.label = (0, cell.toLabel)(endCell.row, endCell.column); + var value = []; + this.emit('callRangeValue', startCell, endCell, function () { + var _value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + + value = _value; + }); + return value; + } + /** + * Try to throw error by its name. + * + * @param {String} errorName Error name. + * @returns {String} + * @private + */ + + }, { + key: "_throwError", + value: function _throwError(errorName) { + if ((0, _error.isValidStrict)(errorName)) { + throw Error(errorName); + } + + throw Error(_error.ERROR); + } + }]); + + return Parser; +}(_tinyEmitter["default"]); + +var _default = Parser; +exports["default"] = _default; +}); + +var hotFormulaParser = createCommonjsModule(function (module, exports) { + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +exports.__esModule = true; + +var _parser = _interopRequireDefault(parser); + +exports.Parser = _parser["default"]; + +var _supportedFormulas = _interopRequireDefault(supportedFormulas); + +exports.SUPPORTED_FORMULAS = _supportedFormulas["default"]; + +var _error = _interopRequireWildcard(error_1); + +exports.error = _error["default"]; +exports.ERROR = _error.ERROR; +exports.ERROR_DIV_ZERO = _error.ERROR_DIV_ZERO; +exports.ERROR_NAME = _error.ERROR_NAME; +exports.ERROR_NOT_AVAILABLE = _error.ERROR_NOT_AVAILABLE; +exports.ERROR_NULL = _error.ERROR_NULL; +exports.ERROR_NUM = _error.ERROR_NUM; +exports.ERROR_REF = _error.ERROR_REF; +exports.ERROR_VALUE = _error.ERROR_VALUE; + + + +exports.extractLabel = cell.extractLabel; +exports.toLabel = cell.toLabel; +exports.columnIndexToLabel = cell.columnIndexToLabel; +exports.columnLabelToIndex = cell.columnLabelToIndex; +exports.rowIndexToLabel = cell.rowIndexToLabel; +exports.rowLabelToIndex = cell.rowLabelToIndex; + +function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } +}); + +function _classCallCheck$2n(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2h(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); } } + +function _createClass$2h(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2h(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2h(Constructor, staticProps); return Constructor; } +/** + * @class BaseCell + * @util + */ + +var BaseCell = /*#__PURE__*/function () { + function BaseCell(row, column) { + _classCallCheck$2n(this, BaseCell); + + var rowObject = isObject$1(row); + var columnObject = isObject$1(column); + this._row = rowObject ? row.index : row; + this.rowAbsolute = rowObject ? row.isAbsolute : true; + this._column = columnObject ? column.index : column; + this.columnAbsolute = columnObject ? column.isAbsolute : true; + this.rowOffset = 0; + this.columnOffset = 0; // TODO: Change syntax to es6 after upgrade tests to newer version of phantom and jasmine. + + Object.defineProperty(this, 'row', { + get: function get() { + return this.rowOffset + this._row; + }, + set: function set(rowIndex) { + this._row = rowIndex; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(this, 'column', { + get: function get() { + return this.columnOffset + this._column; + }, + set: function set(columnIndex) { + this._column = columnIndex; + }, + enumerable: true, + configurable: true + }); + } + /** + * Translate cell coordinates. + * + * @param {number} rowOffset Row offset to move. + * @param {number} columnOffset Column offset to move. + */ + + + _createClass$2h(BaseCell, [{ + key: "translateTo", + value: function translateTo(rowOffset, columnOffset) { + this.row = this.row + rowOffset; + this.column = this.column + columnOffset; + } + /** + * Check if cell is equal to provided one. + * + * @param {BaseCell} cell Cell object. + * @returns {boolean} + */ + + }, { + key: "isEqual", + value: function isEqual(cell) { + return cell.row === this.row && cell.column === this.column; + } + /** + * Stringify object. + * + * @returns {string} + */ + + }, { + key: "toString", + value: function toString() { + return hotFormulaParser.toLabel({ + index: this.row, + isAbsolute: this.rowAbsolute + }, { + index: this.column, + isAbsolute: this.columnAbsolute + }); + } + }]); + + return BaseCell; +}(); + +function _typeof$1p(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1p = function _typeof(obj) { return typeof obj; }; } else { _typeof$1p = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1p(obj); } + +function _classCallCheck$2o(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2i(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); } } + +function _createClass$2i(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2i(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2i(Constructor, staticProps); return Constructor; } + +function _inherits$1d(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1e(subClass, superClass); } + +function _setPrototypeOf$1e(o, p) { _setPrototypeOf$1e = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1e(o, p); } + +function _createSuper$1d(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1e(); return function _createSuperInternal() { var Super = _getPrototypeOf$1d(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1d(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1d(this, result); }; } + +function _possibleConstructorReturn$1d(self, call) { if (call && (_typeof$1p(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1d(self); } + +function _assertThisInitialized$1d(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1e() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1d(o) { _getPrototypeOf$1d = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1d(o); } +var STATE_OUT_OFF_DATE = 1; +var STATE_COMPUTING = 2; +var STATE_UP_TO_DATE = 3; +var states = [STATE_OUT_OFF_DATE, STATE_COMPUTING, STATE_UP_TO_DATE]; +/** + * Class responsible for wrapping formula expression. It contains calculated value of + * the formula, an error if it has happened and cell references which indicates a relationship with regular + * cells. This object uses physical cell coordinates. + * + * @class CellValue + * @util + */ + +var CellValue = /*#__PURE__*/function (_BaseCell) { + _inherits$1d(CellValue, _BaseCell); + + var _super = _createSuper$1d(CellValue); + + function CellValue(row, column) { + var _this; + + _classCallCheck$2o(this, CellValue); + + _this = _super.call(this, row, column); + /** + * List of precedents cells. + * + * @type {Array} + */ + + _this.precedents = []; + /** + * Computed value. + * + * @type {*} + */ + + _this.value = null; + /** + * Error name. + * + * @type {string|null} + */ + + _this.error = null; + /** + * Indicates cell state. + * + * @type {string} + */ + + _this.state = CellValue.STATE_UP_TO_DATE; + return _this; + } + /** + * Set computed value. + * + * @param {*} value The calculated formula value. + */ + + + _createClass$2i(CellValue, [{ + key: "setValue", + value: function setValue(value) { + this.value = value; + } + /** + * Get computed value. + * + * @returns {*} + */ + + }, { + key: "getValue", + value: function getValue() { + return this.value; + } + /** + * Set error message for this cell. + * + * @param {string} error Error name. + */ + + }, { + key: "setError", + value: function setError(error) { + this.error = error; + } + /** + * Get error name for this cell. + * + * @returns {string|null} + */ + + }, { + key: "getError", + value: function getError() { + return this.error; + } + /** + * Check if cell value is marked as error. + * + * @returns {boolean} + */ + + }, { + key: "hasError", + value: function hasError() { + return this.error !== null; + } + /** + * Set cell state. + * + * @param {number} state Cell state. + */ + + }, { + key: "setState", + value: function setState(state) { + if (states.indexOf(state) === -1) { + throw Error("Unrecognized state: ".concat(state)); + } + + this.state = state; + } + /** + * Check cell state. + * + * @param {number} state The state to compare with. + * @returns {boolean} + */ + + }, { + key: "isState", + value: function isState(state) { + return this.state === state; + } + /** + * Add precedent cell to the collection. + * + * @param {CellReference} cellReference Cell reference object. + */ + + }, { + key: "addPrecedent", + value: function addPrecedent(cellReference) { + if (this.isEqual(cellReference)) { + throw Error(hotFormulaParser.ERROR_REF); + } + + if (!this.hasPrecedent(cellReference)) { + this.precedents.push(cellReference); + } + } + /** + * Remove precedent cell from the collection. + * + * @param {CellReference} cellReference Cell reference object. + */ + + }, { + key: "removePrecedent", + value: function removePrecedent(cellReference) { + if (this.isEqual(cellReference)) { + throw Error(hotFormulaParser.ERROR_REF); + } + + this.precedents = arrayFilter(this.precedents, function (cell) { + return !cell.isEqual(cellReference); + }); + } + /** + * Clear all precedent cells. + */ + + }, { + key: "clearPrecedents", + value: function clearPrecedents() { + this.precedents.length = 0; + } + /** + * Get precedent cells. + * + * @returns {Array} + */ + + }, { + key: "getPrecedents", + value: function getPrecedents() { + return this.precedents; + } + /** + * Check if cell value has precedents cells. + * + * @returns {boolean} + */ + + }, { + key: "hasPrecedents", + value: function hasPrecedents() { + return this.precedents.length > 0; + } + /** + * Check if cell reference is precedents this cell. + * + * @param {CellReference} cellReference Cell reference object. + * @returns {boolean} + */ + + }, { + key: "hasPrecedent", + value: function hasPrecedent(cellReference) { + return arrayFilter(this.precedents, function (cell) { + return cell.isEqual(cellReference); + }).length > 0; + } + }], [{ + key: "STATE_OUT_OFF_DATE", + get: + /** + * Out of date state indicates cells ready for recomputing. + * + * @returns {number} + */ + function get() { + return 1; // PhantomJS crashes when we want to use constant above + } + /** + * Computing state indicates cells under processing. + * + * @returns {number} + */ + + }, { + key: "STATE_COMPUTING", + get: function get() { + return 2; // PhantomJS crashes when we want to use constant above + } + /** + * Up to date state indicates cells with fresh computed value. + * + * @returns {number} + */ + + }, { + key: "STATE_UP_TO_DATE", + get: function get() { + return 3; // PhantomJS crashes when we want to use constant above + } + }]); + + return CellValue; +}(BaseCell); + +function _typeof$1q(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1q = function _typeof(obj) { return typeof obj; }; } else { _typeof$1q = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1q(obj); } + +function _classCallCheck$2p(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2j(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); } } + +function _createClass$2j(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2j(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2j(Constructor, staticProps); return Constructor; } + +function _inherits$1e(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1f(subClass, superClass); } + +function _setPrototypeOf$1f(o, p) { _setPrototypeOf$1f = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1f(o, p); } + +function _createSuper$1e(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1f(); return function _createSuperInternal() { var Super = _getPrototypeOf$1e(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1e(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1e(this, result); }; } + +function _possibleConstructorReturn$1e(self, call) { if (call && (_typeof$1q(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1e(self); } + +function _assertThisInitialized$1e(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1f() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1e(o) { _getPrototypeOf$1e = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1e(o); } +/** + * Class which indicates formula expression precedents cells at specified cell + * coordinates (CellValue). This object uses visual cell coordinates. + * + * @class CellReference + * @util + */ + +var CellReference = /*#__PURE__*/function (_BaseCell) { + _inherits$1e(CellReference, _BaseCell); + + var _super = _createSuper$1e(CellReference); + + function CellReference() { + _classCallCheck$2p(this, CellReference); + + return _super.apply(this, arguments); + } + + _createClass$2j(CellReference, [{ + key: "toString", + value: + /** + * Stringify object. + * + * @returns {string} + */ + function toString() { + return hotFormulaParser.toLabel({ + index: this.row, + isAbsolute: false + }, { + index: this.column, + isAbsolute: false + }); + } + }]); + + return CellReference; +}(BaseCell); + +function _classCallCheck$2q(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2k(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); } } + +function _createClass$2k(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2k(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2k(Constructor, staticProps); return Constructor; } +/** + * This component is responsible for storing all calculated cells which contain formula expressions (CellValue) and + * register for all cell references (CellReference). + * + * CellValue is an object which represents a formula expression. It contains a calculated value of that formula, + * an error if applied and cell references. Cell references are CellReference object instances which represent a cell + * in a spreadsheet. One CellReference can be assigned to multiple CellValues as a precedent cell. Each cell + * modification triggers a search through CellValues that are dependent of the CellReference. After + * the match, the cells are marked as 'out of date'. In the next render cycle, all CellValues marked with + * that state are recalculated. + * + * @class Matrix + * @util + */ + +var Matrix = /*#__PURE__*/function () { + function Matrix(hot) { + _classCallCheck$2q(this, Matrix); + + /** + * Handsontable instance. + * + * @type {Core} + */ + this.hot = hot; + /** + * List of all cell values with theirs precedents. + * + * @type {Array} + */ + + this.data = []; + /** + * List of all created and registered cell references. + * + * @type {Array} + */ + + this.cellReferences = []; + } + /** + * Get cell value at given row and column index. + * + * @param {number} row Physical row index. + * @param {number} column Physical column index. + * @returns {CellValue|null} Returns CellValue instance or `null` if cell not found. + */ + + + _createClass$2k(Matrix, [{ + key: "getCellAt", + value: function getCellAt(row, column) { + var result = null; + arrayEach(this.data, function (cell) { + if (cell.row === row && cell.column === column) { + result = cell; + return false; + } + }); + return result; + } + /** + * Get all out of date cells. + * + * @returns {Array} + */ + + }, { + key: "getOutOfDateCells", + value: function getOutOfDateCells() { + return arrayFilter(this.data, function (cell) { + return cell.isState(CellValue.STATE_OUT_OFF_DATE); + }); + } + /** + * Add cell value to the collection. + * + * @param {CellValue|object} cellValue Cell value object. + */ + + }, { + key: "add", + value: function add(cellValue) { + if (!arrayFilter(this.data, function (cell) { + return cell.isEqual(cellValue); + }).length) { + this.data.push(cellValue); + } + } + /** + * Remove cell value from the collection. + * + * @param {CellValue|object|Array} cellValue Cell value object. + */ + + }, { + key: "remove", + value: function remove(cellValue) { + var isArray = Array.isArray(cellValue); + + var isEqual = function isEqual(cell, values) { + var result = false; + + if (isArray) { + arrayEach(values, function (value) { + if (cell.isEqual(value)) { + result = true; + return false; + } + }); + } else { + result = cell.isEqual(values); + } + + return result; + }; + + this.data = arrayFilter(this.data, function (cell) { + return !isEqual(cell, cellValue); + }); + } + /** + * Get cell dependencies using visual coordinates. + * + * @param {object} cellCoord Visual cell coordinates object. + * @returns {Array} + */ + + }, { + key: "getDependencies", + value: function getDependencies(cellCoord) { + var _this = this; + + /* eslint-disable arrow-body-style */ + var getDependencies = function getDependencies(cell) { + return arrayReduce(_this.data, function (acc, cellValue) { + if (cellValue.hasPrecedent(cell) && acc.indexOf(cellValue) === -1) { + acc.push(cellValue); + } + + return acc; + }, []); + }; + + var getTotalDependencies = function getTotalDependencies(cell) { + var deps = getDependencies(cell); + + if (deps.length) { + arrayEach(deps, function (cellValue) { + if (cellValue.hasPrecedents()) { + deps = deps.concat(getTotalDependencies({ + row: _this.hot.toVisualRow(cellValue.row), + column: _this.hot.toVisualColumn(cellValue.column) + })); + } + }); + } + + return deps; + }; + + return getTotalDependencies(cellCoord); + } + /** + * Register cell reference to the collection. + * + * @param {CellReference|object} cellReference Cell reference object. + */ + + }, { + key: "registerCellRef", + value: function registerCellRef(cellReference) { + if (!arrayFilter(this.cellReferences, function (cell) { + return cell.isEqual(cellReference); + }).length) { + this.cellReferences.push(cellReference); + } + } + /** + * Remove cell references from the collection. + * + * @param {object} start Start visual coordinate. + * @param {object} end End visual coordinate. + * @returns {Array} Returns removed cell references. + */ + + }, { + key: "removeCellRefsAtRange", + value: function removeCellRefsAtRange(_ref, _ref2) { + var startRow = _ref.row, + startColumn = _ref.column; + var endRow = _ref2.row, + endColumn = _ref2.column; + var removed = []; + + var rowMatch = function rowMatch(cell) { + return startRow === void 0 ? true : cell.row >= startRow && cell.row <= endRow; + }; + + var colMatch = function colMatch(cell) { + return startColumn === void 0 ? true : cell.column >= startColumn && cell.column <= endColumn; + }; + + this.cellReferences = arrayFilter(this.cellReferences, function (cell) { + if (rowMatch(cell) && colMatch(cell)) { + removed.push(cell); + return false; + } + + return true; + }); + return removed; + } + /** + * Reset matrix data. + */ + + }, { + key: "reset", + value: function reset() { + this.data.length = 0; + this.cellReferences.length = 0; + } + }]); + + return Matrix; +}(); + +function _slicedToArray$I(arr, i) { return _arrayWithHoles$K(arr) || _iterableToArrayLimit$I(arr, i) || _unsupportedIterableToArray$_(arr, i) || _nonIterableRest$K(); } + +function _nonIterableRest$K() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$_(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$_(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$_(o, minLen); } + +function _arrayLikeToArray$_(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$I(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$K(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$2r(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2l(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); } } + +function _createClass$2l(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2l(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2l(Constructor, staticProps); return Constructor; } +var BARE_CELL_STRICT_REGEX = /^\$?[A-Z]+\$?\d+$/; +var BARE_CELL_REGEX = /\$?[A-Z]+\$?\d+/; +var CELL_REGEX = /(?:[^0-9A-Z$: ]|^)\s*(\$?[A-Z]+\$?\d+)\s*(?![0-9A-Z_: ])/g; +var RANGE_REGEX = /\$?[A-Z]+\$?\d+\s*:\s*\$?[A-Z]+\$?\d+/g; +var CELL_AND_RANGE_REGEX = /((?:[^0-9A-Z$: ]|^)\s*(\$?[A-Z]+\$?\d+)\s*(?![0-9A-Z_: ]))|(\$?[A-Z]+\$?\d+\s*:\s*\$?[A-Z]+\$?\d+)/g; // eslint-disable-line max-len + +/** + * Component adds an ability to parse and modify formula expressions. It is designed for translating cell + * coordinates and cell ranges in any direction. By default, component translates only relative coordinates but this + * behavior can be overwritten by passing custom modifier which controls translating process. + * + * @class ExpressionModifier + * @util + */ + +var ExpressionModifier = /*#__PURE__*/function () { + function ExpressionModifier(expression) { + _classCallCheck$2r(this, ExpressionModifier); + + /** + * Formula expression to modify. + * + * @type {string} + */ + this.expression = ''; + /** + * Extracted cells and cells ranges. + * + * @type {Array} + */ + + this.cells = []; + /** + * Function which can modify default behaviour of how cells and cell ranges will be translated. + * + * @type {null|Function} + */ + + this.customModifier = null; + + if (typeof expression === 'string') { + this.setExpression(expression); + } + } + /** + * Set formula expression to modify. + * + * @param {string} expression Formula expression to process. + * @returns {ExpressionModifier} + */ + + + _createClass$2l(ExpressionModifier, [{ + key: "setExpression", + value: function setExpression(expression) { + this.cells.length = 0; + this.expression = toUpperCaseFormula(expression); + + this._extractCells(); + + this._extractCellsRange(); + + return this; + } + /** + * Set function which can modify default behavior of how cells and cell ranges will be translated. + * The passed function will be called with 4 arguments: + * - cell, A cell object with structure + * like this: {start: {row, column}, end: {row, column}, origLabel, type: 'cell|range', refError, toLabel: () => {}} + * - axis, Type of currently processing axis ('row' or 'column') + * - delta, Number as distance to translate. Can be positive or negative. + * - startFromIndex, Base index which translation will be applied from. + * + * The function must return an array with 3 items, where: + * [ + * deltaStart, Number as a delta to translate first part of coordinates. + * DeltaEnd, Number as a delta to translate second part of coordinates (if cell range is modified). + * RefError, Defines an error which refers to the situation when translated cell overcrossed the data boundary. + * ]. + * + * + * @param {Function} customModifier Function with custom logic. + */ + + }, { + key: "useCustomModifier", + value: function useCustomModifier(customModifier) { + this.customModifier = customModifier; + } + /** + * Translate formula expression cells. + * + * @param {object} delta Distance to move in proper direction. + * @param {object} [startFrom] Coordinates which translation will be applied from. + * @returns {ExpressionModifier} + */ + + }, { + key: "translate", + value: function translate(_ref) { + var _this = this; + + var deltaRow = _ref.row, + deltaColumn = _ref.column; + var startFrom = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + arrayEach(this.cells, function (cell) { + if (deltaRow !== null && deltaRow !== void 0) { + _this._translateCell(cell, 'row', deltaRow, startFrom.row); + } + + if (deltaColumn !== null && deltaColumn !== void 0) { + _this._translateCell(cell, 'column', deltaColumn, startFrom.column); + } + }); + return this; + } + /** + * Translate object into string representation. + * + * @returns {string} + */ + + }, { + key: "toString", + value: function toString() { + var _this2 = this; + + var expression = this.expression.replace(CELL_AND_RANGE_REGEX, function (match, p1, p2) { + var isSingleCell = match.indexOf(':') === -1; + var result = match; + var cellLabel = match; + var translatedCellLabel = null; + + if (isSingleCell) { + cellLabel = BARE_CELL_STRICT_REGEX.test(p1) ? p1 : p2; + } + + var cell = _this2._searchCell(cellLabel); + + if (cell) { + translatedCellLabel = cell.refError ? hotFormulaParser.error(hotFormulaParser.ERROR_REF) : cell.toLabel(); + + if (isSingleCell) { + result = match.replace(cellLabel, translatedCellLabel); + } else { + result = translatedCellLabel; + } + } + + return result; + }); + + if (!expression.startsWith('=')) { + expression = "=".concat(expression); + } + + return expression; + } + /** + * Translate single cell. + * + * @param {object} cell Cell object. + * @param {string} axis Axis to modify. + * @param {number} delta Distance to move. + * @param {number} [startFromIndex] Base index which translation will be applied from. + * @private + */ + + }, { + key: "_translateCell", + value: function _translateCell(cell, axis, delta, startFromIndex) { + var start = cell.start, + end = cell.end; + var startIndex = start[axis].index; + var endIndex = end[axis].index; + var deltaStart = delta; + var deltaEnd = delta; + var refError = false; + + if (this.customModifier) { + var _this$customModifier = this.customModifier(cell, axis, delta, startFromIndex); + + var _this$customModifier2 = _slicedToArray$I(_this$customModifier, 3); + + deltaStart = _this$customModifier2[0]; + deltaEnd = _this$customModifier2[1]; + refError = _this$customModifier2[2]; + } else { + // By default only relative cells are translated, if meets absolute reset deltas to 0 + if (start[axis].isAbsolute) { + deltaStart = 0; + } + + if (end[axis].isAbsolute) { + deltaEnd = 0; + } + } + + if (deltaStart && !refError) { + if (startIndex + deltaStart < 0) { + refError = true; + } + + start[axis].index = Math.max(startIndex + deltaStart, 0); + } + + if (deltaEnd && !refError) { + if (endIndex + deltaEnd < 0) { + refError = true; + } + + end[axis].index = Math.max(endIndex + deltaEnd, 0); + } + + if (refError) { + cell.refError = true; + } + } + /** + * Extract all cells from the formula expression. + * + * @private + */ + + }, { + key: "_extractCells", + value: function _extractCells() { + var _this3 = this; + + var matches = this.expression.match(CELL_REGEX); + + if (!matches) { + return; + } + + arrayEach(matches, function (coord) { + var cellCoords = coord.match(BARE_CELL_REGEX); + + if (!cellCoords) { + return; + } + + var _extractLabel = hotFormulaParser.extractLabel(cellCoords[0]), + _extractLabel2 = _slicedToArray$I(_extractLabel, 2), + row = _extractLabel2[0], + column = _extractLabel2[1]; + + _this3.cells.push(_this3._createCell({ + row: row, + column: column + }, { + row: row, + column: column + }, cellCoords[0])); + }); + } + /** + * Extract all cells range from the formula expression. + * + * @private + */ + + }, { + key: "_extractCellsRange", + value: function _extractCellsRange() { + var _this4 = this; + + var matches = this.expression.match(RANGE_REGEX); + + if (!matches) { + return; + } + + arrayEach(matches, function (match) { + var _match$split = match.split(':'), + _match$split2 = _slicedToArray$I(_match$split, 2), + start = _match$split2[0], + end = _match$split2[1]; + + var _extractLabel3 = hotFormulaParser.extractLabel(start), + _extractLabel4 = _slicedToArray$I(_extractLabel3, 2), + startRow = _extractLabel4[0], + startColumn = _extractLabel4[1]; + + var _extractLabel5 = hotFormulaParser.extractLabel(end), + _extractLabel6 = _slicedToArray$I(_extractLabel5, 2), + endRow = _extractLabel6[0], + endColumn = _extractLabel6[1]; + + var startCell = { + row: startRow, + column: startColumn + }; + var endCell = { + row: endRow, + column: endColumn + }; + + _this4.cells.push(_this4._createCell(startCell, endCell, match)); + }); + } + /** + * Search cell by its label. + * + * @param {string} label Cell label eq. `B4` or `$B$6`. + * @returns {object|null} + * @private + */ + + }, { + key: "_searchCell", + value: function _searchCell(label) { + var _arrayFilter = arrayFilter(this.cells, function (cellMeta) { + return cellMeta.origLabel === label; + }), + _arrayFilter2 = _slicedToArray$I(_arrayFilter, 1), + cell = _arrayFilter2[0]; + + return cell || null; + } + /** + * Create object cell. + * + * @param {object} start Start coordinates (top-left). + * @param {object} end End coordinates (bottom-right). + * @param {string} label Original label name. + * @returns {object} + * @private + */ + + }, { + key: "_createCell", + value: function _createCell(start, end, label) { + return { + start: start, + end: end, + origLabel: label, + type: label.indexOf(':') === -1 ? 'cell' : 'range', + refError: false, + toLabel: function toLabel() { + var newLabel = hotFormulaParser.toLabel(this.start.row, this.start.column); + + if (this.type === 'range') { + newLabel += ":".concat(hotFormulaParser.toLabel(this.end.row, this.end.column)); + } + + return newLabel; + } + }; + } + }]); + + return ExpressionModifier; +}(); + +mixin(ExpressionModifier, localHooks); + +/** + * When "column_sorting" is triggered the following operations must be performed: + * + * - All formulas which contain cell coordinates must be updated and saved into source data - Column must be changed + * (decreased or increased) depends on new target position - previous position. + * - Mark all formulas which need update with "STATE_OUT_OFF_DATE" flag, so they can be recalculated after the operation. + */ + +var OPERATION_NAME = 'column_sorting'; +var visualRows; +/** + * Collect all previous visual rows from CellValues. + */ + +function prepare() { + var matrix = this.matrix, + hot = this.hot; + visualRows = new WeakMap(); + arrayEach(matrix.data, function (cell) { + visualRows.set(cell, hot.toVisualRow(cell.row)); + }); +} +/** + * Translate all CellValues depends on previous position. + */ + +function operate() { + var matrix = this.matrix, + dataProvider = this.dataProvider, + hot = this.hot; + matrix.cellReferences.length = 0; + arrayEach(matrix.data, function (cell) { + cell.setState(CellValue.STATE_OUT_OFF_DATE); + cell.clearPrecedents(); + var row = cell.row, + column = cell.column; + var value = dataProvider.getSourceDataAtCell(row, column); + + if (isFormulaExpression(value)) { + var prevRow = visualRows.get(cell); + var expModifier = new ExpressionModifier(value); + expModifier.translate({ + row: hot.toVisualRow(row) - prevRow + }); + dataProvider.updateSourceData(row, column, expModifier.toString()); + } + }); + visualRows = null; +} + +var columnSorting = /*#__PURE__*/Object.freeze({ + __proto__: null, + OPERATION_NAME: OPERATION_NAME, + prepare: prepare, + operate: operate +}); + +/** + * When "inser_column" is triggered the following operations must be performed: + * + * - All formulas which contain cell coordinates must be updated and saved into source data - Column must be increased + * by "amount" of times (eq: D4 to E4, $F$5 to $G$5); + * - Mark all formulas which need update with "STATE_OUT_OFF_DATE" flag, so they can be recalculated after the operation. + */ + +var OPERATION_NAME$1 = 'insert_column'; +/** + * Execute changes. + * + * @param {number} start Index column from which the operation starts. + * @param {number} amount Count of columns to be inserted. + * @param {boolean} [modifyFormula=true] If `true` all formula expressions will be modified according to the changes. + * `false` value is used by UndoRedo plugin which saves snapshoots before alter + * operation so it doesn't have to modify formulas if "undo" action was triggered. + */ + +function operate$1(start, amount) { + var modifyFormula = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var matrix = this.matrix, + dataProvider = this.dataProvider; + var translate = [0, amount]; + arrayEach(matrix.cellReferences, function (cell) { + if (cell.column >= start) { + cell.translateTo.apply(cell, translate); + } + }); + arrayEach(matrix.data, function (cell) { + var origRow = cell.row, + origColumn = cell.column; + + if (cell.column >= start) { + cell.translateTo.apply(cell, translate); + cell.setState(CellValue.STATE_OUT_OFF_DATE); + } + + if (modifyFormula) { + var row = cell.row, + column = cell.column; + var value = dataProvider.getSourceDataAtCell(row, column); + + if (isFormulaExpression(value)) { + var startCoord = cellCoordFactory('column', start); + var expModifier = new ExpressionModifier(value); + expModifier.useCustomModifier(customTranslateModifier); + expModifier.translate({ + column: amount + }, startCoord({ + row: origRow, + column: origColumn + })); + dataProvider.updateSourceData(row, column, expModifier.toString()); + } + } + }); +} +/** + * @param {cellCoord} cell The cell coordinates. + * @param {string} axis The axis defined as "row" or "column". + * @param {number} delta The shift/delta betwen old and new position. + * @param {number} startFromIndex The index from the operation was performed. + * @returns {Array} + */ + +function customTranslateModifier(cell, axis, delta, startFromIndex) { + var start = cell.start, + end = cell.end; + var startIndex = start[axis].index; + var endIndex = end[axis].index; + var deltaStart = delta; + var deltaEnd = delta; // Do not translate cells above inserted row or on the left of inserted column + + if (startFromIndex > startIndex) { + deltaStart = 0; + } + + if (startFromIndex > endIndex) { + deltaEnd = 0; + } + + return [deltaStart, deltaEnd, false]; +} + +var insertColumn = /*#__PURE__*/Object.freeze({ + __proto__: null, + OPERATION_NAME: OPERATION_NAME$1, + operate: operate$1 +}); + +/** + * When "insert_row" is triggered the following operations must be performed: + * + * - All formulas which contain cell coordinates must be updated and saved into source data - Row must be increased + * by "amount" of times (eq: D4 to D5, $F$5 to $F$6); + * - Mark all formulas which need update with "STATE_OUT_OFF_DATE" flag, so they can be recalculated after the operation. + */ + +var OPERATION_NAME$2 = 'insert_row'; +/** + * Execute changes. + * + * @param {number} start Index row from which the operation starts. + * @param {number} amount Count of rows to be inserted. + * @param {boolean} [modifyFormula=true] If `true` all formula expressions will be modified according to the changes. + * `false` value is used by UndoRedo plugin which saves snapshoots before alter + * operation so it doesn't modify formulas if undo action is triggered. + */ + +function operate$2(start, amount) { + var modifyFormula = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var matrix = this.matrix, + dataProvider = this.dataProvider; + var translate = [amount, 0]; + arrayEach(matrix.cellReferences, function (cell) { + if (cell.row >= start) { + cell.translateTo.apply(cell, translate); + } + }); + arrayEach(matrix.data, function (cell) { + var origRow = cell.row, + origColumn = cell.column; + + if (cell.row >= start) { + cell.translateTo.apply(cell, translate); + cell.setState(CellValue.STATE_OUT_OFF_DATE); + } + + if (modifyFormula) { + var row = cell.row, + column = cell.column; + var value = dataProvider.getSourceDataAtCell(row, column); + + if (isFormulaExpression(value)) { + var startCoord = cellCoordFactory('row', start); + var expModifier = new ExpressionModifier(value); + expModifier.useCustomModifier(customTranslateModifier$1); + expModifier.translate({ + row: amount + }, startCoord({ + row: origRow, + column: origColumn + })); + dataProvider.updateSourceData(row, column, expModifier.toString()); + } + } + }); +} +/** + * @param {cellCoord} cell The cell coordinates. + * @param {string} axis The axis defined as "row" or "column". + * @param {number} delta The shift/delta betwen old and new position. + * @param {number} startFromIndex The index from the operation was performed. + * @returns {Array} + */ + +function customTranslateModifier$1(cell, axis, delta, startFromIndex) { + var start = cell.start, + end = cell.end; + var startIndex = start[axis].index; + var endIndex = end[axis].index; + var deltaStart = delta; + var deltaEnd = delta; // Do not translate cells above inserted row or on the left of inserted column + + if (startFromIndex > startIndex) { + deltaStart = 0; + } + + if (startFromIndex > endIndex) { + deltaEnd = 0; + } + + return [deltaStart, deltaEnd, false]; +} + +var insertRow = /*#__PURE__*/Object.freeze({ + __proto__: null, + OPERATION_NAME: OPERATION_NAME$2, + operate: operate$2 +}); + +/** + * When "remove_column" is triggered the following operations must be performed: + * + * - All formulas which contain cell coordinates must be updated and saved into source data - Column must be decreased + * by "amount" of times (eq: D4 to C4, $F$5 to $E$5); + * - Mark all formulas which need update with "STATE_OUT_OFF_DATE" flag, so they can be recalculated after the operation. + */ + +var OPERATION_NAME$3 = 'remove_column'; +/** + * Execute changes. + * + * @param {number} start Index column from which the operation starts. + * @param {number} amount Count of columns to be removed. + * @param {boolean} [modifyFormula=true] If `true` all formula expressions will be modified according to the changes. + * `false` value is used by UndoRedo plugin which saves snapshoots before alter + * operation so it doesn't modify formulas if undo action is triggered. + */ + +function operate$3(start, amount) { + var modifyFormula = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var columnsAmount = -amount; + var matrix = this.matrix, + dataProvider = this.dataProvider, + sheet = this.sheet; + var translate = [0, columnsAmount]; + var indexOffset = Math.abs(columnsAmount) - 1; + var removedCellRef = matrix.removeCellRefsAtRange({ + column: start + }, { + column: start + indexOffset + }); + var toRemove = []; + arrayEach(matrix.data, function (cell) { + arrayEach(removedCellRef, function (cellRef) { + if (!cell.hasPrecedent(cellRef)) { + return; + } + + cell.removePrecedent(cellRef); + cell.setState(CellValue.STATE_OUT_OFF_DATE); + arrayEach(sheet.getCellDependencies(cell.row, cell.column), function (cellValue) { + cellValue.setState(CellValue.STATE_OUT_OFF_DATE); + }); + }); + + if (cell.column >= start && cell.column <= start + indexOffset) { + toRemove.push(cell); + } + }); + matrix.remove(toRemove); + arrayEach(matrix.cellReferences, function (cell) { + if (cell.column >= start) { + cell.translateTo.apply(cell, translate); + } + }); + arrayEach(matrix.data, function (cell) { + var origRow = cell.row, + origColumn = cell.column; + + if (cell.column >= start) { + cell.translateTo.apply(cell, translate); + cell.setState(CellValue.STATE_OUT_OFF_DATE); + } + + if (modifyFormula) { + var row = cell.row, + column = cell.column; + var value = dataProvider.getSourceDataAtCell(row, column); + + if (isFormulaExpression(value)) { + var startCoord = cellCoordFactory('column', start); + var expModifier = new ExpressionModifier(value); + expModifier.useCustomModifier(customTranslateModifier$2); + expModifier.translate({ + column: columnsAmount + }, startCoord({ + row: origRow, + column: origColumn + })); + dataProvider.updateSourceData(row, column, expModifier.toString()); + } + } + }); +} +/** + * @param {cellCoord} cell The cell coordinates. + * @param {string} axis The axis defined as "row" or "column". + * @param {number} delta The shift/delta betwen old and new position. + * @param {number} startFromIndex The index from the operation was performed. + * @returns {Array} + */ + +function customTranslateModifier$2(cell, axis, delta, startFromIndex) { + var start = cell.start, + end = cell.end, + type = cell.type; + var startIndex = start[axis].index; + var endIndex = end[axis].index; + var indexOffset = Math.abs(delta) - 1; + var deltaStart = delta; + var deltaEnd = delta; + var refError = false; // Mark all cells as #REF! which refer to removed cells between startFromIndex and startFromIndex + delta + + if (startIndex >= startFromIndex && endIndex <= startFromIndex + indexOffset) { + refError = true; + } // Decrement all cells below startFromIndex + + + if (!refError && type === 'cell') { + if (startFromIndex >= startIndex) { + deltaStart = 0; + deltaEnd = 0; + } + } + + if (!refError && type === 'range') { + if (startFromIndex >= startIndex) { + deltaStart = 0; + } + + if (startFromIndex > endIndex) { + deltaEnd = 0; + } else if (endIndex <= startFromIndex + indexOffset) { + deltaEnd -= Math.min(endIndex - (startFromIndex + indexOffset), 0); + } + } + + if (startIndex + deltaStart < 0) { + deltaStart -= startIndex + deltaStart; + } + + return [deltaStart, deltaEnd, refError]; +} + +var removeColumn = /*#__PURE__*/Object.freeze({ + __proto__: null, + OPERATION_NAME: OPERATION_NAME$3, + operate: operate$3 +}); + +/** + * When "remove_row" is triggered the following operations must be performed: + * + * - All formulas which contain cell coordinates must be updated and saved into source data - Row must be decreased + * by "amount" of times (eq: D4 to D3, $F$5 to $F$4); + * - Mark all formulas which need update with "STATE_OUT_OFF_DATE" flag, so they can be recalculated after the operation. + */ + +var OPERATION_NAME$4 = 'remove_row'; +/** + * Execute changes. + * + * @param {number} start Index row from which the operation starts. + * @param {number} amount Count of rows to be removed. + * @param {boolean} [modifyFormula=true] If `true` all formula expressions will be modified according to the changes. + * `false` value is used by UndoRedo plugin which saves snapshoots before alter + * operation so it doesn't modify formulas if undo action is triggered. + */ + +function operate$4(start, amount) { + var modifyFormula = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var rowsAmount = -amount; + var matrix = this.matrix, + dataProvider = this.dataProvider, + sheet = this.sheet; + var translate = [rowsAmount, 0]; + var indexOffset = Math.abs(rowsAmount) - 1; + var removedCellRef = matrix.removeCellRefsAtRange({ + row: start + }, { + row: start + indexOffset + }); + var toRemove = []; + arrayEach(matrix.data, function (cell) { + arrayEach(removedCellRef, function (cellRef) { + if (!cell.hasPrecedent(cellRef)) { + return; + } + + cell.removePrecedent(cellRef); + cell.setState(CellValue.STATE_OUT_OFF_DATE); + arrayEach(sheet.getCellDependencies(cell.row, cell.column), function (cellValue) { + cellValue.setState(CellValue.STATE_OUT_OFF_DATE); + }); + }); + + if (cell.row >= start && cell.row <= start + indexOffset) { + toRemove.push(cell); + } + }); + matrix.remove(toRemove); + arrayEach(matrix.cellReferences, function (cell) { + if (cell.row >= start) { + cell.translateTo.apply(cell, translate); + } + }); + arrayEach(matrix.data, function (cell) { + var origRow = cell.row, + origColumn = cell.column; + + if (cell.row >= start) { + cell.translateTo.apply(cell, translate); + cell.setState(CellValue.STATE_OUT_OFF_DATE); + } + + if (modifyFormula) { + var row = cell.row, + column = cell.column; + var value = dataProvider.getSourceDataAtCell(row, column); + + if (isFormulaExpression(value)) { + var startCoord = cellCoordFactory('row', start); + var expModifier = new ExpressionModifier(value); + expModifier.useCustomModifier(customTranslateModifier$3); + expModifier.translate({ + row: rowsAmount + }, startCoord({ + row: origRow, + column: origColumn + })); + dataProvider.updateSourceData(row, column, expModifier.toString()); + } + } + }); +} +/** + * @param {cellCoord} cell The cell coordinates. + * @param {string} axis The axis defined as "row" or "column". + * @param {number} delta The shift/delta betwen old and new position. + * @param {number} startFromIndex The index from the operation was performed. + * @returns {Array} + */ + +function customTranslateModifier$3(cell, axis, delta, startFromIndex) { + var start = cell.start, + end = cell.end, + type = cell.type; + var startIndex = start[axis].index; + var endIndex = end[axis].index; + var indexOffset = Math.abs(delta) - 1; + var deltaStart = delta; + var deltaEnd = delta; + var refError = false; // Mark all cells as #REF! which refer to removed cells between startFromIndex and startFromIndex + delta + + if (startIndex >= startFromIndex && endIndex <= startFromIndex + indexOffset) { + refError = true; + } // Decrement all cells below startFromIndex + + + if (!refError && type === 'cell') { + if (startFromIndex >= startIndex) { + deltaStart = 0; + deltaEnd = 0; + } + } + + if (!refError && type === 'range') { + if (startFromIndex >= startIndex) { + deltaStart = 0; + } + + if (startFromIndex > endIndex) { + deltaEnd = 0; + } else if (endIndex <= startFromIndex + indexOffset) { + deltaEnd -= Math.min(endIndex - (startFromIndex + indexOffset), 0); + } + } + + if (startIndex + deltaStart < 0) { + deltaStart -= startIndex + deltaStart; + } + + return [deltaStart, deltaEnd, refError]; +} + +var removeRow = /*#__PURE__*/Object.freeze({ + __proto__: null, + OPERATION_NAME: OPERATION_NAME$4, + operate: operate$4 +}); + +function _classCallCheck$2s(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2m(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); } } + +function _createClass$2m(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2m(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2m(Constructor, staticProps); return Constructor; } +var operations$1 = new Map(); +registerOperation$1(OPERATION_NAME, columnSorting); +registerOperation$1(OPERATION_NAME$1, insertColumn); +registerOperation$1(OPERATION_NAME$2, insertRow); +registerOperation$1(OPERATION_NAME$3, removeColumn); +registerOperation$1(OPERATION_NAME$4, removeRow); +/** + * Alter Manager is a service that is responsible for changing the formula expressions (especially cell coordinates) + * based on specific alter operation applied into the table. + * + * For example, when a user adds a new row the algorithm that moves all the cells below the added row down by one row + * should be triggered (eq: cell A5 become A6 etc). + * + * All alter operations are defined in the "alterOperation/" directory. + * + * @class AlterManager + * @util + */ + +var AlterManager = /*#__PURE__*/function () { + function AlterManager(sheet) { + _classCallCheck$2s(this, AlterManager); + + /** + * Instance of {@link Sheet}. + * + * @type {Sheet} + */ + this.sheet = sheet; + /** + * Handsontable instance. + * + * @type {Core} + */ + + this.hot = sheet.hot; + /** + * Instance of {@link DataProvider}. + * + * @type {DataProvider} + */ + + this.dataProvider = sheet.dataProvider; + /** + * Instance of {@link Matrix}. + * + * @type {Matrix} + */ + + this.matrix = sheet.matrix; + } + /** + * Prepare to execute an alter algorithm. This preparation can be useful for collecting some variables and + * states before specific algorithm will be executed. + * + * @param {string} action One of the action defined in alterOperation. + * @param {*} args Arguments pass to alter operation. + */ + + + _createClass$2m(AlterManager, [{ + key: "prepareAlter", + value: function prepareAlter(action) { + if (!operations$1.has(action)) { + throw Error("Alter operation \"".concat(action, "\" not exist.")); + } + + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + operations$1.get(action).prepare.apply(this, args); + } + /** + * Trigger an alter algorithm and after executing code trigger local hook ("afterAlter"). + * + * @param {string} action One of the action defined in alterOperation. + * @param {*} args Arguments pass to alter operation. + */ + + }, { + key: "triggerAlter", + value: function triggerAlter(action) { + if (!operations$1.has(action)) { + throw Error("Alter operation \"".concat(action, "\" not exist.")); + } + + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + + operations$1.get(action).operate.apply(this, args); + this.runLocalHooks.apply(this, ['afterAlter'].concat(args)); + } + /** + * Destroy class. + */ + + }, { + key: "destroy", + value: function destroy() { + this.sheet = null; + this.hot = null; + this.dataProvider = null; + this.matrix = null; + } + }]); + + return AlterManager; +}(); + +mixin(AlterManager, localHooks); + +var empty$1 = function empty() {}; +/** + * @param {string} name The ID of the operation to register. + * @param {object} descriptor The object with `prepare` and `operate` methods which holds the operation logic. + */ + + +function registerOperation$1(name, descriptor) { + if (!operations$1.has(name)) { + operations$1.set(name, { + prepare: descriptor.prepare || empty$1, + operate: descriptor.operate || empty$1 + }); + } +} + +function _classCallCheck$2t(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2n(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); } } + +function _createClass$2n(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2n(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2n(Constructor, staticProps); return Constructor; } +var STATE_UP_TO_DATE$1 = 1; +var STATE_NEED_REBUILD = 2; +var STATE_NEED_FULL_REBUILD = 3; +/** + * Sheet component responsible for whole spreadsheet calculations. + * + * @class Sheet + * @util + */ + +var Sheet = /*#__PURE__*/function () { + function Sheet(hot, dataProvider) { + var _this = this; + + _classCallCheck$2t(this, Sheet); + + /** + * Handsontable instance. + * + * @type {Core} + */ + this.hot = hot; + /** + * Data provider for sheet calculations. + * + * @type {DataProvider} + */ + + this.dataProvider = dataProvider; + /** + * Instance of {@link https://github.com/handsontable/formula-parser}. + * + * @type {Parser} + */ + + this.parser = new hotFormulaParser.Parser(); + /** + * Instance of {@link Matrix}. + * + * @type {Matrix} + */ + + this.matrix = new Matrix(this.hot); + /** + * Instance of {@link AlterManager}. + * + * @type {AlterManager} + */ + + this.alterManager = new AlterManager(this); + /** + * Cell object which indicates which cell is currently processing. + * + * @private + * @type {null} + */ + + this._processingCell = null; + /** + * State of the sheet. + * + * @type {number} + * @private + */ + + this._state = STATE_NEED_FULL_REBUILD; + this.parser.on('callCellValue', function () { + return _this._onCallCellValue.apply(_this, arguments); + }); + this.parser.on('callRangeValue', function () { + return _this._onCallRangeValue.apply(_this, arguments); + }); + this.alterManager.addLocalHook('afterAlter', function () { + return _this._onAfterAlter.apply(_this, arguments); + }); + } + /** + * Recalculate sheet. + */ + + + _createClass$2n(Sheet, [{ + key: "recalculate", + value: function recalculate() { + switch (this._state) { + case STATE_NEED_FULL_REBUILD: + this.recalculateFull(); + break; + + case STATE_NEED_REBUILD: + this.recalculateOptimized(); + break; + } + } + /** + * Recalculate sheet using optimized methods (fast recalculation). + */ + + }, { + key: "recalculateOptimized", + value: function recalculateOptimized() { + var _this2 = this; + + var cells = this.matrix.getOutOfDateCells(); + arrayEach(cells, function (cellValue) { + var value = _this2.dataProvider.getSourceDataAtCell(cellValue.row, cellValue.column); + + if (isFormulaExpression(value)) { + _this2.parseExpression(cellValue, value.substr(1)); + } + }); + this._state = STATE_UP_TO_DATE$1; + this.runLocalHooks('afterRecalculate', cells, 'optimized'); + } + /** + * Recalculate whole table by building dependencies from scratch (slow recalculation). + */ + + }, { + key: "recalculateFull", + value: function recalculateFull() { + var _this3 = this; + + var cells = this.dataProvider.getSourceDataByRange(); + this.matrix.reset(); + arrayEach(cells, function (rowData, row) { + arrayEach(rowData, function (value, column) { + if (isFormulaExpression(value)) { + _this3.parseExpression(new CellValue(row, column), value.substr(1)); + } + }); + }); + this._state = STATE_UP_TO_DATE$1; + this.runLocalHooks('afterRecalculate', cells, 'full'); + } + /** + * Set predefined variable name which can be visible while parsing formula expression. + * + * @param {string} name Variable name. + * @param {*} value Variable value. + */ + + }, { + key: "setVariable", + value: function setVariable(name, value) { + this.parser.setVariable(name, value); + } + /** + * Get variable name. + * + * @param {string} name Variable name. + * @returns {*} + */ + + }, { + key: "getVariable", + value: function getVariable(name) { + return this.parser.getVariable(name); + } + /** + * Apply changes to the sheet. + * + * @param {number} row Physical row index. + * @param {number} column Physical column index. + * @param {*} newValue Current cell value. + */ + + }, { + key: "applyChanges", + value: function applyChanges(row, column, newValue) { + // Remove formula description for old expression + // TODO: Move this to recalculate() + this.matrix.remove({ + row: row, + column: column + }); // TODO: Move this to recalculate() + + if (isFormulaExpression(newValue)) { + // ...and create new for new changed formula expression + this.parseExpression(new CellValue(row, column), newValue.substr(1)); + } + + var deps = this.getCellDependencies(this.hot.toVisualRow(row), this.hot.toVisualColumn(column)); + arrayEach(deps, function (cellValue) { + cellValue.setState(CellValue.STATE_OUT_OFF_DATE); + }); + this._state = STATE_NEED_REBUILD; + } + /** + * Parse and evaluate formula for provided cell. + * + * @param {CellValue|object} cellValue Cell value object. + * @param {string} formula Value to evaluate. + */ + + }, { + key: "parseExpression", + value: function parseExpression(cellValue, formula) { + cellValue.setState(CellValue.STATE_COMPUTING); + this._processingCell = cellValue; + + var _this$parser$parse = this.parser.parse(toUpperCaseFormula(formula)), + error = _this$parser$parse.error, + result = _this$parser$parse.result; + + if (isFormulaExpression(result)) { + this.parseExpression(cellValue, result.substr(1)); + } else { + cellValue.setValue(result); + cellValue.setError(error); + cellValue.setState(CellValue.STATE_UP_TO_DATE); + } + + this.matrix.add(cellValue); + this._processingCell = null; + } + /** + * Get cell value object at specified physical coordinates. + * + * @param {number} row Physical row index. + * @param {number} column Physical column index. + * @returns {CellValue|undefined} + */ + + }, { + key: "getCellAt", + value: function getCellAt(row, column) { + return this.matrix.getCellAt(row, column); + } + /** + * Get cell dependencies at specified physical coordinates. + * + * @param {number} row Physical row index. + * @param {number} column Physical column index. + * @returns {Array} + */ + + }, { + key: "getCellDependencies", + value: function getCellDependencies(row, column) { + return this.matrix.getDependencies({ + row: row, + column: column + }); + } + /** + * Listener for parser cell value. + * + * @private + * @param {object} cellCoords Cell coordinates. + * @param {Function} done Function to call with valid cell value. + */ + + }, { + key: "_onCallCellValue", + value: function _onCallCellValue(_ref, done) { + var row = _ref.row, + column = _ref.column; + var cell = new CellReference(row, column); + + if (!this.dataProvider.isInDataRange(cell.row, cell.column)) { + throw Error(hotFormulaParser.ERROR_REF); + } + + this.matrix.registerCellRef(cell); + + this._processingCell.addPrecedent(cell); + + var cellValue = this.dataProvider.getRawDataAtCell(row.index, column.index); + + if (hotFormulaParser.error(cellValue)) { + var computedCell = this.matrix.getCellAt(row.index, column.index); + + if (computedCell && computedCell.hasError()) { + throw Error(cellValue); + } + } + + if (isFormulaExpression(cellValue)) { + var _this$parser$parse2 = this.parser.parse(cellValue.substr(1)), + error = _this$parser$parse2.error, + result = _this$parser$parse2.result; + + if (error) { + throw Error(error); + } + + done(result); + } else { + done(cellValue); + } + } + /** + * Listener for parser cells (range) value. + * + * @private + * @param {object} startCell Cell coordinates (top-left corner coordinate). + * @param {object} endCell Cell coordinates (bottom-right corner coordinate). + * @param {Function} done Function to call with valid cells values. + */ + + }, { + key: "_onCallRangeValue", + value: function _onCallRangeValue(_ref2, _ref3, done) { + var _this4 = this; + + var startRow = _ref2.row, + startColumn = _ref2.column; + var endRow = _ref3.row, + endColumn = _ref3.column; + var cellValues = this.dataProvider.getRawDataByRange(startRow.index, startColumn.index, endRow.index, endColumn.index); + + var mapRowData = function mapRowData(rowData, rowIndex) { + return arrayMap(rowData, function (cellData, columnIndex) { + var rowCellCoord = startRow.index + rowIndex; + var columnCellCoord = startColumn.index + columnIndex; + var cell = new CellReference(rowCellCoord, columnCellCoord); + + if (!_this4.dataProvider.isInDataRange(cell.row, cell.column)) { + throw Error(hotFormulaParser.ERROR_REF); + } + + _this4.matrix.registerCellRef(cell); + + _this4._processingCell.addPrecedent(cell); + + var newCellData = cellData; + + if (hotFormulaParser.error(newCellData)) { + var computedCell = _this4.matrix.getCellAt(cell.row, cell.column); + + if (computedCell && computedCell.hasError()) { + throw Error(newCellData); + } + } + + if (isFormulaExpression(newCellData)) { + var _this4$parser$parse = _this4.parser.parse(newCellData.substr(1)), + error = _this4$parser$parse.error, + result = _this4$parser$parse.result; + + if (error) { + throw Error(error); + } + + newCellData = result; + } + + return newCellData; + }); + }; + + var calculatedCellValues = arrayMap(cellValues, function (rowData, rowIndex) { + return mapRowData(rowData, rowIndex); + }); + done(calculatedCellValues); + } + /** + * On after alter sheet listener. + * + * @private + */ + + }, { + key: "_onAfterAlter", + value: function _onAfterAlter() { + this.recalculateOptimized(); + } + /** + * Destroy class. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot = null; + this.dataProvider.destroy(); + this.dataProvider = null; + this.alterManager.destroy(); + this.alterManager = null; + this.parser = null; + this.matrix.reset(); + this.matrix = null; + } + }]); + + return Sheet; +}(); + +mixin(Sheet, localHooks); + +function _classCallCheck$2u(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2o(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); } } + +function _createClass$2o(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2o(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2o(Constructor, staticProps); return Constructor; } +/** + * Data class provider responsible for providing a set of range data types, necessary for calculating formulas. + * Those methods strongly using hot.getData and hot.getSourceData methods with some changes. Data provider additionally + * collects all changes added to the data source to make them available faster than by using + * hot.getData and hot.getSourceData methods. + * + * @class DataProvider + * @util + */ + +var DataProvider$1 = /*#__PURE__*/function () { + function DataProvider(hot) { + _classCallCheck$2u(this, DataProvider); + + /** + * Handsontable instance. + * + * @type {Core} + */ + this.hot = hot; + /** + * Collected changes applied into editors or by calling public Handsontable API. This is require to provide + * fresh data applied into spreadsheet before they will be available from the public API. + * + * @type {object} + */ + + this.changes = {}; + } + /** + * Collect all data changes applied to the Handsontable to make them available later. + * + * @param {number} row Physical row index. + * @param {number} column Physical column index. + * @param {*} value Value to store. + */ + + + _createClass$2o(DataProvider, [{ + key: "collectChanges", + value: function collectChanges(row, column, value) { + this.changes[this._coordId(row, column)] = value; + } + /** + * Clear all collected changes. + */ + + }, { + key: "clearChanges", + value: function clearChanges() { + this.changes = {}; + } + /** + * Check if provided coordinates match to the table range data. + * + * @param {number} visualRow Visual row index. + * @param {number} visualColumn Visual row index. + * @returns {boolean} + */ + + }, { + key: "isInDataRange", + value: function isInDataRange(visualRow, visualColumn) { + return visualRow >= 0 && visualRow < this.hot.countRows() && visualColumn >= 0 && visualColumn < this.hot.countCols(); + } + /** + * Get calculated data at specified cell. + * + * @param {number} visualRow Visual row index. + * @param {number} visualColumn Visual column index. + * @returns {*} + */ + + }, { + key: "getDataAtCell", + value: function getDataAtCell(visualRow, visualColumn) { + var id = this._coordId(this.hot.toPhysicalRow(visualRow), this.hot.toPhysicalColumn(visualColumn)); + + var result; + + if (hasOwnProperty$1(this.changes, id)) { + result = this.changes[id]; + } else { + result = this.hot.getDataAtCell(visualRow, visualColumn); + } + + return result; + } + /** + * Get calculated data at specified range. + * + * @param {number} [visualRow1] Visual row index. + * @param {number} [visualColumn1] Visual column index. + * @param {number} [visualRow2] Visual row index. + * @param {number} [visualColumn2] Visual column index. + * @returns {Array} + */ + + }, { + key: "getDataByRange", + value: function getDataByRange(visualRow1, visualColumn1, visualRow2, visualColumn2) { + var _this = this; + + var result = this.hot.getData(visualRow1, visualColumn1, visualRow2, visualColumn2); + arrayEach(result, function (rowData, rowIndex) { + arrayEach(rowData, function (value, columnIndex) { + var id = _this._coordId(_this.hot.toPhysicalRow(rowIndex + visualRow1), _this.hot.toPhysicalColumn(columnIndex + visualColumn1)); + + if (hasOwnProperty$1(_this.changes, id)) { + result[rowIndex][columnIndex] = _this.changes[id]; + } + }); + }); + return result; + } + /** + * Get source data at specified physical cell. + * + * @param {number} physicalRow Physical row index. + * @param {number} physicalColumn Physical column index. + * @returns {*} + */ + + }, { + key: "getSourceDataAtCell", + value: function getSourceDataAtCell(physicalRow, physicalColumn) { + var id = this._coordId(physicalRow, physicalColumn); + + var result; + + if (hasOwnProperty$1(this.changes, id)) { + result = this.changes[id]; + } else { + result = this.hot.getSourceDataAtCell(physicalRow, physicalColumn); + } + + return result; + } + /** + * Get source data at specified physical range. + * + * @param {number} [physicalRow1] Physical row index. + * @param {number} [physicalColumn1] Physical column index. + * @param {number} [physicalRow2] Physical row index. + * @param {number} [physicalColumn2] Physical column index. + * @returns {Array} + */ + + }, { + key: "getSourceDataByRange", + value: function getSourceDataByRange(physicalRow1, physicalColumn1, physicalRow2, physicalColumn2) { + return this.hot.getSourceDataArray(physicalRow1, physicalColumn1, physicalRow2, physicalColumn2); + } + /** + * Get source data at specified visual cell. + * + * @param {number} visualRow Visual row index. + * @param {number} visualColumn Visual column index. + * @returns {*} + */ + + }, { + key: "getRawDataAtCell", + value: function getRawDataAtCell(visualRow, visualColumn) { + return this.getSourceDataAtCell(this.hot.toPhysicalRow(visualRow), this.hot.toPhysicalColumn(visualColumn)); + } + /** + * Get source data at specified visual range. + * + * @param {number} [visualRow1] Visual row index. + * @param {number} [visualColumn1] Visual column index. + * @param {number} [visualRow2] Visual row index. + * @param {number} [visualColumn2] Visual column index. + * @returns {Array} + */ + + }, { + key: "getRawDataByRange", + value: function getRawDataByRange(visualRow1, visualColumn1, visualRow2, visualColumn2) { + var _this2 = this; + + var data = []; + rangeEach(visualRow1, visualRow2, function (visualRow) { + var row = []; + rangeEach(visualColumn1, visualColumn2, function (visualColumn) { + var _ref = [_this2.hot.toPhysicalRow(visualRow), _this2.hot.toPhysicalColumn(visualColumn)], + physicalRow = _ref[0], + physicalColumn = _ref[1]; + + var id = _this2._coordId(physicalRow, physicalColumn); + + if (hasOwnProperty$1(_this2.changes, id)) { + row.push(_this2.changes[id]); + } else { + row.push(_this2.getSourceDataAtCell(physicalRow, physicalColumn)); + } + }); + data.push(row); + }); + return data; + } + /** + * Update source data. + * + * @param {number} physicalRow Physical row index. + * @param {number} physicalColumn Physical row index. + * @param {*} value Value to update. + */ + + }, { + key: "updateSourceData", + value: function updateSourceData(physicalRow, physicalColumn, value) { + this.hot.setSourceDataAtCell(physicalRow, this.hot.colToProp(physicalColumn), value); + } + /** + * Generate cell coordinates id where the data changes will be stored. + * + * @param {number} row Row index. + * @param {number} column Column index. + * @returns {string} + * @private + */ + + }, { + key: "_coordId", + value: function _coordId(row, column) { + return "".concat(row, ":").concat(column); + } + /** + * Destroy class. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot = null; + this.changes = null; + } + }]); + + return DataProvider; +}(); + +function _classCallCheck$2v(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2p(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); } } + +function _createClass$2p(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2p(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2p(Constructor, staticProps); return Constructor; } + +/** + * @class Stack + * @util + */ +var Stack = /*#__PURE__*/function () { + function Stack() { + var initial = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + + _classCallCheck$2v(this, Stack); + + /** + * Items collection. + * + * @type {Array} + */ + this.items = initial; + } + /** + * Add new item or items at the back of the stack. + * + * @param {*} items An item to add. + */ + + + _createClass$2p(Stack, [{ + key: "push", + value: function push() { + var _this$items; + + (_this$items = this.items).push.apply(_this$items, arguments); + } + /** + * Remove the last element from the stack and returns it. + * + * @returns {*} + */ + + }, { + key: "pop", + value: function pop() { + return this.items.pop(); + } + /** + * Return the last element from the stack (without modification stack). + * + * @returns {*} + */ + + }, { + key: "peek", + value: function peek() { + return this.isEmpty() ? void 0 : this.items[this.items.length - 1]; + } + /** + * Check if the stack is empty. + * + * @returns {boolean} + */ + + }, { + key: "isEmpty", + value: function isEmpty() { + return !this.size(); + } + /** + * Return number of elements in the stack. + * + * @returns {number} + */ + + }, { + key: "size", + value: function size() { + return this.items.length; + } + }]); + + return Stack; +}(); + +function _classCallCheck$2w(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2q(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); } } + +function _createClass$2q(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2q(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2q(Constructor, staticProps); return Constructor; } +/** + * This components is a simple workaround to make Undo/Redo functionality work. + * + * @class UndoRedoSnapshot + * @util + */ + +var UndoRedoSnapshot = /*#__PURE__*/function () { + function UndoRedoSnapshot(sheet) { + _classCallCheck$2w(this, UndoRedoSnapshot); + + /** + * Instance of {@link Sheet}. + * + * @type {Sheet} + */ + this.sheet = sheet; + /** + * Stack instance for collecting undo/redo changes. + * + * @type {Stack} + */ + + this.stack = new Stack(); + } + /** + * Save snapshot for specified action. + * + * @param {string} axis Alter action which triggers snapshot. + * @param {number} index Alter operation stared at. + * @param {number} amount Amount of items to operate. + */ + + + _createClass$2q(UndoRedoSnapshot, [{ + key: "save", + value: function save(axis, index, amount) { + var _this$sheet = this.sheet, + matrix = _this$sheet.matrix, + dataProvider = _this$sheet.dataProvider; + var changes = []; + arrayEach(matrix.data, function (cellValue) { + var row = cellValue.row, + column = cellValue.column; + + if (cellValue[axis] < index || cellValue[axis] > index + (amount - 1)) { + var value = dataProvider.getSourceDataAtCell(row, column); + changes.push({ + row: row, + column: column, + value: value + }); + } + }); + this.stack.push({ + axis: axis, + index: index, + amount: amount, + changes: changes + }); + } + /** + * Restore state to the previous one. + */ + + }, { + key: "restore", + value: function restore() { + var _this$sheet2 = this.sheet, + matrix = _this$sheet2.matrix, + dataProvider = _this$sheet2.dataProvider; + + var _this$stack$pop = this.stack.pop(), + axis = _this$stack$pop.axis, + index = _this$stack$pop.index, + amount = _this$stack$pop.amount, + changes = _this$stack$pop.changes; + + if (changes) { + arrayEach(changes, function (change) { + if (change[axis] > index + (amount - 1)) { + change[axis] -= amount; + } + + var row = change.row, + column = change.column, + value = change.value; + var rawValue = dataProvider.getSourceDataAtCell(row, column); + + if (rawValue !== value) { + dataProvider.updateSourceData(row, column, value); + matrix.getCellAt(row, column).setState(CellValue.STATE_OUT_OFF_DATE); + } + }); + } + } + /** + * Destroy class. + */ + + }, { + key: "destroy", + value: function destroy() { + this.sheet = null; + this.stack = null; + } + }]); + + return UndoRedoSnapshot; +}(); + +function _typeof$1r(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1r = function _typeof(obj) { return typeof obj; }; } else { _typeof$1r = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1r(obj); } + +function _slicedToArray$J(arr, i) { return _arrayWithHoles$L(arr) || _iterableToArrayLimit$J(arr, i) || _unsupportedIterableToArray$$(arr, i) || _nonIterableRest$L(); } + +function _nonIterableRest$L() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$$(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$$(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$$(o, minLen); } + +function _arrayLikeToArray$$(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$J(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$L(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$2x(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2r(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); } } + +function _createClass$2r(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2r(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2r(Constructor, staticProps); return Constructor; } + +function _get$N(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$N = Reflect.get; } else { _get$N = function _get(target, property, receiver) { var base = _superPropBase$N(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$N(target, property, receiver || target); } + +function _superPropBase$N(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1f(object); if (object === null) break; } return object; } + +function _inherits$1f(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1g(subClass, superClass); } + +function _setPrototypeOf$1g(o, p) { _setPrototypeOf$1g = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1g(o, p); } + +function _createSuper$1f(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1g(); return function _createSuperInternal() { var Super = _getPrototypeOf$1f(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1f(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1f(this, result); }; } + +function _possibleConstructorReturn$1f(self, call) { if (call && (_typeof$1r(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1f(self); } + +function _assertThisInitialized$1f(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1g() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1f(o) { _getPrototypeOf$1f = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1f(o); } +var PLUGIN_KEY$s = 'formulas'; +var PLUGIN_PRIORITY$q = 260; +/** + * The formulas plugin. + * + * @plugin Formulas + */ + +var Formulas = /*#__PURE__*/function (_BasePlugin) { + _inherits$1f(Formulas, _BasePlugin); + + var _super = _createSuper$1f(Formulas); + + function Formulas(hotInstance) { + var _this; + + _classCallCheck$2x(this, Formulas); + + _this = _super.call(this, hotInstance); + /** + * Instance of {@link EventManager}. + * + * @private + * @type {EventManager} + */ + + _this.eventManager = new EventManager(_assertThisInitialized$1f(_this)); + /** + * Instance of {@link DataProvider}. + * + * @private + * @type {DataProvider} + */ + + _this.dataProvider = new DataProvider$1(_this.hot); + /** + * Instance of {@link Sheet}. + * + * @private + * @type {Sheet} + */ + + _this.sheet = new Sheet(_this.hot, _this.dataProvider); + /** + * Instance of {@link UndoRedoSnapshot}. + * + * @private + * @type {UndoRedoSnapshot} + */ + + _this.undoRedoSnapshot = new UndoRedoSnapshot(_this.sheet); + /** + * Flag which indicates if table should be re-render after sheet recalculations. + * + * @type {boolean} + * @default false + * @private + */ + + _this._skipRendering = false; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link Formulas#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$2r(Formulas, [{ + key: "isEnabled", + value: function isEnabled() { + /* eslint-disable no-unneeded-ternary */ + return this.hot.getSettings()[PLUGIN_KEY$s] ? true : false; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var settings = this.hot.getSettings()[PLUGIN_KEY$s]; + + if (isObject$1(settings)) { + if (isObject$1(settings.variables)) { + objectEach(settings.variables, function (value, name) { + return _this2.setVariable(name, value); + }); + } + } + + this.addHook('afterColumnSort', function () { + return _this2.onAfterColumnSort.apply(_this2, arguments); + }); + this.addHook('afterCreateCol', function () { + return _this2.onAfterCreateCol.apply(_this2, arguments); + }); + this.addHook('afterCreateRow', function () { + return _this2.onAfterCreateRow.apply(_this2, arguments); + }); + this.addHook('afterLoadData', function () { + return _this2.onAfterLoadData(); + }); + this.addHook('afterRemoveCol', function () { + return _this2.onAfterRemoveCol.apply(_this2, arguments); + }); + this.addHook('afterRemoveRow', function () { + return _this2.onAfterRemoveRow.apply(_this2, arguments); + }); + this.addHook('afterSetDataAtCell', function () { + return _this2.onAfterSetDataAtCell.apply(_this2, arguments); + }); + this.addHook('afterSetDataAtRowProp', function () { + return _this2.onAfterSetDataAtCell.apply(_this2, arguments); + }); + this.addHook('beforeColumnSort', function () { + return _this2.onBeforeColumnSort.apply(_this2, arguments); + }); + this.addHook('beforeCreateCol', function () { + return _this2.onBeforeCreateCol.apply(_this2, arguments); + }); + this.addHook('beforeCreateRow', function () { + return _this2.onBeforeCreateRow.apply(_this2, arguments); + }); + this.addHook('beforeRemoveCol', function () { + return _this2.onBeforeRemoveCol.apply(_this2, arguments); + }); + this.addHook('beforeRemoveRow', function () { + return _this2.onBeforeRemoveRow.apply(_this2, arguments); + }); + this.addHook('beforeValidate', function () { + return _this2.onBeforeValidate.apply(_this2, arguments); + }); + this.addHook('beforeValueRender', function () { + return _this2.onBeforeValueRender.apply(_this2, arguments); + }); + this.addHook('modifyData', function () { + return _this2.onModifyData.apply(_this2, arguments); + }); + this.sheet.addLocalHook('afterRecalculate', function () { + return _this2.onSheetAfterRecalculate.apply(_this2, arguments); + }); + + _get$N(_getPrototypeOf$1f(Formulas.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + _get$N(_getPrototypeOf$1f(Formulas.prototype), "disablePlugin", this).call(this); + } + /** + * Returns cell value (evaluated from formula expression) at specified cell coords. + * + * @param {number} row Row index. + * @param {number} column Column index. + * @returns {*} + */ + + }, { + key: "getCellValue", + value: function getCellValue(row, column) { + var cell = this.sheet.getCellAt(row, column); + return cell ? cell.getError() || cell.getValue() : void 0; + } + /** + * Checks if there are any formula evaluations made under specific cell coords. + * + * @param {number} row Row index. + * @param {number} column Column index. + * @returns {boolean} + */ + + }, { + key: "hasComputedCellValue", + value: function hasComputedCellValue(row, column) { + return this.sheet.getCellAt(row, column) !== null; + } + /** + * Recalculates all formulas (an algorithm will choose the best method of calculation). + */ + + }, { + key: "recalculate", + value: function recalculate() { + this.sheet.recalculate(); + } + /** + * Recalculates all formulas (rebuild dependencies from scratch - slow approach). + */ + + }, { + key: "recalculateFull", + value: function recalculateFull() { + this.sheet.recalculateFull(); + } + /** + * Recalculates all formulas (recalculate only changed cells - fast approach). + */ + + }, { + key: "recalculateOptimized", + value: function recalculateOptimized() { + this.sheet.recalculateOptimized(); + } + /** + * Sets predefined variable name which can be visible while parsing formula expression. + * + * @param {string} name Variable name. + * @param {*} value Variable value. + */ + + }, { + key: "setVariable", + value: function setVariable(name, value) { + this.sheet.setVariable(name, value); + } + /** + * Returns variable name. + * + * @param {string} name Variable name. + * @returns {*} + */ + + }, { + key: "getVariable", + value: function getVariable(name) { + return this.sheet.getVariable(name); + } + /** + * Local hook listener for after sheet recalculation. + * + * @private + * @param {Array} cells An array of recalculated/changed cells. + */ + + }, { + key: "onSheetAfterRecalculate", + value: function onSheetAfterRecalculate(cells) { + if (this._skipRendering) { + this._skipRendering = false; + return; + } + + var hot = this.hot; + arrayEach(cells, function (cellValue) { + if (cellValue instanceof CellValue) { + var row = cellValue.row, + column = cellValue.column; + hot.validateCell(hot.getDataAtCell(row, column), hot.getCellMeta(row, column), function () {}); + } + }); + hot.render(); + } + /** + * On modify row data listener. It overwrites raw values into calculated ones and force upper case all formula expressions. + * + * @private + * @param {number} row Row index. + * @param {number} column Column index. + * @param {object} valueHolder Value holder as an object to change value by reference. + * @param {string} ioMode IO operation (`get` or `set`). + */ + + }, { + key: "onModifyData", + value: function onModifyData(row, column, valueHolder, ioMode) { + if (ioMode === 'get' && this.hasComputedCellValue(row, column)) { + valueHolder.value = this.getCellValue(row, column); + } else if (ioMode === 'set' && isFormulaExpression(valueHolder.value)) { + valueHolder.value = toUpperCaseFormula(valueHolder.value); + } + } + /** + * On before value render listener. + * + * @private + * @param {*} value Value to render. + * @returns {*} + */ + + }, { + key: "onBeforeValueRender", + value: function onBeforeValueRender(value) { + var renderValue = value; + + if (isFormulaExpressionEscaped(renderValue)) { + renderValue = unescapeFormulaExpression(renderValue); + } + + return renderValue; + } + /** + * On before validate listener. + * + * @private + * @param {*} value Value to validate. + * @param {number} row Row index. + * @param {number} prop Column property. + * @returns {*} + */ + + }, { + key: "onBeforeValidate", + value: function onBeforeValidate(value, row, prop) { + var column = this.hot.propToCol(prop); + var validateValue = value; + + if (this.hasComputedCellValue(row, column)) { + validateValue = this.getCellValue(row, column); + } + + return validateValue; + } + /** + * `afterSetDataAtCell` listener. + * + * @private + * @param {Array} changes Array of changes. + * @param {string} [source] Source of changes. + */ + + }, { + key: "onAfterSetDataAtCell", + value: function onAfterSetDataAtCell(changes, source) { + var _this3 = this; + + if (source === 'loadData') { + return; + } + + this.dataProvider.clearChanges(); + arrayEach(changes, function (_ref) { + var _ref2 = _slicedToArray$J(_ref, 4), + row = _ref2[0], + column = _ref2[1], + oldValue = _ref2[2], + newValue = _ref2[3]; + + var physicalColumn = _this3.hot.propToCol(column); + + var physicalRow = _this3.hot.toPhysicalRow(row); + + var value = newValue; + + if (isFormulaExpression(value)) { + value = toUpperCaseFormula(value); + } + + _this3.dataProvider.collectChanges(physicalRow, physicalColumn, value); + + if (oldValue !== value) { + _this3.sheet.applyChanges(physicalRow, physicalColumn, value); + } + }); + this.recalculate(); + } + /** + * On before create row listener. + * + * @private + * @param {number} row Row index. + * @param {number} amount An amount of removed rows. + * @param {string} source Source of method call. + */ + + }, { + key: "onBeforeCreateRow", + value: function onBeforeCreateRow(row, amount, source) { + if (source === 'UndoRedo.undo') { + this.undoRedoSnapshot.restore(); + } + } + /** + * On after create row listener. + * + * @private + * @param {number} row Row index. + * @param {number} amount An amount of created rows. + * @param {string} source Source of method call. + */ + + }, { + key: "onAfterCreateRow", + value: function onAfterCreateRow(row, amount, source) { + this.sheet.alterManager.triggerAlter('insert_row', row, amount, source !== 'UndoRedo.undo'); + } + /** + * On before remove row listener. + * + * @private + * @param {number} row Row index. + * @param {number} amount An amount of removed rows. + */ + + }, { + key: "onBeforeRemoveRow", + value: function onBeforeRemoveRow(row, amount) { + this.undoRedoSnapshot.save('row', row, amount); + } + /** + * On after remove row listener. + * + * @private + * @param {number} row Row index. + * @param {number} amount An amount of removed rows. + */ + + }, { + key: "onAfterRemoveRow", + value: function onAfterRemoveRow(row, amount) { + this.sheet.alterManager.triggerAlter('remove_row', row, amount); + } + /** + * On before create column listener. + * + * @private + * @param {number} column Column index. + * @param {number} amount An amount of removed columns. + * @param {string} source Source of method call. + */ + + }, { + key: "onBeforeCreateCol", + value: function onBeforeCreateCol(column, amount, source) { + if (source === 'UndoRedo.undo') { + this.undoRedoSnapshot.restore(); + } + } + /** + * On after create column listener. + * + * @private + * @param {number} column Column index. + * @param {number} amount An amount of created columns. + * @param {string} source Source of method call. + */ + + }, { + key: "onAfterCreateCol", + value: function onAfterCreateCol(column, amount, source) { + this.sheet.alterManager.triggerAlter('insert_column', column, amount, source !== 'UndoRedo.undo'); + } + /** + * On before remove column listener. + * + * @private + * @param {number} column Column index. + * @param {number} amount An amount of removed columns. + */ + + }, { + key: "onBeforeRemoveCol", + value: function onBeforeRemoveCol(column, amount) { + this.undoRedoSnapshot.save('column', column, amount); + } + /** + * On after remove column listener. + * + * @private + * @param {number} column Column index. + * @param {number} amount An amount of created columns. + */ + + }, { + key: "onAfterRemoveCol", + value: function onAfterRemoveCol(column, amount) { + this.sheet.alterManager.triggerAlter('remove_column', column, amount); + } + /** + * On before column sorting listener. + * + * @private + * @param {number} column Sorted column index. + * @param {boolean} order Order type. + */ + + }, { + key: "onBeforeColumnSort", + value: function onBeforeColumnSort(column, order) { + this.sheet.alterManager.prepareAlter('column_sorting', column, order); + } + /** + * On after column sorting listener. + * + * @private + * @param {number} column Sorted column index. + * @param {boolean} order Order type. + */ + + }, { + key: "onAfterColumnSort", + value: function onAfterColumnSort(column, order) { + this.sheet.alterManager.triggerAlter('column_sorting', column, order); + } + /** + * On after load data listener. + * + * @private + */ + + }, { + key: "onAfterLoadData", + value: function onAfterLoadData() { + this._skipRendering = true; + this.recalculateFull(); + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.dataProvider.destroy(); + this.dataProvider = null; + this.sheet.destroy(); + this.sheet = null; + + _get$N(_getPrototypeOf$1f(Formulas.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$s; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$q; + } + }]); + + return Formulas; +}(BasePlugin); + +function _typeof$1s(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1s = function _typeof(obj) { return typeof obj; }; } else { _typeof$1s = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1s(obj); } + +function _classCallCheck$2y(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2s(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); } } + +function _createClass$2s(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2s(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2s(Constructor, staticProps); return Constructor; } + +function _get$O(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$O = Reflect.get; } else { _get$O = function _get(target, property, receiver) { var base = _superPropBase$O(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$O(target, property, receiver || target); } + +function _superPropBase$O(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1g(object); if (object === null) break; } return object; } + +function _inherits$1g(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1h(subClass, superClass); } + +function _setPrototypeOf$1h(o, p) { _setPrototypeOf$1h = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1h(o, p); } + +function _createSuper$1g(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1h(); return function _createSuperInternal() { var Super = _getPrototypeOf$1g(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1g(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1g(this, result); }; } + +function _possibleConstructorReturn$1g(self, call) { if (call && (_typeof$1s(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1g(self); } + +function _assertThisInitialized$1g(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1h() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1g(o) { _getPrototypeOf$1g = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1g(o); } +var PLUGIN_KEY$t = 'headerTooltips'; +var PLUGIN_PRIORITY$r = 270; +var isDeprecationMessageShowed = false; +/** + * @plugin HeaderTooltips + * + * @deprecated This plugin is deprecated and will be removed in the next major release. + * @description + * Allows to add a tooltip to the table headers. + * + * Available options: + * * the `rows` property defines if tooltips should be added to row headers, + * * the `columns` property defines if tooltips should be added to column headers, + * * the `onlyTrimmed` property defines if tooltips should be added only to headers, which content is trimmed by the header itself (the content being wider then the header). + * + * @example + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData(), + * // enable and configure header tooltips + * headerTooltips: { + * rows: true, + * columns: true, + * onlyTrimmed: false + * } + * }); + * ``` + */ + +var HeaderTooltips = /*#__PURE__*/function (_BasePlugin) { + _inherits$1g(HeaderTooltips, _BasePlugin); + + var _super = _createSuper$1g(HeaderTooltips); + + function HeaderTooltips(hotInstance) { + var _this; + + _classCallCheck$2y(this, HeaderTooltips); + + _this = _super.call(this, hotInstance); + /** + * Cached plugin settings. + * + * @private + * @type {boolean|object} + */ + + _this.settings = null; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link HeaderTooltips#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$2s(HeaderTooltips, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$t]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + if (!isDeprecationMessageShowed) { + isDeprecationMessageShowed = true; + warn('The Header Tooltips plugin is deprecated and will be removed in the next major release'); + } + + this.settings = this.hot.getSettings()[PLUGIN_KEY$t]; + this.parseSettings(); + this.addHook('afterGetColHeader', function (col, TH) { + return _this2.onAfterGetHeader(col, TH); + }); + this.addHook('afterGetRowHeader', function (col, TH) { + return _this2.onAfterGetHeader(col, TH); + }); + + _get$O(_getPrototypeOf$1g(HeaderTooltips.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.settings = null; + this.clearTitleAttributes(); + + _get$O(_getPrototypeOf$1g(HeaderTooltips.prototype), "disablePlugin", this).call(this); + } + /** + * Parses the plugin settings. + * + * @private + */ + + }, { + key: "parseSettings", + value: function parseSettings() { + if (typeof this.settings === 'boolean') { + this.settings = { + rows: true, + columns: true, + onlyTrimmed: false + }; + } + } + /** + * Clears the previously assigned title attributes. + * + * @private + */ + + }, { + key: "clearTitleAttributes", + value: function clearTitleAttributes() { + var headerLevels = this.hot.view.wt.getSetting('columnHeaders').length; + var mainHeaders = this.hot.view.wt.wtTable.THEAD; + var topHeaders = this.hot.view.wt.wtOverlays.topOverlay.clone.wtTable.THEAD; + var topLeftCornerOverlay = this.hot.view.wt.wtOverlays.topLeftCornerOverlay; + var topLeftCornerHeaders = topLeftCornerOverlay ? topLeftCornerOverlay.clone.wtTable.THEAD : null; + rangeEach(0, headerLevels - 1, function (i) { + var masterLevel = mainHeaders.childNodes[i]; + var topLevel = topHeaders.childNodes[i]; + var topLeftCornerLevel = topLeftCornerHeaders ? topLeftCornerHeaders.childNodes[i] : null; + rangeEach(0, masterLevel.childNodes.length - 1, function (j) { + masterLevel.childNodes[j].removeAttribute('title'); + + if (topLevel && topLevel.childNodes[j]) { + topLevel.childNodes[j].removeAttribute('title'); + } + + if (topLeftCornerHeaders && topLeftCornerLevel && topLeftCornerLevel.childNodes[j]) { + topLeftCornerLevel.childNodes[j].removeAttribute('title'); + } + }); + }); + } + /** + * Adds a tooltip to the headers. + * + * @private + * @param {number} index Visual column index. + * @param {HTMLElement} TH Header's TH element. + */ + + }, { + key: "onAfterGetHeader", + value: function onAfterGetHeader(index, TH) { + var innerSpan = TH.querySelector('span'); + var isColHeader = TH.parentNode.parentNode.nodeName === 'THEAD'; + + if (isColHeader && this.settings.columns || !isColHeader && this.settings.rows) { + if (this.settings.onlyTrimmed) { + if (outerWidth(innerSpan) >= outerWidth(TH) && outerWidth(innerSpan) !== 0) { + TH.setAttribute('title', innerSpan.textContent); + } + } else { + TH.setAttribute('title', innerSpan.textContent); + } + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.settings = null; + + _get$O(_getPrototypeOf$1g(HeaderTooltips.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$t; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$r; + } + }]); + + return HeaderTooltips; +}(BasePlugin); + +/** + * Default properties for nested header settings. + * + * @type {object} + */ +var HEADER_DEFAULT_SETTINGS = { + /** + * The name/label of the column header. + * + * @type {string} + */ + label: '', + + /** + * Current calculated colspan value of the rendered column header element. + * + * @type {number} + */ + colspan: 1, + + /** + * Original colspan value, set once while parsing user-defined nested header settings. + * + * @type {number} + */ + origColspan: 1, + + /** + * The flag which determines whether the node is collapsible (can be collpased/expanded). + * + * @type {boolean} + */ + collapsible: false, + + /** + * The flag which determines whether the node was collapsed. + * + * @type {boolean} + */ + isCollapsed: false, + + /** + * The flag which determines whether the column header should be rendered as hidden (display: none). + * + * @type {boolean} + */ + isHidden: false, + + /** + * The flag which determines whether the column header settings is accually not renderable. That kind + * of objects are generated after colspaned header to fill an array to correct size. + * + * For example for header with colspan = 8 the 7 blank objects are generated to fil an array settings + * to length = 8. + * + * @type {boolean} + */ + isBlank: false +}; +/** + * List of properties which are configurable. That properties can be changed using public API. + * + * @type {string[]} + */ + +var HEADER_CONFIGURABLE_PROPS = ['label', 'collapsible']; + +function _toConsumableArray$r(arr) { return _arrayWithoutHoles$p(arr) || _iterableToArray$r(arr) || _unsupportedIterableToArray$10(arr) || _nonIterableSpread$p(); } + +function _nonIterableSpread$p() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$10(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$10(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$10(o, minLen); } + +function _iterableToArray$r(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$p(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$10(arr); } + +function _arrayLikeToArray$10(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function ownKeys$b(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$a(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$b(Object(source), true).forEach(function (key) { _defineProperty$k(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$b(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$k(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +/** + * A function that normalizes user-defined settings into one predictable + * structure. Currently, the developer can declare nested headers by passing + * the following unstructured (and sometimes uncompleted) array. + * [ + * [{ label: 'A1', colspan: 2 }], + * [{ label: true }, 'B2', 4], + * [], + * ] + * + * The normalization process equalizes the length of columns to each header + * layers to the same length and generates object settings with a common shape. + * So the above mentioned example will be normalized into this: + * [ + * [ + * { label: 'A1', colspan: 2, isHidden: false, ... }, + * { label: '', colspan: 1, isHidden: true, ... }, + * { label: '', colspan: 1, isHidden: false, ... }, + * ], + * [ + * { label: 'true', colspan: 1, isHidden: false, ... }, + * { label: 'B2', colspan: 1, isHidden: false, ... }, + * { label: '4', colspan: 1, isHidden: false, ... }, + * ], + * [ + * { label: '', colspan: 1, isHidden: false, ... }, + * { label: '', colspan: 1, isHidden: false, ... }, + * { label: '', colspan: 1, isHidden: false, ... }, + * ], + * ] + * + * @param {Array[]} sourceSettings An array with defined nested headers settings. + * @param {number} [columnsLimit=Infinity] A number of columns to which the structure + * will be trimmed. While trimming the colspan + * values are adjusted to preserve the original + * structure. + * @returns {Array[]} + */ + +function normalizeSettings(sourceSettings) { + var columnsLimit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Infinity; + var normalizedSettings = []; + + if (columnsLimit === 0) { + return normalizedSettings; + } // Normalize array items (header settings) into one shape - literal object with default props. + + + arrayEach(sourceSettings, function (headersSettings) { + var columns = []; + var columnIndex = 0; + normalizedSettings.push(columns); + arrayEach(headersSettings, function (sourceHeaderSettings) { + var headerSettings = _objectSpread$a({}, HEADER_DEFAULT_SETTINGS); + + if (isObject$1(sourceHeaderSettings)) { + var label = sourceHeaderSettings.label, + colspan = sourceHeaderSettings.colspan; + headerSettings.label = stringify(label); + + if (typeof colspan === 'number' && colspan > 1) { + headerSettings.colspan = colspan; + headerSettings.origColspan = colspan; + } + } else { + headerSettings.label = stringify(sourceHeaderSettings); + } + + columnIndex += headerSettings.origColspan; + var cancelProcessing = false; + + if (columnIndex >= columnsLimit) { + // Adjust the colspan value to not overlap the columns limit. + headerSettings.colspan = headerSettings.origColspan - (columnIndex - columnsLimit); + headerSettings.origColspan = headerSettings.colspan; + cancelProcessing = true; + } + + columns.push(headerSettings); + + if (headerSettings.colspan > 1) { + for (var i = 0; i < headerSettings.colspan - 1; i++) { + columns.push(_objectSpread$a(_objectSpread$a({}, HEADER_DEFAULT_SETTINGS), {}, { + isHidden: true, + isBlank: true + })); + } + } + + return !cancelProcessing; + }); + }); + var columnsLength = Math.max.apply(Math, _toConsumableArray$r(arrayMap(normalizedSettings, function (headersSettings) { + return headersSettings.length; + }))); // Normalize the length of each header layer to the same columns length. + + arrayEach(normalizedSettings, function (headersSettings) { + if (headersSettings.length < columnsLength) { + var defaultSettings = arrayMap(new Array(columnsLength - headersSettings.length), function () { + return _objectSpread$a({}, HEADER_DEFAULT_SETTINGS); + }); + headersSettings.splice.apply(headersSettings, [headersSettings.length, 0].concat(_toConsumableArray$r(defaultSettings))); + } + }); + return normalizedSettings; +} + +function ownKeys$c(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$b(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$c(Object(source), true).forEach(function (key) { _defineProperty$l(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$c(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$l(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _objectWithoutProperties$6(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$6(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose$6(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +function _classCallCheck$2z(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2t(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); } } + +function _createClass$2t(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2t(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2t(Constructor, staticProps); return Constructor; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; } +/** + * The class manages and normalizes settings passed by the developer + * into the nested headers plugin. The SourceSettings class is a + * source of truth for tree builder (HeaderTree) module. + * + * @class SourceSettings + * @plugin NestedHeaders + */ + +var _data = new WeakMap(); + +var _dataLength = new WeakMap(); + +var _columnsLimit = new WeakMap(); + +var SourceSettings = /*#__PURE__*/function () { + function SourceSettings() { + _classCallCheck$2z(this, SourceSettings); + + _data.set(this, { + writable: true, + value: [] + }); + + _dataLength.set(this, { + writable: true, + value: 0 + }); + + _columnsLimit.set(this, { + writable: true, + value: Infinity + }); + } + + _createClass$2t(SourceSettings, [{ + key: "setColumnsLimit", + value: + /** + * Sets columns limit to the source settings will be trimmed. All headers which + * overlap the column limit will be reduced to keep the structure solid. + * + * @param {number} columnsCount The number of columns to limit to. + */ + function setColumnsLimit(columnsCount) { + _classPrivateFieldSet(this, _columnsLimit, columnsCount); + } + /** + * Sets a new nested header configuration. + * + * @param {Array[]} [nestedHeadersSettings=[]] The user-defined nested headers settings. + */ + + }, { + key: "setData", + value: function setData() { + var nestedHeadersSettings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + + _classPrivateFieldSet(this, _data, normalizeSettings(nestedHeadersSettings, _classPrivateFieldGet(this, _columnsLimit))); + + _classPrivateFieldSet(this, _dataLength, _classPrivateFieldGet(this, _data).length); + } + /** + * Gets normalized source settings. + * + * @returns {Array[]} + */ + + }, { + key: "getData", + value: function getData() { + return _classPrivateFieldGet(this, _data); + } + /** + * Merges settings with current source settings. + * + * @param {object[]} additionalSettings An array of objects with `row`, `col` and additional + * properties to merge with current source settings. + */ + + }, { + key: "mergeWith", + value: function mergeWith(additionalSettings) { + var _this = this; + + arrayEach(additionalSettings, function (_ref) { + var row = _ref.row, + col = _ref.col, + rest = _objectWithoutProperties$6(_ref, ["row", "col"]); + + var headerSettings = _this.getHeaderSettings(row, col); + + if (headerSettings !== null) { + extend(headerSettings, rest, HEADER_CONFIGURABLE_PROPS); + } + }); + } + /** + * Maps the current state with a callback. For each source settings the callback function + * is called. If the function returns value that value is merged with the source settings. + * + * @param {Function} callback A function that is called for every header settings. + * Each time the callback is called, the returned value extends + * header settings. + */ + + }, { + key: "map", + value: function map(callback) { + arrayEach(_classPrivateFieldGet(this, _data), function (header) { + arrayEach(header, function (headerSettings) { + var propsToExtend = callback(_objectSpread$b({}, headerSettings)); + + if (isObject$1(propsToExtend)) { + extend(headerSettings, propsToExtend, HEADER_CONFIGURABLE_PROPS); + } + }); + }); + } + /** + * Gets source column header settings for a specified header. The returned + * object contains information about the header label, its colspan length, + * or if it is hidden in the header renderers. + * + * @param {number} headerLevel Header level (0 = most distant to the table). + * @param {number} columnIndex A visual column index. + * @returns {object|null} + */ + + }, { + key: "getHeaderSettings", + value: function getHeaderSettings(headerLevel, columnIndex) { + var _headersSettings$colu; + + if (headerLevel >= _classPrivateFieldGet(this, _dataLength) || headerLevel < 0) { + return null; + } + + var headersSettings = _classPrivateFieldGet(this, _data)[headerLevel]; + + if (columnIndex >= headersSettings.length) { + return null; + } + + return (_headersSettings$colu = headersSettings[columnIndex]) !== null && _headersSettings$colu !== void 0 ? _headersSettings$colu : null; + } + /** + * Gets source of column headers settings for specified headers. If the retrieved column + * settings overlap the range "box" determined by "columnIndex" and "columnsLength" + * the exception will be thrown. + * + * @param {number} headerLevel Header level (0 = most distant to the table). + * @param {number} columnIndex A visual column index from which the settings will be extracted. + * @param {number} [columnsLength=1] The number of columns involved in the extraction of settings. + * @returns {object} + */ + + }, { + key: "getHeadersSettings", + value: function getHeadersSettings(headerLevel, columnIndex) { + var columnsLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1; + var headersSettingsChunks = []; + + if (headerLevel >= _classPrivateFieldGet(this, _dataLength) || headerLevel < 0) { + return headersSettingsChunks; + } + + var headersSettings = _classPrivateFieldGet(this, _data)[headerLevel]; + + var currentLength = 0; + + for (var i = columnIndex; i < headersSettings.length; i++) { + var headerSettings = headersSettings[i]; + + if (headerSettings.isHidden === true) { + throw new Error('The first column settings cannot overlap the other header layers'); + } + + currentLength += headerSettings.colspan; + headersSettingsChunks.push(headerSettings); + + if (headerSettings.colspan > 1) { + i += headerSettings.colspan - 1; + } // We met the current sum of the child colspans + + + if (currentLength === columnsLength) { + break; + } // We exceeds the current sum of the child colspans, the last columns colspan overlaps the "columnsLength" length. + + + if (currentLength > columnsLength) { + throw new Error('The last column settings cannot overlap the other header layers'); + } + } + + return headersSettingsChunks; + } + /** + * Gets a total number of headers levels. + * + * @returns {number} + */ + + }, { + key: "getLayersCount", + value: function getLayersCount() { + return _classPrivateFieldGet(this, _dataLength); + } + /** + * Gets a total number of columns count. + * + * @returns {number} + */ + + }, { + key: "getColumnsCount", + value: function getColumnsCount() { + return _classPrivateFieldGet(this, _dataLength) > 0 ? _classPrivateFieldGet(this, _data)[0].length : 0; + } + /** + * Clears the data. + */ + + }, { + key: "clear", + value: function clear() { + _classPrivateFieldSet(this, _data, []); + + _classPrivateFieldSet(this, _dataLength, 0); + } + }]); + + return SourceSettings; +}(); + +function ownKeys$d(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$c(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$d(Object(source), true).forEach(function (key) { _defineProperty$m(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$d(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck$2A(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2u(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); } } + +function _createClass$2u(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2u(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2u(Constructor, staticProps); return Constructor; } + +function _defineProperty$m(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _toConsumableArray$s(arr) { return _arrayWithoutHoles$q(arr) || _iterableToArray$s(arr) || _unsupportedIterableToArray$11(arr) || _nonIterableSpread$q(); } + +function _nonIterableSpread$q() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$11(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$11(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$11(o, minLen); } + +function _iterableToArray$s(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$q(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$11(arr); } + +function _arrayLikeToArray$11(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +/** + * Depth-first pre-order strategy (https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)). + * + * @type {string} + */ +var TRAVERSAL_DF_PRE = 'DF-pre-order'; +/** + * @param {Function} callback A callback which will be called on each visited node. + * @param {*} context A context to pass through. + * @returns {boolean} + */ + +function depthFirstPreOrder(callback, context) { + var continueTraverse = callback.call(context, this); + + for (var i = 0; i < this.childs.length; i++) { + if (continueTraverse === false) { + return false; + } + + continueTraverse = depthFirstPreOrder.call(this.childs[i], callback, context); + } + + return continueTraverse; +} +/** + * Depth-first post-order strategy (https://en.wikipedia.org/wiki/Tree_traversal#Post-order_(NLR)). + * + * @type {string} + */ + +var TRAVERSAL_DF_POST = 'DF-post-order'; +/** + * @param {Function} callback A callback which will be called on each visited node. + * @param {*} context A context to pass through. + * @returns {boolean} + */ + +function depthFirstPostOrder(callback, context) { + for (var i = 0; i < this.childs.length; i++) { + var continueTraverse = depthFirstPostOrder.call(this.childs[i], callback, context); + + if (continueTraverse === false) { + return false; + } + } + + return callback.call(context, this); +} +/** + * Breadth-first traversal strategy (https://en.wikipedia.org/wiki/Tree_traversal#Breadth-first_search_/_level_order). + * + * @type {string} + */ + + +var TRAVERSAL_BF = 'BF'; +/** + * @param {Function} callback A callback which will be called on each visited node. + * @param {*} context A context to pass through. + */ + +function breadthFirst(callback, context) { + var queue = [this]; + /** + * Internal processor. + */ + + function process() { + if (queue.length === 0) { + return; + } + + var node = queue.shift(); + queue.push.apply(queue, _toConsumableArray$s(node.childs)); + + if (callback.call(context, node) !== false) { + process(); + } + } + + process(); +} +/** + * Default strategy for tree traversal. + * + * @type {string} + */ + + +var DEFAULT_TRAVERSAL_STRATEGY = TRAVERSAL_BF; +/** + * Collection of all available tree traversal strategies. + * + * @type {Map} + */ + +var TRAVERSAL_STRATEGIES = new Map([[TRAVERSAL_DF_PRE, depthFirstPreOrder], [TRAVERSAL_DF_POST, depthFirstPostOrder], [TRAVERSAL_BF, breadthFirst]]); +/** + * + */ + +var TreeNode = /*#__PURE__*/function () { + /** + * A tree data. + * + * @type {object} + */ + + /** + * A parent node. + * + * @type {TreeNode} + */ + + /** + * A tree leaves. + * + * @type {TreeNode[]} + */ + function TreeNode(data) { + _classCallCheck$2A(this, TreeNode); + + _defineProperty$m(this, "data", {}); + + _defineProperty$m(this, "parent", null); + + _defineProperty$m(this, "childs", []); + + this.data = data; + } + /** + * Adds a node to tree leaves. Added node is linked with the parent node through "parent" property. + * + * @param {TreeNode} node A TreeNode to add. + */ + + + _createClass$2u(TreeNode, [{ + key: "addChild", + value: function addChild(node) { + node.parent = this; + this.childs.push(node); + } + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * @memberof TreeNode# + * @function cloneTree + * + * Clones a tree structure deeply. + * + * For example, for giving a tree structure: + * .--(B1)--. + * .-(C1) .-(C2)-.----. + * (D1) (D2) (D3) (D4) + * + * Cloning a tree starting from C2 node creates a mirrored tree structure. + * .-(C2')-.-----. + * (D2') (D3') (D4') + * + * The cloned tree can be safely modified without affecting the original structure. + * After modification, the clone can be merged with a tree using the "replaceTreeWith" method. + * + * @param {TreeNode} [nodeTree=this] A TreeNode to clone. + * @returns {TreeNode} + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + }, { + key: "cloneTree", + value: function cloneTree() { + var nodeTree = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this; + var clonedNode = new TreeNode(_objectSpread$c({}, nodeTree.data)); + + for (var i = 0; i < nodeTree.childs.length; i++) { + clonedNode.addChild(this.cloneTree(nodeTree.childs[i])); + } + + return clonedNode; + } + /** + * Replaces the current node with a passed tree structure. + * + * @param {TreeNode} nodeTree A TreeNode to replace with. + */ + + }, { + key: "replaceTreeWith", + value: function replaceTreeWith(nodeTree) { + this.data = _objectSpread$c({}, nodeTree.data); + this.childs = []; + + for (var i = 0; i < nodeTree.childs.length; i++) { + this.addChild(nodeTree.childs[i]); + } + } + /** + * Traverses the tree structure through node childs. The walk down traversing supports + * a three different strategies. + * - Depth-first pre-order strategy (https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)); + * - Depth-first post-order strategy (https://en.wikipedia.org/wiki/Tree_traversal#Post-order_(NLR)); + * - Breadth-first traversal strategy (https://en.wikipedia.org/wiki/Tree_traversal#Breadth-first_search_/_level_order). + * + * @param {Function} callback The callback function which will be called for each node. + * @param {string} [traversalStrategy=DEFAULT_TRAVERSAL_STRATEGY] Traversing strategy. + */ + + }, { + key: "walkDown", + value: function walkDown(callback) { + var traversalStrategy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_TRAVERSAL_STRATEGY; + + if (!TRAVERSAL_STRATEGIES.has(traversalStrategy)) { + throw new Error("Traversal strategy \"".concat(traversalStrategy, "\" does not exist")); + } + + TRAVERSAL_STRATEGIES.get(traversalStrategy).call(this, callback, this); + } + /** + * Traverses the tree structure through node parents. + * + * @param {Function} callback The callback function which will be called for each node. + */ + + }, { + key: "walkUp", + value: function walkUp(callback) { + var context = this; + + var process = function process(node) { + var continueTraverse = callback.call(context, node); + + if (continueTraverse !== false && node.parent !== null) { + process(node.parent); + } + }; + + process(this); + } + }]); + + return TreeNode; +}(); + +function ownKeys$e(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$d(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$e(Object(source), true).forEach(function (key) { _defineProperty$n(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$e(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$n(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _slicedToArray$K(arr, i) { return _arrayWithHoles$M(arr) || _iterableToArrayLimit$K(arr, i) || _unsupportedIterableToArray$12(arr, i) || _nonIterableRest$M(); } + +function _nonIterableRest$M() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$12(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$12(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$12(o, minLen); } + +function _arrayLikeToArray$12(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$K(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$M(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck$2B(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2v(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); } } + +function _createClass$2v(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2v(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2v(Constructor, staticProps); return Constructor; } + +function _classPrivateFieldGet$1(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet$1(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; } +/* eslint-disable jsdoc/require-description-complete-sentence */ + +/** + * @class HeadersTree + * + * The header tree class keeps nested header settings in the tree + * structure for easier node manipulation (e.q collapse or expand column). + * That trees represent the current state of the nested headers. From the + * trees, the matrix is generated for nested header renderers. + * + * The second role of the module is validation. While building the tree, + * there is check whether the configuration contains overlapping + * headers. If true, then the exception is thrown. + * + * The tree is static; it means that its column indexing never changes + * even when a collapsing header is performed. The structure is based + * on visual column indexes. + * + * For example, for that header configuration: + * +----+----+----+----+----+ + * │ A1 │ A2 │ + * +----+----+----+----+----+ + * │ B1 │ B2 │ B3 │ + * +----+----+----+----+----+ + * │ C1 │ C2 │ C3 │ C4 │ + * +----+----+----+----+----+ + * + * The tree structures look like: + * (0) (4) // a visual column index + * │ │ + * .------(A1)------. (A2)--. + * .--(B1)--. (B2)--. (B3)--. + * (C1) (C2) (C3) (C4) + * + * @plugin NestedHeaders + */ + +/* eslint-enable jsdoc/require-description-complete-sentence */ + +var _rootNodes = new WeakMap(); + +var _rootsIndex = new WeakMap(); + +var _sourceSettings = new WeakMap(); + +var HeadersTree = /*#__PURE__*/function () { + /** + * The collection of nested headers settings structured into trees. The root trees are stored + * under the visual column index. + * + * @private + * @type {Map} + */ + + /** + * A map that translates the visual column indexes that intersect the range + * defined by the header colspan width to the root index. + * + * @private + * @type {Map} + */ + + /** + * The instance of the SourceSettings class. + * + * @private + * @type {SourceSettings} + */ + function HeadersTree(sourceSettings) { + _classCallCheck$2B(this, HeadersTree); + + _rootNodes.set(this, { + writable: true, + value: new Map() + }); + + _rootsIndex.set(this, { + writable: true, + value: new Map() + }); + + _sourceSettings.set(this, { + writable: true, + value: null + }); + + _classPrivateFieldSet$1(this, _sourceSettings, sourceSettings); + } + /** + * Gets an array of the all root nodes. + * + * @returns {TreeNode[]} + */ + + + _createClass$2v(HeadersTree, [{ + key: "getRoots", + value: function getRoots() { + return Array.from(_classPrivateFieldGet$1(this, _rootNodes).values()); + } + /** + * Gets a root node by specified visual column index. + * + * @param {number} columnIndex A visual column index. + * @returns {TreeNode|undefined} + */ + + }, { + key: "getRootByColumn", + value: function getRootByColumn(columnIndex) { + var node; + + if (_classPrivateFieldGet$1(this, _rootsIndex).has(columnIndex)) { + node = _classPrivateFieldGet$1(this, _rootNodes).get(_classPrivateFieldGet$1(this, _rootsIndex).get(columnIndex)); + } + + return node; + } + /** + * Gets a tree node by its position in the grid settings. + * + * @param {number} headerLevel Header level index (there is support only for positive values). + * @param {number} columnIndex A visual column index. + * @returns {TreeNode|undefined} + */ + + }, { + key: "getNode", + value: function getNode(headerLevel, columnIndex) { + var rootNode = this.getRootByColumn(columnIndex); + + if (!rootNode) { + return; + } // Normalize the visual column index to a 0-based system for a specific "box" defined + // by root node colspan width. + + + var normColumnIndex = columnIndex - _classPrivateFieldGet$1(this, _rootsIndex).get(columnIndex); + + var columnCursor = 0; + var treeNode; // Collect all parent nodes that depend on the collapsed node. + + rootNode.walkDown(function (node) { + var _node$data = node.data, + origColspan = _node$data.origColspan, + nodeHeaderLevel = _node$data.headerLevel; + + if (headerLevel === nodeHeaderLevel) { + if (normColumnIndex >= columnCursor && normColumnIndex <= columnCursor + origColspan - 1) { + treeNode = node; + return false; // Cancel tree traversing. + } + + columnCursor += origColspan; + } + }); + return treeNode; + } + /** + * Builds (or rebuilds if called again) root nodes indexes. + */ + + }, { + key: "rebuildTreeIndex", + value: function rebuildTreeIndex() { + var _this = this; + + var columnIndex = 0; + + _classPrivateFieldGet$1(this, _rootsIndex).clear(); + + arrayEach(_classPrivateFieldGet$1(this, _rootNodes), function (_ref) { + var _ref2 = _slicedToArray$K(_ref, 2), + colspan = _ref2[1].data.colspan; + + // Map tree range (colspan range/width) into visual column index of the root node. + for (var i = columnIndex; i < columnIndex + colspan; i++) { + _classPrivateFieldGet$1(_this, _rootsIndex).set(i, columnIndex); + } + + columnIndex += colspan; + }); + } + /** + * Builds trees based on SourceSettings class. Calling a method causes clearing the tree state built + * from the previous call. + */ + + }, { + key: "buildTree", + value: function buildTree() { + this.clear(); + + var columnsCount = _classPrivateFieldGet$1(this, _sourceSettings).getColumnsCount(); + + var columnIndex = 0; + + while (columnIndex < columnsCount) { + var columnSettings = _classPrivateFieldGet$1(this, _sourceSettings).getHeaderSettings(0, columnIndex); + + var rootNode = new TreeNode(); + + _classPrivateFieldGet$1(this, _rootNodes).set(columnIndex, rootNode); + + this.buildLeaves(rootNode, columnIndex, 0, columnSettings.origColspan); + columnIndex += columnSettings.origColspan; + } + + this.rebuildTreeIndex(); + } + /** + * Builds leaves for specified tree node. + * + * @param {TreeNode} parentNode A node to which the leaves applies. + * @param {number} columnIndex A visual column index. + * @param {number} headerLevel Currently processed header level. + * @param {number} [extractionLength=1] Determines column extraction length for node children. + */ + + }, { + key: "buildLeaves", + value: function buildLeaves(parentNode, columnIndex, headerLevel) { + var _this2 = this; + + var extractionLength = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1; + + var columnsSettings = _classPrivateFieldGet$1(this, _sourceSettings).getHeadersSettings(headerLevel, columnIndex, extractionLength); + + headerLevel += 1; + arrayEach(columnsSettings, function (columnSettings) { + var nodeData = _objectSpread$d(_objectSpread$d({}, columnSettings), {}, { + headerLevel: headerLevel - 1, + columnIndex: columnIndex + }); + + var node; + + if (headerLevel === 1) { + // fill the root node + parentNode.data = nodeData; + node = parentNode; + } else { + node = new TreeNode(nodeData); + parentNode.addChild(node); + } + + if (headerLevel < _classPrivateFieldGet$1(_this2, _sourceSettings).getLayersCount()) { + _this2.buildLeaves(node, columnIndex, headerLevel, columnSettings.origColspan); + } + + columnIndex += columnSettings.origColspan; + }); + } + /** + * Clears the tree to the initial state. + */ + + }, { + key: "clear", + value: function clear() { + _classPrivateFieldGet$1(this, _rootNodes).clear(); + + _classPrivateFieldGet$1(this, _rootsIndex).clear(); + } + }]); + + return HeadersTree; +}(); + +function _classCallCheck$2C(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2w(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); } } + +function _createClass$2w(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2w(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2w(Constructor, staticProps); return Constructor; } + +function _defineProperty$o(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +/** + * The NodeModifiers module is responsible for the modification of a tree + * structure in a way to achieve new column headers state. + * + * @class NodeModifiers + * @plugin NestedHeaders + */ + +var NodeModifiers = /*#__PURE__*/function () { + function NodeModifiers() { + _classCallCheck$2C(this, NodeModifiers); + } + + _createClass$2w(NodeModifiers, [{ + key: "collapseNode", + value: + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * @memberof NodeModifiers# + * @function collapseNode + * Collapsing a node is a process where the processing node is collapsed + * to the colspan width of the first child. All node children, except the + * first one, are hidden. To prevent losing a current state of node children + * on the right, all nodes are cloned (and restored while expanding), and + * only then original nodes are modified (hidden in this case). + * + * @param {TreeNode} nodeToProcess A tree node to process. + * @returns {object} result Returns an object with properties: + * - rollbackModification: The function that + * rollbacks the tree to the previous state. + * - affectedColumns: The list of the visual column + * indexes which are affected. That list is passed + * to the hiddens column logic. + * - colspanCompensation: The number of colspan by + * which the processed node colspan was reduced. + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + function collapseNode(nodeToProcess) { + var _getFirstChildPropert, + _this = this; + + var nodeData = nodeToProcess.data, + nodeChilds = nodeToProcess.childs; + + if (nodeData.isCollapsed === true || nodeData.isHidden === true || nodeData.origColspan <= 1) { + return { + rollbackModification: function rollbackModification() {}, + affectedColumns: [], + colspanCompensation: 0 + }; + } + + var isNodeReflected = isNodeReflectsFirstChildColspan(nodeToProcess); + + if (isNodeReflected) { + return this.collapseNode(nodeChilds[0]); + } + + nodeData.isCollapsed = true; + var allLeavesExceptMostLeft = nodeChilds.slice(1); + var affectedColumns = new Set(); + + if (allLeavesExceptMostLeft.length > 0) { + arrayEach(allLeavesExceptMostLeft, function (node) { + traverseHiddenNodeColumnIndexes(node, function (nodeColumnIndex) { + affectedColumns.add(nodeColumnIndex); + }); // Clone the tree to preserve original tree state after header expanding. + + node.data.clonedTree = node.cloneTree(); // Hide all leaves except the first leaf on the left (on headers context hide all + // headers on the right). + + node.walkDown(function (_ref) { + var data = _ref.data; + data.isHidden = true; + }); + }); + } else { + // Add column to "affected" started from 1. The header without children can not be + // collapsed so the first have to be visible (untouched). + for (var i = 1; i < nodeData.origColspan; i++) { + affectedColumns.add(nodeData.columnIndex + i); + } + } // Calculate by how many colspan it needs to reduce the headings to match them to + // the first child colspan width. + + + var colspanCompensation = nodeData.colspan - ((_getFirstChildPropert = getFirstChildProperty(nodeToProcess, 'colspan')) !== null && _getFirstChildPropert !== void 0 ? _getFirstChildPropert : 1); + nodeToProcess.walkUp(function (node) { + var data = node.data; + data.colspan -= colspanCompensation; + + if (data.colspan <= 1) { + data.colspan = 1; + data.isCollapsed = true; + } else if (isNodeReflectsFirstChildColspan(node)) { + data.isCollapsed = getFirstChildProperty(node, 'isCollapsed'); + } + }); + return { + rollbackModification: function rollbackModification() { + return _this.expandNode(nodeToProcess); + }, + affectedColumns: Array.from(affectedColumns), + colspanCompensation: colspanCompensation + }; + } + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * @memberof NodeModifiers# + * @function expandNode + * Expanding a node is a process where the processing node is expanded to + * its original colspan width. To restore an original state of all node + * children on the right, the modified nodes are replaced with the cloned + * nodes (they were cloned while collapsing). + * + * @param {TreeNode} nodeToProcess A tree node to process. + * @returns {object} result Returns an object with properties: + * - rollbackModification: The function that + * rollbacks the tree to the previous state. + * - affectedColumns: The list of the visual column + * indexes which are affected. That list is passed + * to the hiddens column logic. + * - colspanCompensation: The number of colspan by + * which the processed node colspan was increased. + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + }, { + key: "expandNode", + value: function expandNode(nodeToProcess) { + var _this2 = this; + + var nodeData = nodeToProcess.data, + nodeChilds = nodeToProcess.childs; + + if (nodeData.isCollapsed === false || nodeData.isHidden === true || nodeData.origColspan <= 1) { + return { + rollbackModification: function rollbackModification() {}, + affectedColumns: [], + colspanCompensation: 0 + }; + } + + var isNodeReflected = isNodeReflectsFirstChildColspan(nodeToProcess); + + if (isNodeReflected) { + return this.expandNode(nodeChilds[0]); + } + + nodeData.isCollapsed = false; + var allLeavesExceptMostLeft = nodeChilds.slice(1); + var affectedColumns = new Set(); + var colspanCompensation = 0; + + if (allLeavesExceptMostLeft.length > 0) { + arrayEach(allLeavesExceptMostLeft, function (node) { + // Restore original state of the collapsed headers. + node.replaceTreeWith(node.data.clonedTree); + node.data.clonedTree = null; + var leafData = node.data; // Calculate by how many colspan it needs to increase the headings to match them to + // the colspan width of all its children. + + colspanCompensation += leafData.colspan; + traverseHiddenNodeColumnIndexes(node, function (nodeColumnIndex) { + affectedColumns.add(nodeColumnIndex); + }); + }); + } else { + var colspan = nodeData.colspan, + origColspan = nodeData.origColspan, + columnIndex = nodeData.columnIndex; // In a case when the node doesn't have any children restore the colspan width to + // its original state. + + colspanCompensation = origColspan - colspan; // Add column to "affected" started from 1. The header without children can not be + // collapsed so the first column is already visible and we shouldn't touch it. + + for (var i = 1; i < origColspan; i++) { + affectedColumns.add(columnIndex + i); + } + } + + nodeToProcess.walkUp(function (node) { + var data = node.data; + data.colspan += colspanCompensation; + + if (data.colspan >= data.origColspan) { + data.colspan = data.origColspan; + data.isCollapsed = false; + } else if (isNodeReflectsFirstChildColspan(node)) { + data.isCollapsed = getFirstChildProperty(node, 'isCollapsed'); + } + }); + return { + rollbackModification: function rollbackModification() { + return _this2.collapseNode(nodeToProcess); + }, + affectedColumns: Array.from(affectedColumns), + colspanCompensation: colspanCompensation + }; + } + /** + * An entry point for triggering a node modifiers. If the triggered action + * does not exist the exception is thrown. + * + * @param {string} actionName An action name to trigger. + * @param {TreeNode} nodeToProcess A tree node to process. + * @returns {object} + */ + + }, { + key: "triggerAction", + value: function triggerAction(actionName, nodeToProcess) { + if (!NodeModifiers.AVAILABLE_ACTIONS.includes(actionName)) { + throw new Error("The node modifier action (\"".concat(actionName, "\") does not exist.")); + } + + return this["".concat(actionName, "Node")](nodeToProcess); + } + }]); + + return NodeModifiers; +}(); +/** + * Traverses the tree nodes and calls a callback when no hidden node is found. The callback + * is called with visual column index then. + * + * @param {TreeNode} node A tree node to traverse. + * @param {Function} callback The callback function which will be called for each node. + */ + + +_defineProperty$o(NodeModifiers, "AVAILABLE_ACTIONS", ['collapse', 'expand']); + +function traverseHiddenNodeColumnIndexes(node, callback) { + node.walkDown(function (_ref2) { + var data = _ref2.data, + childs = _ref2.childs; + + if (!data.isHidden) { + callback(data.columnIndex); + + if (childs.length === 0) { + for (var i = 1; i < data.colspan; i++) { + callback(data.columnIndex + i); + } + } + } + }); +} +/** + * A tree helper for retrieving a data from the first child. + * + * @param {TreeNode} node A tree node to check. + * @param {string} propertyName A name of the property whose value you want to get. + * @returns {*} + */ + + +function getFirstChildProperty(_ref3, propertyName) { + var childs = _ref3.childs; + + if (childs.length === 0) { + return; + } + + return childs[0].data[propertyName]; +} +/** + * A tree helper which checks if passed node has the same original colspan as its + * first child. In that case the node is treated as "mirrored" or "reflected" every + * action performed on one of that nodes should be reflected to other "mirrored" node. + * + * In that case nodes A1 and A2 are "refelcted" + * +----+----+----+----+ + * | A1 | B1 | + * +----+----+----+----+ + * | A2 | B2 | B3 | + * +----+----+----+----+. + * + * @param {TreeNode} node A tree node to check. + * @returns {boolean} + */ + + +function isNodeReflectsFirstChildColspan(node) { + return getFirstChildProperty(node, 'origColspan') === node.data.origColspan; +} + +function ownKeys$f(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$e(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$f(Object(source), true).forEach(function (key) { _defineProperty$p(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$f(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$p(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +/** + * A function that dump a tree structure into multidimensional array. That structure is + * later processed by header renderers to modify TH elements to achieve a proper + * DOM structure. + * + * That structure contains settings object for every TH element generated by Walkontable. + * The matrix operates on visual column index. + * + * Output example: + * [ + * [ + * { label: 'A1', colspan: 2, origColspan: 2, isHidden: false, ... }, + * { label: '', colspan: 1, origColspan: 1, isHidden: true, ... }, + * { label: '', colspan: 1, origColspan: 1, isHidden: false, ... }, + * ], + * [ + * { label: 'true', colspan: 1, origColspan: 1, isHidden: false, ... }, + * { label: 'B2', colspan: 1, origColspan: 1, isHidden: false, ... }, + * { label: '4', colspan: 1, origColspan: 1, isHidden: false, ... }, + * ], + * [ + * { label: '', colspan: 1, origColspan: 1, isHidden: false, ... }, + * { label: '', colspan: 1, origColspan: 1, isHidden: false, ... }, + * { label: '', colspan: 1, origColspan: 1, isHidden: false, ... }, + * ], + * ] + * + * @param {TreeNode[]} headerRoots An array of root nodes. + * @returns {Array[]} + */ + +function generateMatrix(headerRoots) { + var matrix = []; + arrayEach(headerRoots, function (rootNode) { + rootNode.walkDown(function (node) { + var _node$data = node.data, + colspan = _node$data.colspan, + origColspan = _node$data.origColspan, + label = _node$data.label, + isHidden = _node$data.isHidden, + headerLevel = _node$data.headerLevel, + collapsible = _node$data.collapsible, + isCollapsed = _node$data.isCollapsed; + var colspanHeaderLayer = createNestedArrayIfNecessary(matrix, headerLevel); + colspanHeaderLayer.push({ + label: label, + colspan: colspan, + origColspan: origColspan, + collapsible: collapsible, + isCollapsed: isCollapsed, + isHidden: isHidden, + isBlank: false + }); + + if (origColspan > 1) { + for (var i = 0; i < origColspan - 1; i++) { + colspanHeaderLayer.push(_objectSpread$e(_objectSpread$e({}, HEADER_DEFAULT_SETTINGS), {}, { + origColspan: origColspan, + isHidden: true, + isBlank: true + })); + } + } + }); + }); + return matrix; +} +/** + * Internal helper which ensures that subarray exists under specified index. + * + * @param {Array[]} array An array to check. + * @param {number} index An array index under the subarray should be checked. + * @returns {Array} + */ + +function createNestedArrayIfNecessary(array, index) { + var subArray; + + if (Array.isArray(array[index])) { + subArray = array[index]; + } else { + subArray = []; + array[index] = subArray; + } + + return subArray; +} + +function ownKeys$g(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread$f(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys$g(Object(source), true).forEach(function (key) { _defineProperty$q(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys$g(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty$q(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _objectWithoutProperties$7(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose$7(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; } + +function _objectWithoutPropertiesLoose$7(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; } + +function _classCallCheck$2D(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2x(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); } } + +function _createClass$2x(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2x(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2x(Constructor, staticProps); return Constructor; } + +function _classPrivateFieldSet$2(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; } + +function _classPrivateFieldGet$2(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } +/** + * The state manager is a source of truth for nested headers configuration. + * The state generation process is divided into three stages. + * + * +---------------------+ 1. User-defined configuration normalization; + * │ │ The source settings class normalizes and shares API for + * │ SourceSettings │ raw settings passed by the developer. It is only consumed by + * │ │ the header tree module. + * +---------------------+ + * │ + * \│/ + * +---------------------+ 2. Building a tree structure for validation and easier node manipulation; + * │ │ The header tree generates a tree based on source settings for future + * │ HeadersTree │ node manipulation (such as collapsible columns feature). While generating a tree + * │ │ the source settings is checked to see if the configuration has overlapping headers. + * +---------------------+ If `true` the colspan matrix generation is skipped, overlapped headers are not supported. + * │ + * \│/ + * +---------------------+ 3. Matrix generation; + * │ │ Based on built trees the matrix generation is performed. That part of code + * │ matrix generation │ generates an array structure similar to normalized data from the SourceSettings + * │ │ but with the difference that this structure contains column settings which changed + * +---------------------+ during runtime (after the tree manipulation) e.q after collapse or expand column. + * That settings describes how the TH element should be modified (colspan attribute, + * CSS classes, etc) for a specific column and layer level. + * + * @class StateManager + * @plugin NestedHeaders + */ + +var _sourceSettings$1 = new WeakMap(); + +var _nodeModifiers = new WeakMap(); + +var _headersTree = new WeakMap(); + +var _stateMatrix = new WeakMap(); + +var StateManager = /*#__PURE__*/function () { + function StateManager() { + _classCallCheck$2D(this, StateManager); + + _sourceSettings$1.set(this, { + writable: true, + value: new SourceSettings() + }); + + _nodeModifiers.set(this, { + writable: true, + value: new NodeModifiers() + }); + + _headersTree.set(this, { + writable: true, + value: new HeadersTree(_classPrivateFieldGet$2(this, _sourceSettings$1)) + }); + + _stateMatrix.set(this, { + writable: true, + value: [[]] + }); + } + + _createClass$2x(StateManager, [{ + key: "setState", + value: + /** + * Sets a new state for the nested headers plugin based on settings passed + * directly to the plugin. + * + * @param {Array[]} nestedHeadersSettings The user-defined settings. + * @returns {boolean} Returns `true` if the settings are processed correctly, `false` otherwise. + */ + function setState(nestedHeadersSettings) { + _classPrivateFieldGet$2(this, _sourceSettings$1).setData(nestedHeadersSettings); + + var hasError = false; + + try { + _classPrivateFieldGet$2(this, _headersTree).buildTree(); + } catch (ex) { + _classPrivateFieldGet$2(this, _headersTree).clear(); + + _classPrivateFieldGet$2(this, _sourceSettings$1).clear(); + + hasError = true; + } + + _classPrivateFieldSet$2(this, _stateMatrix, generateMatrix(_classPrivateFieldGet$2(this, _headersTree).getRoots())); + + return hasError; + } + /** + * Sets columns limit to the state will be trimmed. All headers (colspans) which + * overlap the column limit will be reduced to keep the structure solid. + * + * @param {number} columnsCount The number of columns to limit to. + */ + + }, { + key: "setColumnsLimit", + value: function setColumnsLimit(columnsCount) { + _classPrivateFieldGet$2(this, _sourceSettings$1).setColumnsLimit(columnsCount); + } + /** + * Merges settings with current plugin state. + * + * By default only foreign keys are merged with source state and passed to the tree. But only + * known keys are exported to matrix. + * + * @param {object[]} settings An array of objects to merge with the current source settings. + * It is a requirement that every object has `row` and `col` properties + * which points to the specific header settings object. + */ + + }, { + key: "mergeStateWith", + value: function mergeStateWith(settings) { + var _this = this; + + var transformedSettings = arrayMap(settings, function (_ref) { + var row = _ref.row, + rest = _objectWithoutProperties$7(_ref, ["row"]); + + return _objectSpread$f({ + row: row < 0 ? _this.rowCoordsToLevel(row) : row + }, rest); + }); + + _classPrivateFieldGet$2(this, _sourceSettings$1).mergeWith(transformedSettings); + + _classPrivateFieldGet$2(this, _headersTree).buildTree(); + + _classPrivateFieldSet$2(this, _stateMatrix, generateMatrix(_classPrivateFieldGet$2(this, _headersTree).getRoots())); + } + /** + * Maps the current state with a callback. For each header settings the callback function + * is called. If the function returns value that value is merged with the state. + * + * By default only foreign keys are merged with source state and passed to the tree. But only + * known keys are exported to matrix. + * + * @param {Function} callback A function that is called for every header source settings. + * Each time the callback is called, the returned value extends + * header settings. + */ + + }, { + key: "mapState", + value: function mapState(callback) { + _classPrivateFieldGet$2(this, _sourceSettings$1).map(callback); + + _classPrivateFieldGet$2(this, _headersTree).buildTree(); + + _classPrivateFieldSet$2(this, _stateMatrix, generateMatrix(_classPrivateFieldGet$2(this, _headersTree).getRoots())); + } + /** + * Maps the current tree nodes with a callback. For each node the callback function + * is called. If the function returns value that value is added to returned array. + * + * @param {Function} callback A function that is called for every tree node. + * Each time the callback is called, the returned value is + * added to returned array. + * @returns {Array} + */ + + }, { + key: "mapNodes", + value: function mapNodes(callback) { + return arrayReduce(_classPrivateFieldGet$2(this, _headersTree).getRoots(), function (acc, rootNode) { + rootNode.walkDown(function (node) { + var result = callback(node.data); + + if (result !== void 0) { + acc.push(result); + } + }); + return acc; + }, []); + } + /** + * Triggers an action (it can be "collapse" or "expand") from the NodeModifiers module. The module + * modifies a tree structure in such a way as to obtain the correct structure consistent with the + * called action. + * + * @param {string} action An action name to trigger. + * @param {number} headerLevel Header level index (there is support for negative and positive values). + * @param {number} columnIndex A visual column index. + * @returns {object|undefined} + */ + + }, { + key: "triggerNodeModification", + value: function triggerNodeModification(action, headerLevel, columnIndex) { + if (headerLevel < 0) { + headerLevel = this.rowCoordsToLevel(headerLevel); + } + + var nodeToProcess = _classPrivateFieldGet$2(this, _headersTree).getNode(headerLevel, columnIndex); + + var actionResult; + + if (nodeToProcess) { + actionResult = _classPrivateFieldGet$2(this, _nodeModifiers).triggerAction(action, nodeToProcess); + + _classPrivateFieldSet$2(this, _stateMatrix, generateMatrix(_classPrivateFieldGet$2(this, _headersTree).getRoots())); + } + + return actionResult; + } + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * @memberof StateManager# + * @function rowCoordsToLevel + * + * Translates row coordinates into header level. The row coordinates counts from -1 to -N + * and describes headers counting from most closest to most distant from the table. + * The header levels are counted from 0 to N where 0 describes most distant header + * from the table. + * + * Row coords Header level + * +--------------+ + * -3 │ A1 │ A1 │ 0 + * +--------------+ + * -2 │ B1 │ B2 │ B3 │ 1 + * +--------------+ + * -1 │ C1 │ C2 │ C3 │ 2 + * +==============+ + * │ │ │ │ + * +--------------+ + * │ │ │ │ + * + * @param {number} rowIndex A visual row index. + * @returns {number} Returns unsigned number. + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + }, { + key: "rowCoordsToLevel", + value: function rowCoordsToLevel(rowIndex) { + var layersCount = Math.max(this.getLayersCount(), 1); + var highestPossibleLevel = layersCount - 1; + var lowestPossibleLevel = 0; + return Math.min(Math.max(rowIndex + layersCount, lowestPossibleLevel), highestPossibleLevel); + } + /* eslint-disable jsdoc/require-description-complete-sentence */ + + /** + * @memberof StateManager# + * @function levelToRowCoords + * + * Translates header level into row coordinates. The row coordinates counts from -1 to -N + * and describes headers counting from most closest to most distant from the table. + * The header levels are counted from 0 to N where 0 describes most distant header + * from the table. + * + * Header level Row coords + * +--------------+ + * 0 │ A1 │ A1 │ -3 + * +--------------+ + * 1 │ B1 │ B2 │ B3 │ -2 + * +--------------+ + * 2 │ C1 │ C2 │ C3 │ -1 + * +==============+ + * │ │ │ │ + * +--------------+ + * │ │ │ │ + * + * @param {number} headerLevel Header level index. + * @returns {number} Returns negative number. + */ + + /* eslint-enable jsdoc/require-description-complete-sentence */ + + }, { + key: "levelToRowCoords", + value: function levelToRowCoords(headerLevel) { + var layersCount = Math.max(this.getLayersCount(), 1); + var highestPossibleRow = -1; + var lowestPossibleRow = -layersCount; + return Math.min(Math.max(headerLevel - layersCount, lowestPossibleRow), highestPossibleRow); + } + /** + * Gets column header settings for a specified column and header index. The returned object contains + * all information necessary for header renderers. It contains header label, colspan length, or hidden + * flag. + * + * @param {number} headerLevel Header level (there is support for negative and positive values). + * @param {number} columnIndex A visual column index. + * @returns {object} + */ + + }, { + key: "getHeaderSettings", + value: function getHeaderSettings(headerLevel, columnIndex) { + var _classPrivateFieldGet2, _classPrivateFieldGet3; + + if (headerLevel < 0) { + headerLevel = this.rowCoordsToLevel(headerLevel); + } + + if (headerLevel >= this.getLayersCount()) { + return _objectSpread$f({}, HEADER_DEFAULT_SETTINGS); + } + + return (_classPrivateFieldGet2 = (_classPrivateFieldGet3 = _classPrivateFieldGet$2(this, _stateMatrix)[headerLevel]) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3[columnIndex]) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : _objectSpread$f({}, HEADER_DEFAULT_SETTINGS); + } + /** + * The method is helpful in cases where the column index targets in-between currently + * collapsed column. In that case, the method returns the left-most column index + * where the nested header begins. + * + * @param {number} headerLevel Header level (there is support for negative and positive values). + * @param {number} columnIndex A visual column index. + * @returns {number} + */ + + }, { + key: "findLeftMostColumnIndex", + value: function findLeftMostColumnIndex(headerLevel, columnIndex) { + var _this$getHeaderSettin = this.getHeaderSettings(headerLevel, columnIndex), + isBlank = _this$getHeaderSettin.isBlank; + + if (isBlank === false) { + return columnIndex; + } + + var stepBackColumn = columnIndex - 1; + + do { + var _this$getHeaderSettin2 = this.getHeaderSettings(headerLevel, stepBackColumn), + blank = _this$getHeaderSettin2.isBlank; + + if (blank === false) { + break; + } + + stepBackColumn -= 1; + } while (columnIndex >= 0); + + return stepBackColumn; + } + /** + * Gets a total number of headers levels. + * + * @returns {number} + */ + + }, { + key: "getLayersCount", + value: function getLayersCount() { + return _classPrivateFieldGet$2(this, _sourceSettings$1).getLayersCount(); + } + /** + * Gets a total number of columns count. + * + * @returns {number} + */ + + }, { + key: "getColumnsCount", + value: function getColumnsCount() { + return _classPrivateFieldGet$2(this, _sourceSettings$1).getColumnsCount(); + } + /** + * Clears the column state manager to the initial state. + */ + + }, { + key: "clear", + value: function clear() { + _classPrivateFieldSet$2(this, _stateMatrix, []); + + _classPrivateFieldGet$2(this, _sourceSettings$1).clear(); + + _classPrivateFieldGet$2(this, _headersTree).clear(); + } + }]); + + return StateManager; +}(); + +function _classCallCheck$2E(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2y(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); } } + +function _createClass$2y(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2y(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2y(Constructor, staticProps); return Constructor; } + +var GhostTable$1 = /*#__PURE__*/function () { + function GhostTable(plugin) { + _classCallCheck$2E(this, GhostTable); + + /** + * Reference to NestedHeaders plugin. + * + * @type {NestedHeaders} + */ + this.nestedHeaders = plugin; + /** + * Temporary element created to get minimal headers widths. + * + * @type {*} + */ + + this.container = void 0; + /** + * Cached the headers widths. + * + * @type {Array} + */ + + this.widthsCache = []; + } + /** + * Build cache of the headers widths. + * + * @private + */ + + + _createClass$2y(GhostTable, [{ + key: "buildWidthsMapper", + value: function buildWidthsMapper() { + this.container = this.nestedHeaders.hot.rootDocument.createElement('div'); + this.buildGhostTable(this.container); + this.nestedHeaders.hot.rootElement.appendChild(this.container); + var columns = this.container.querySelectorAll('tr:last-of-type th'); + var maxColumns = columns.length; + this.widthsCache.length = 0; + + for (var i = 0; i < maxColumns; i++) { + this.widthsCache.push(columns[i].offsetWidth); + } + + this.container.parentNode.removeChild(this.container); + this.container = null; + this.nestedHeaders.hot.render(); + } + /** + * Build temporary table for getting minimal columns widths. + * + * @private + * @param {HTMLElement} container The element where the DOM nodes are injected. + */ + + }, { + key: "buildGhostTable", + value: function buildGhostTable(container) { + var rootDocument = this.nestedHeaders.hot.rootDocument; + var fragment = rootDocument.createDocumentFragment(); + var table = rootDocument.createElement('table'); + var lastRowColspan = false; + var isDropdownEnabled = !!this.nestedHeaders.hot.getSettings().dropdownMenu; + var maxRows = this.nestedHeaders.getLayersCount(); + var maxCols = this.nestedHeaders.hot.countCols(); + var lastRowIndex = maxRows - 1; + + for (var row = 0; row < maxRows; row++) { + var tr = rootDocument.createElement('tr'); + lastRowColspan = false; + + for (var col = 0; col < maxCols; col++) { + var td = rootDocument.createElement('th'); + var headerObj = clone(this.nestedHeaders.getHeaderSettings(row, col)); + + if (headerObj && !headerObj.isHidden) { + if (row === lastRowIndex) { + if (headerObj.colspan > 1) { + lastRowColspan = true; + } + + if (isDropdownEnabled) { + headerObj.label += ''; + } + } + + fastInnerHTML(td, headerObj.label); + td.colSpan = headerObj.colspan; + tr.appendChild(td); + } + } + + table.appendChild(tr); + } // We have to be sure the last row contains only the single columns. + + + if (lastRowColspan) { + { + var _tr = rootDocument.createElement('tr'); + + for (var _col = 0; _col < maxCols; _col++) { + var _td = rootDocument.createElement('th'); + + _tr.appendChild(_td); + } + + table.appendChild(_tr); + } + } + + fragment.appendChild(table); + container.appendChild(fragment); + } + /** + * Clear the widths cache. + */ + + }, { + key: "clear", + value: function clear() { + this.container = null; + this.widthsCache.length = 0; + } + }]); + + return GhostTable; +}(); + +function _typeof$1t(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1t = function _typeof(obj) { return typeof obj; }; } else { _typeof$1t = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1t(obj); } + +var _templateObject$c, _templateObject2$3; + +function _slicedToArray$L(arr, i) { return _arrayWithHoles$N(arr) || _iterableToArrayLimit$L(arr, i) || _unsupportedIterableToArray$13(arr, i) || _nonIterableRest$N(); } + +function _nonIterableRest$N() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$13(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$13(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$13(o, minLen); } + +function _arrayLikeToArray$13(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$L(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$N(arr) { if (Array.isArray(arr)) return arr; } + +function _taggedTemplateLiteral$c(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _classCallCheck$2F(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2z(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); } } + +function _createClass$2z(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2z(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2z(Constructor, staticProps); return Constructor; } + +function _get$P(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$P = Reflect.get; } else { _get$P = function _get(target, property, receiver) { var base = _superPropBase$P(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$P(target, property, receiver || target); } + +function _superPropBase$P(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1h(object); if (object === null) break; } return object; } + +function _inherits$1h(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1i(subClass, superClass); } + +function _setPrototypeOf$1i(o, p) { _setPrototypeOf$1i = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1i(o, p); } + +function _createSuper$1h(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1i(); return function _createSuperInternal() { var Super = _getPrototypeOf$1h(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1h(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1h(this, result); }; } + +function _possibleConstructorReturn$1h(self, call) { if (call && (_typeof$1t(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1h(self); } + +function _assertThisInitialized$1h(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1i() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1h(o) { _getPrototypeOf$1h = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1h(o); } + +function _defineProperty$r(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldSet$3(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; } + +function _classPrivateFieldGet$3(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } +var PLUGIN_KEY$u = 'nestedHeaders'; +var PLUGIN_PRIORITY$s = 280; +/** + * @plugin NestedHeaders + * @description + * The plugin allows to create a nested header structure, using the HTML's colspan attribute. + * + * To make any header wider (covering multiple table columns), it's corresponding configuration array element should be + * provided as an object with `label` and `colspan` properties. The `label` property defines the header's label, + * while the `colspan` property defines a number of columns that the header should cover. + * + * __Note__ that the plugin supports a *nested* structure, which means, any header cannot be wider than it's "parent". In + * other words, headers cannot overlap each other. + * @example + * + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData(), + * nestedHeaders: [ + * ['A', {label: 'B', colspan: 8}, 'C'], + * ['D', {label: 'E', colspan: 4}, {label: 'F', colspan: 4}, 'G'], + * ['H', {label: 'I', colspan: 2}, {label: 'J', colspan: 2}, {label: 'K', colspan: 2}, {label: 'L', colspan: 2}, 'M'], + * ['N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W'] + * ], + * ``` + */ + +var _stateManager = new WeakMap(); + +var NestedHeaders = /*#__PURE__*/function (_BasePlugin) { + _inherits$1h(NestedHeaders, _BasePlugin); + + var _super = _createSuper$1h(NestedHeaders); + + function NestedHeaders() { + var _this; + + _classCallCheck$2F(this, NestedHeaders); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _stateManager.set(_assertThisInitialized$1h(_this), { + writable: true, + value: new StateManager() + }); + + _defineProperty$r(_assertThisInitialized$1h(_this), "ghostTable", new GhostTable$1(_assertThisInitialized$1h(_this))); + + _defineProperty$r(_assertThisInitialized$1h(_this), "detectedOverlappedHeaders", false); + + return _this; + } + + _createClass$2z(NestedHeaders, [{ + key: "isEnabled", + value: + /** + * Check if plugin is enabled. + * + * @returns {boolean} + */ + function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$u]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var _this$hot$getSettings = this.hot.getSettings(), + nestedHeaders = _this$hot$getSettings.nestedHeaders; + + if (!Array.isArray(nestedHeaders) || !Array.isArray(nestedHeaders[0])) { + warn(toSingleLine(_templateObject$c || (_templateObject$c = _taggedTemplateLiteral$c(["Your Nested Headers plugin configuration is invalid. The settings has to be \n passed as an array of arrays e.q. [['A1', { label: 'A2', colspan: 2 }]]"], ["Your Nested Headers plugin configuration is invalid. The settings has to be\\x20\n passed as an array of arrays e.q. [['A1', { label: 'A2', colspan: 2 }]]"])))); + } + + this.addHook('init', function () { + return _this2.onInit(); + }); + this.addHook('afterLoadData', function () { + return _this2.onAfterLoadData.apply(_this2, arguments); + }); + this.addHook('afterOnCellMouseDown', function (event, coords) { + return _this2.onAfterOnCellMouseDown(event, coords); + }); + this.addHook('beforeOnCellMouseOver', function (event, coords, TD, blockCalculations) { + return _this2.onBeforeOnCellMouseOver(event, coords, TD, blockCalculations); + }); + this.addHook('afterGetColumnHeaderRenderers', function (array) { + return _this2.onAfterGetColumnHeaderRenderers(array); + }); + this.addHook('modifyColWidth', function (width, column) { + return _this2.onModifyColWidth(width, column); + }); + this.addHook('afterViewportColumnCalculatorOverride', function (calc) { + return _this2.onAfterViewportColumnCalculatorOverride(calc); + }); + + _get$P(_getPrototypeOf$1h(NestedHeaders.prototype), "enablePlugin", this).call(this); + + this.updatePlugin(); // @TODO: Workaround for broken plugin initialization abstraction. + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + if (!this.hot.view) { + // @TODO: Workaround for broken plugin initialization abstraction. + return; + } + + var _this$hot$getSettings2 = this.hot.getSettings(), + nestedHeaders = _this$hot$getSettings2.nestedHeaders; + + _classPrivateFieldGet$3(this, _stateManager).setColumnsLimit(this.hot.countCols()); + + if (Array.isArray(nestedHeaders)) { + this.detectedOverlappedHeaders = _classPrivateFieldGet$3(this, _stateManager).setState(nestedHeaders); + } + + if (this.detectedOverlappedHeaders) { + warn(toSingleLine(_templateObject2$3 || (_templateObject2$3 = _taggedTemplateLiteral$c(["Your Nested Headers plugin setup contains overlapping headers. This kind of configuration \n is currently not supported."], ["Your Nested Headers plugin setup contains overlapping headers. This kind of configuration\\x20\n is currently not supported."])))); + } + + this.ghostTable.buildWidthsMapper(); + + _get$P(_getPrototypeOf$1h(NestedHeaders.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.clearColspans(); + + _classPrivateFieldGet$3(this, _stateManager).clear(); + + this.ghostTable.clear(); + + _get$P(_getPrototypeOf$1h(NestedHeaders.prototype), "disablePlugin", this).call(this); + } + /** + * Returns an instance of the internal state manager of the plugin. + * + * @private + * @returns {StateManager} + */ + + }, { + key: "getStateManager", + value: function getStateManager() { + return _classPrivateFieldGet$3(this, _stateManager); + } + /** + * Gets a total number of headers levels. + * + * @private + * @returns {number} + */ + + }, { + key: "getLayersCount", + value: function getLayersCount() { + return _classPrivateFieldGet$3(this, _stateManager).getLayersCount(); + } + /** + * Gets column settings for a specified header. The returned object contains + * information about the header label, its colspan length, or if it is hidden + * in the header renderers. + * + * @private + * @param {number} headerLevel Header level (0 = most distant to the table). + * @param {number} columnIndex A visual column index. + * @returns {object} + */ + + }, { + key: "getHeaderSettings", + value: function getHeaderSettings(headerLevel, columnIndex) { + return _classPrivateFieldGet$3(this, _stateManager).getHeaderSettings(headerLevel, columnIndex); + } + /** + * Gets HTML elements for specified visual column index and header level from + * all overlays except master. + * + * @private + * @param {number} columnIndex A visual column index. + * @param {number} headerLevel Header level (0 = most distant to the table). + * @returns {HTMLElement[]} + */ + + }, { + key: "getColumnHeaders", + value: function getColumnHeaders(columnIndex, headerLevel) { + var wtOverlays = this.hot.view.wt.wtOverlays; + var renderedColumnIndex = this.hot.columnIndexMapper.getRenderableFromVisualIndex(columnIndex); + var headers = []; + + if (renderedColumnIndex !== null) { + if (wtOverlays.topOverlay) { + headers.push(wtOverlays.topOverlay.clone.wtTable.getColumnHeader(renderedColumnIndex, headerLevel)); + } + + if (wtOverlays.topLeftCornerOverlay) { + headers.push(wtOverlays.topLeftCornerOverlay.clone.wtTable.getColumnHeader(renderedColumnIndex, headerLevel)); + } + } + + return headers; + } + /** + * Clear the colspans remaining after plugin usage. + * + * @private + */ + + }, { + key: "clearColspans", + value: function clearColspans() { + if (!this.hot.view) { + return; + } + + var wt = this.hot.view.wt; + var headerLevels = wt.getSetting('columnHeaders').length; + var mainHeaders = wt.wtTable.THEAD; + var topHeaders = wt.wtOverlays.topOverlay.clone.wtTable.THEAD; + var topLeftCornerHeaders = wt.wtOverlays.topLeftCornerOverlay ? wt.wtOverlays.topLeftCornerOverlay.clone.wtTable.THEAD : null; + + for (var i = 0; i < headerLevels; i++) { + var masterLevel = mainHeaders.childNodes[i]; + + if (!masterLevel) { + break; + } + + var topLevel = topHeaders.childNodes[i]; + var topLeftCornerLevel = topLeftCornerHeaders ? topLeftCornerHeaders.childNodes[i] : null; + + for (var j = 0, masterNodes = masterLevel.childNodes.length; j < masterNodes; j++) { + masterLevel.childNodes[j].removeAttribute('colspan'); + removeClass(masterLevel.childNodes[j], 'hiddenHeader'); + + if (topLevel && topLevel.childNodes[j]) { + topLevel.childNodes[j].removeAttribute('colspan'); + removeClass(topLevel.childNodes[j], 'hiddenHeader'); + } + + if (topLeftCornerHeaders && topLeftCornerLevel && topLeftCornerLevel.childNodes[j]) { + topLeftCornerLevel.childNodes[j].removeAttribute('colspan'); + removeClass(topLeftCornerLevel.childNodes[j], 'hiddenHeader'); + } + } + } + } + /** + * Generates the appropriate header renderer for a header row. + * + * @private + * @param {number} headerLevel The index of header level counting from the top (positive + * values counting from 0 to N). + * @returns {Function} + * @fires Hooks#afterGetColHeader + */ + + }, { + key: "headerRendererFactory", + value: function headerRendererFactory(headerLevel) { + var _this3 = this; + + var fixedColumnsLeft = this.hot.getSettings().fixedColumnsLeft || 0; + return function (renderedColumnIndex, TH) { + var _this3$hot = _this3.hot, + rootDocument = _this3$hot.rootDocument, + columnIndexMapper = _this3$hot.columnIndexMapper, + view = _this3$hot.view; + var visualColumnsIndex = columnIndexMapper.getVisualFromRenderableIndex(renderedColumnIndex); + + if (visualColumnsIndex === null) { + visualColumnsIndex = renderedColumnIndex; + } + + TH.removeAttribute('colspan'); + removeClass(TH, 'hiddenHeader'); + + var _classPrivateFieldGet2 = _classPrivateFieldGet$3(_this3, _stateManager).getHeaderSettings(headerLevel, visualColumnsIndex), + colspan = _classPrivateFieldGet2.colspan, + label = _classPrivateFieldGet2.label, + isHidden = _classPrivateFieldGet2.isHidden; + + if (isHidden === true) { + addClass(TH, 'hiddenHeader'); + } else if (colspan > 1) { + var _view$wt$wtOverlays$t, _view$wt$wtOverlays$l; + + var isTopLeftOverlay = (_view$wt$wtOverlays$t = view.wt.wtOverlays.topLeftCornerOverlay) === null || _view$wt$wtOverlays$t === void 0 ? void 0 : _view$wt$wtOverlays$t.clone.wtTable.THEAD.contains(TH); + var isLeftOverlay = (_view$wt$wtOverlays$l = view.wt.wtOverlays.leftOverlay) === null || _view$wt$wtOverlays$l === void 0 ? void 0 : _view$wt$wtOverlays$l.clone.wtTable.THEAD.contains(TH); // Check if there is a fixed column enabled, if so then reduce colspan to fixed column width. + + var correctedColspan = isTopLeftOverlay || isLeftOverlay ? Math.min(colspan, fixedColumnsLeft - visualColumnsIndex) : colspan; + + if (correctedColspan > 1) { + TH.setAttribute('colspan', correctedColspan); + } + } + + var divEl = rootDocument.createElement('div'); + var spanEl = rootDocument.createElement('span'); + addClass(divEl, 'relative'); + addClass(spanEl, 'colHeader'); + fastInnerHTML(spanEl, label); + divEl.appendChild(spanEl); + empty(TH); + TH.appendChild(divEl); + + _this3.hot.runHooks('afterGetColHeader', visualColumnsIndex, TH); + }; + } + /** + * Updates headers highlight in nested structure. + * + * @private + */ + + }, { + key: "updateHeadersHighlight", + value: function updateHeadersHighlight() { + var _this4 = this; + + var hot = this.hot; + var selection = hot.getSelectedRange(); + + if (selection === void 0) { + return; + } + + var hotSettings = this.hot.getSettings(); + + var classNameModifier = function classNameModifier(className) { + return function (TH, modifier) { + return function () { + return TH ? modifier(TH, className) : null; + }; + }; + }; + + var highlightHeader = classNameModifier(hotSettings.currentHeaderClassName); + var activeHeader = classNameModifier(hotSettings.activeHeaderClassName); + var selectionByHeader = hot.selection.isSelectedByColumnHeader() || hot.selection.isSelectedByCorner(); + + var layersCount = _classPrivateFieldGet$3(this, _stateManager).getLayersCount(); + + var activeHeaderChanges = new Map(); + var highlightHeaderChanges = new Map(); + arrayEach(selection, function (selectionLayer) { + var coordsFrom = selectionLayer.getTopLeftCorner(); + var coordsTo = selectionLayer.getTopRightCorner(); // If the beginning of the selection (columnFrom) starts in-between colspaned + // header shift the columnFrom to the header position where it starts. + + var columnFrom = _classPrivateFieldGet$3(_this4, _stateManager).findLeftMostColumnIndex(-1, coordsFrom.col); + + var columnTo = coordsTo.col; + var columnSelectionWidth = columnTo - columnFrom + 1; + var columnCursor = 0; + + for (var column = columnFrom; column <= columnTo; column++) { + var _loop = function _loop(level) { + var _classPrivateFieldGet3 = _classPrivateFieldGet$3(_this4, _stateManager).getHeaderSettings(level, column), + colspan = _classPrivateFieldGet3.colspan, + isHidden = _classPrivateFieldGet3.isHidden; + + var isFirstLayer = level === layersCount - 1; + var isOutOfRange = !isFirstLayer && columnCursor + colspan > columnSelectionWidth; + + var THs = _this4.getColumnHeaders(column, level); + + arrayEach(THs, function (TH) { + if (isOutOfRange || isHidden) { + // Reset CSS classes state (workaround for WoT issue which can not render that classes + // for nested header structure properly). + activeHeaderChanges.set(TH, activeHeader(TH, removeClass)); + highlightHeaderChanges.set(TH, highlightHeader(TH, removeClass)); + } else if (selectionByHeader) { + activeHeaderChanges.set(TH, activeHeader(TH, addClass)); + highlightHeaderChanges.set(TH, highlightHeader(TH, addClass)); + } else if (isFirstLayer) { + highlightHeaderChanges.set(TH, highlightHeader(TH, addClass)); + } else { + highlightHeaderChanges.set(TH, highlightHeader(TH, removeClass)); + } + }); + }; + + // Traverse header layers from bottom to top. + for (var level = layersCount - 1; level > -1; level--) { + _loop(level); + } + + columnCursor += 1; + } + }); + arrayEach(activeHeaderChanges, function (_ref) { + var _ref2 = _slicedToArray$L(_ref, 2), + classModifer = _ref2[1]; + + return void classModifer(); + }); + arrayEach(highlightHeaderChanges, function (_ref3) { + var _ref4 = _slicedToArray$L(_ref3, 2), + classModifer = _ref4[1]; + + return void classModifer(); + }); + activeHeaderChanges.clear(); + highlightHeaderChanges.clear(); + } + /** + * Select all nested headers of clicked cell. + * + * @private + * @param {MouseEvent} event Mouse event. + * @param {CellCoords} coords Clicked cell coords. + */ + + }, { + key: "onAfterOnCellMouseDown", + value: function onAfterOnCellMouseDown(event, coords) { + if (coords.row < 0) { + var _classPrivateFieldGet4 = _classPrivateFieldGet$3(this, _stateManager).getHeaderSettings(coords.row, coords.col), + origColspan = _classPrivateFieldGet4.origColspan; + + if (origColspan > 1) { + this.hot.selection.selectColumns(coords.col, coords.col + origColspan - 1); + } + } + } + /** + * Make the header-selection properly select the nested headers. + * + * @private + * @param {MouseEvent} event Mouse event. + * @param {CellCoords} coords Clicked cell coords. + * @param {HTMLElement} TD The cell element. + * @param {object} blockCalculations An object which allows or disallows changing the selection for the particular axies. + */ + + }, { + key: "onBeforeOnCellMouseOver", + value: function onBeforeOnCellMouseOver(event, coords, TD, blockCalculations) { + if (coords.row >= 0 || coords.col < 0 || !this.hot.view.isMouseDown()) { + return; + } + + var _this$hot$getSelected = this.hot.getSelectedRangeLast(), + from = _this$hot$getSelected.from, + to = _this$hot$getSelected.to; + + var _classPrivateFieldGet5 = _classPrivateFieldGet$3(this, _stateManager).getHeaderSettings(coords.row, coords.col), + origColspan = _classPrivateFieldGet5.origColspan; + + var lastColIndex = coords.col + origColspan - 1; + var changeDirection = false; + + if (from.col <= to.col) { + if (coords.col < from.col && lastColIndex === to.col || coords.col < from.col && lastColIndex < from.col || coords.col < from.col && lastColIndex >= from.col && lastColIndex < to.col) { + changeDirection = true; + } + } else if (coords.col < to.col && lastColIndex > from.col || coords.col > from.col || coords.col <= to.col && lastColIndex > from.col || coords.col > to.col && lastColIndex > from.col) { + changeDirection = true; + } + + if (changeDirection) { + var _ref5 = [to.col, from.col]; + from.col = _ref5[0]; + to.col = _ref5[1]; + } + + if (origColspan > 1) { + var _this$hot; + + blockCalculations.column = true; + blockCalculations.cell = true; + var columnRange = []; + + if (from.col === to.col) { + if (lastColIndex <= from.col && coords.col < from.col) { + columnRange.push(to.col, coords.col); + } else { + columnRange.push(coords.col < from.col ? coords.col : from.col, lastColIndex > to.col ? lastColIndex : to.col); + } + } + + if (from.col < to.col) { + columnRange.push(coords.col < from.col ? coords.col : from.col, lastColIndex); + } + + if (from.col > to.col) { + columnRange.push(from.col, coords.col); + } + + (_this$hot = this.hot).selectColumns.apply(_this$hot, columnRange); + } + } + /** + * `afterGetColumnHeader` hook callback - prepares the header structure. + * + * @private + * @param {Array} renderersArray Array of renderers. + */ + + }, { + key: "onAfterGetColumnHeaderRenderers", + value: function onAfterGetColumnHeaderRenderers(renderersArray) { + if (renderersArray) { + renderersArray.length = 0; + + for (var headerLayer = 0; headerLayer < _classPrivateFieldGet$3(this, _stateManager).getLayersCount(); headerLayer++) { + renderersArray.push(this.headerRendererFactory(headerLayer)); + } + } + + this.updateHeadersHighlight(); + } + /** + * Make the renderer render the first nested column in its entirety. + * + * @private + * @param {object} calc Viewport column calculator. + */ + + }, { + key: "onAfterViewportColumnCalculatorOverride", + value: function onAfterViewportColumnCalculatorOverride(calc) { + var newStartColumn = calc.startColumn; + + for (var headerLayer = 0; headerLayer < _classPrivateFieldGet$3(this, _stateManager).getLayersCount(); headerLayer++) { + var startColumn = _classPrivateFieldGet$3(this, _stateManager).findLeftMostColumnIndex(headerLayer, calc.startColumn); + + var renderedStartColumn = this.hot.columnIndexMapper.getRenderableFromVisualIndex(startColumn); + + if (renderedStartColumn < calc.startColumn) { + newStartColumn = renderedStartColumn; + break; + } + } + + calc.startColumn = newStartColumn; + } + /** + * `modifyColWidth` hook callback - returns width from cache, when is greater than incoming from hook. + * + * @private + * @param {number} width Width from hook. + * @param {number} column Visual index of an column. + * @returns {number} + */ + + }, { + key: "onModifyColWidth", + value: function onModifyColWidth(width, column) { + var cachedWidth = this.ghostTable.widthsCache[column]; + return width > cachedWidth ? width : cachedWidth; + } + /** + * Updates the plugin state after HoT initialization. + * + * @private + */ + + }, { + key: "onInit", + value: function onInit() { + // @TODO: Workaround for broken plugin initialization abstraction. + this.updatePlugin(); + } + /** + * Updates the plugin state after new dataset load. + * + * @private + * @param {Array[]} sourceData Array of arrays or array of objects containing data. + * @param {boolean} initialLoad Flag that determines whether the data has been loaded + * during the initialization. + */ + + }, { + key: "onAfterLoadData", + value: function onAfterLoadData(sourceData, initialLoad) { + if (!initialLoad) { + this.updatePlugin(); + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + _classPrivateFieldSet$3(this, _stateManager, null); + + _get$P(_getPrototypeOf$1h(NestedHeaders.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$u; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$s; + } + /** + * @private + * @type {StateManager} + */ + + }]); + + return NestedHeaders; +}(BasePlugin); + +function _typeof$1u(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1u = function _typeof(obj) { return typeof obj; }; } else { _typeof$1u = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1u(obj); } + +function _toConsumableArray$t(arr) { return _arrayWithoutHoles$r(arr) || _iterableToArray$t(arr) || _unsupportedIterableToArray$14(arr) || _nonIterableSpread$r(); } + +function _nonIterableSpread$r() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$14(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$14(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$14(o, minLen); } + +function _iterableToArray$t(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$r(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$14(arr); } + +function _arrayLikeToArray$14(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$2G(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2A(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); } } + +function _createClass$2A(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2A(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2A(Constructor, staticProps); return Constructor; } + +function _get$Q(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$Q = Reflect.get; } else { _get$Q = function _get(target, property, receiver) { var base = _superPropBase$Q(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$Q(target, property, receiver || target); } + +function _superPropBase$Q(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1i(object); if (object === null) break; } return object; } + +function _inherits$1i(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1j(subClass, superClass); } + +function _setPrototypeOf$1j(o, p) { _setPrototypeOf$1j = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1j(o, p); } + +function _createSuper$1i(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1j(); return function _createSuperInternal() { var Super = _getPrototypeOf$1i(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1i(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1i(this, result); }; } + +function _possibleConstructorReturn$1i(self, call) { if (call && (_typeof$1u(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1i(self); } + +function _assertThisInitialized$1i(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1j() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1i(o) { _getPrototypeOf$1i = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1i(o); } + +function _defineProperty$s(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet$4(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet$4(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; } +var PLUGIN_KEY$v = 'collapsibleColumns'; +var PLUGIN_PRIORITY$t = 290; +var actionDictionary = new Map([['collapse', { + hideColumn: true, + beforeHook: 'beforeColumnCollapse', + afterHook: 'afterColumnCollapse' +}], ['expand', { + hideColumn: false, + beforeHook: 'beforeColumnExpand', + afterHook: 'afterColumnExpand' +}]]); +/** + * @plugin CollapsibleColumns + * + * @description + * The {@link CollapsibleColumns} plugin allows collapsing of columns, covered by a header with the `colspan` property defined. + * + * Clicking the "collapse/expand" button collapses (or expands) all "child" headers except the first one. + * + * Setting the {@link Options#collapsibleColumns} property to `true` will display a "collapse/expand" button in every header + * with a defined `colspan` property. + * + * To limit this functionality to a smaller group of headers, define the `collapsibleColumns` property as an array + * of objects, as in the example below. + * + * @example + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: generateDataObj(), + * colHeaders: true, + * rowHeaders: true, + * nestedHeaders: true, + * // enable plugin + * collapsibleColumns: true, + * }); + * + * // or + * const hot = new Handsontable(container, { + * data: generateDataObj(), + * colHeaders: true, + * rowHeaders: true, + * nestedHeaders: true, + * // enable and configure which columns can be collapsed + * collapsibleColumns: [ + * {row: -4, col: 1, collapsible: true}, + * {row: -3, col: 5, collapsible: true} + * ], + * }); + * ``` + */ + +var _collapsedColumnsMap = new WeakMap(); + +var CollapsibleColumns = /*#__PURE__*/function (_BasePlugin) { + _inherits$1i(CollapsibleColumns, _BasePlugin); + + var _super = _createSuper$1i(CollapsibleColumns); + + function CollapsibleColumns() { + var _this; + + _classCallCheck$2G(this, CollapsibleColumns); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _defineProperty$s(_assertThisInitialized$1i(_this), "nestedHeadersPlugin", null); + + _defineProperty$s(_assertThisInitialized$1i(_this), "eventManager", new EventManager(_assertThisInitialized$1i(_this))); + + _defineProperty$s(_assertThisInitialized$1i(_this), "headerStateManager", null); + + _collapsedColumnsMap.set(_assertThisInitialized$1i(_this), { + writable: true, + value: null + }); + + return _this; + } + + _createClass$2A(CollapsibleColumns, [{ + key: "isEnabled", + value: + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link CollapsibleColumns#enablePlugin} method is called. + * + * @returns {boolean} + */ + function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$v]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var _this$hot$getSettings = this.hot.getSettings(), + nestedHeaders = _this$hot$getSettings.nestedHeaders; + + if (!nestedHeaders) { + warn('You need to configure the Nested Headers plugin in order to use collapsible headers.'); + } + + _classPrivateFieldSet$4(this, _collapsedColumnsMap, new HidingMap()); + + this.hot.columnIndexMapper.registerMap(this.pluginName, _classPrivateFieldGet$4(this, _collapsedColumnsMap)); + this.nestedHeadersPlugin = this.hot.getPlugin('nestedHeaders'); + this.headerStateManager = this.nestedHeadersPlugin.getStateManager(); + this.addHook('init', function () { + return _this2.onInit(); + }); + this.addHook('afterLoadData', function () { + return _this2.onAfterLoadData.apply(_this2, arguments); + }); + this.addHook('afterGetColHeader', function (col, TH) { + return _this2.onAfterGetColHeader(col, TH); + }); + this.addHook('beforeOnCellMouseDown', function (event, coords, TD) { + return _this2.onBeforeOnCellMouseDown(event, coords, TD); + }); + + _get$Q(_getPrototypeOf$1i(CollapsibleColumns.prototype), "enablePlugin", this).call(this); // @TODO: Workaround for broken plugin initialization abstraction (#6806). + + + this.updatePlugin(); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + // @TODO: Workaround for broken plugin initialization abstraction (#6806). + if (!this.hot.view) { + return; + } + + if (!this.nestedHeadersPlugin.detectedOverlappedHeaders) { + var _this$hot$getSettings2 = this.hot.getSettings(), + collapsibleColumns = _this$hot$getSettings2.collapsibleColumns; + + if (typeof collapsibleColumns === 'boolean') { + // Add `collapsible: true` attribute to all headers with colspan higher than 1. + this.headerStateManager.mapState(function (headerSettings) { + return { + collapsible: headerSettings.origColspan > 1 + }; + }); + } else if (Array.isArray(collapsibleColumns)) { + this.headerStateManager.mergeStateWith(collapsibleColumns); + } + } + + _get$Q(_getPrototypeOf$1i(CollapsibleColumns.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.hot.columnIndexMapper.unregisterMap(this.pluginName); + + _classPrivateFieldSet$4(this, _collapsedColumnsMap, null); + + this.nestedHeadersPlugin = null; + this.clearButtons(); + + _get$Q(_getPrototypeOf$1i(CollapsibleColumns.prototype), "disablePlugin", this).call(this); + } + /** + * Clears the expand/collapse buttons. + * + * @private + */ + + }, { + key: "clearButtons", + value: function clearButtons() { + if (!this.hot.view) { + return; + } + + var headerLevels = this.hot.view.wt.getSetting('columnHeaders').length; + var mainHeaders = this.hot.view.wt.wtTable.THEAD; + var topHeaders = this.hot.view.wt.wtOverlays.topOverlay.clone.wtTable.THEAD; + var topLeftCornerHeaders = this.hot.view.wt.wtOverlays.topLeftCornerOverlay ? this.hot.view.wt.wtOverlays.topLeftCornerOverlay.clone.wtTable.THEAD : null; + + var removeButton = function removeButton(button) { + if (button) { + button.parentNode.removeChild(button); + } + }; + + rangeEach(0, headerLevels - 1, function (i) { + var masterLevel = mainHeaders.childNodes[i]; + var topLevel = topHeaders.childNodes[i]; + var topLeftCornerLevel = topLeftCornerHeaders ? topLeftCornerHeaders.childNodes[i] : null; + rangeEach(0, masterLevel.childNodes.length - 1, function (j) { + var button = masterLevel.childNodes[j].querySelector('.collapsibleIndicator'); + removeButton(button); + + if (topLevel && topLevel.childNodes[j]) { + button = topLevel.childNodes[j].querySelector('.collapsibleIndicator'); + removeButton(button); + } + + if (topLeftCornerHeaders && topLeftCornerLevel && topLeftCornerLevel.childNodes[j]) { + button = topLeftCornerLevel.childNodes[j].querySelector('.collapsibleIndicator'); + removeButton(button); + } + }); + }); + } + /** + * Expands section at the provided coords. + * + * @param {object} coords Contains coordinates information. (`coords.row`, `coords.col`). + */ + + }, { + key: "expandSection", + value: function expandSection(coords) { + this.toggleCollapsibleSection([coords], 'expand'); + } + /** + * Collapses section at the provided coords. + * + * @param {object} coords Contains coordinates information. (`coords.row`, `coords.col`). + */ + + }, { + key: "collapseSection", + value: function collapseSection(coords) { + this.toggleCollapsibleSection([coords], 'collapse'); + } + /** + * Collapses or expand all collapsible sections, depending on the action parameter. + * + * @param {string} action 'collapse' or 'expand'. + */ + + }, { + key: "toggleAllCollapsibleSections", + value: function toggleAllCollapsibleSections(action) { + var _this3 = this; + + var coords = this.headerStateManager.mapNodes(function (_ref) { + var collapsible = _ref.collapsible, + origColspan = _ref.origColspan, + headerLevel = _ref.headerLevel, + columnIndex = _ref.columnIndex; + + if (collapsible === true && origColspan > 1) { + return { + row: _this3.headerStateManager.levelToRowCoords(headerLevel), + col: columnIndex + }; + } + }); + this.toggleCollapsibleSection(coords, action); + } + /** + * Collapses all collapsible sections. + */ + + }, { + key: "collapseAll", + value: function collapseAll() { + this.toggleAllCollapsibleSections('collapse'); + } + /** + * Expands all collapsible sections. + */ + + }, { + key: "expandAll", + value: function expandAll() { + this.toggleAllCollapsibleSections('expand'); + } + /** + * Collapses/Expands a section. + * + * @param {Array} coords Array of coords - section coordinates. + * @param {string} [action] Action definition ('collapse' or 'expand'). + * @fires Hooks#beforeColumnCollapse + * @fires Hooks#beforeColumnExpand + * @fires Hooks#afterColumnCollapse + * @fires Hooks#afterColumnExpand + */ + + }, { + key: "toggleCollapsibleSection", + value: function toggleCollapsibleSection(coords, action) { + var _this4 = this; + + if (!actionDictionary.has(action)) { + throw new Error("Unsupported action is passed (".concat(action, ").")); + } + + if (!Array.isArray(coords)) { + return; + } // Ignore coordinates which points to the cells range. + + + var filteredCoords = arrayFilter(coords, function (_ref2) { + var row = _ref2.row; + return row < 0; + }); + var isActionPossible = filteredCoords.length > 0; + arrayEach(filteredCoords, function (_ref3) { + var row = _ref3.row, + column = _ref3.col; + + var _this4$headerStateMan = _this4.headerStateManager.getHeaderSettings(row, column), + collapsible = _this4$headerStateMan.collapsible, + isCollapsed = _this4$headerStateMan.isCollapsed; + + if (!collapsible || isCollapsed && action === 'collapse' || !isCollapsed && action === 'expand') { + isActionPossible = false; + return false; + } + }); + var nodeModRollbacks = []; + var affectedColumnsIndexes = []; + + if (isActionPossible) { + arrayEach(filteredCoords, function (_ref4) { + var row = _ref4.row, + column = _ref4.col; + + var _this4$headerStateMan2 = _this4.headerStateManager.triggerNodeModification(action, row, column), + colspanCompensation = _this4$headerStateMan2.colspanCompensation, + affectedColumns = _this4$headerStateMan2.affectedColumns, + rollbackModification = _this4$headerStateMan2.rollbackModification; + + if (colspanCompensation > 0) { + affectedColumnsIndexes.push.apply(affectedColumnsIndexes, _toConsumableArray$t(affectedColumns)); + nodeModRollbacks.push(rollbackModification); + } + }); + } + + var currentCollapsedColumns = this.getCollapsedColumns(); + var destinationCollapsedColumns = []; + + if (action === 'collapse') { + destinationCollapsedColumns = arrayUnique([].concat(_toConsumableArray$t(currentCollapsedColumns), affectedColumnsIndexes)); + } else if (action === 'expand') { + destinationCollapsedColumns = arrayFilter(currentCollapsedColumns, function (index) { + return !affectedColumnsIndexes.includes(index); + }); + } + + var actionTranslator = actionDictionary.get(action); + var isActionAllowed = this.hot.runHooks(actionTranslator.beforeHook, currentCollapsedColumns, destinationCollapsedColumns, isActionPossible); + + if (isActionAllowed === false) { + // Rollback all header nodes modification (collapse or expand). + arrayEach(nodeModRollbacks, function (nodeModRollback) { + nodeModRollback(); + }); + return; + } + + this.hot.batchExecution(function () { + arrayEach(affectedColumnsIndexes, function (visualColumn) { + _classPrivateFieldGet$4(_this4, _collapsedColumnsMap).setValueAtIndex(_this4.hot.toPhysicalColumn(visualColumn), actionTranslator.hideColumn); + }); + }, true); + var isActionPerformed = this.getCollapsedColumns().length !== currentCollapsedColumns.length; + this.hot.runHooks(actionTranslator.afterHook, currentCollapsedColumns, destinationCollapsedColumns, isActionPossible, isActionPerformed); + this.hot.render(); + this.hot.view.adjustElementsSize(true); + } + /** + * Gets an array of physical indexes of collapsed columns. + * + * @private + * @returns {number[]} + */ + + }, { + key: "getCollapsedColumns", + value: function getCollapsedColumns() { + return _classPrivateFieldGet$4(this, _collapsedColumnsMap).getHiddenIndexes(); + } + /** + * Generates the indicator element. + * + * @private + * @param {number} row Row index. + * @param {number} column Column index. + * @returns {HTMLElement} + */ + + }, { + key: "generateIndicator", + value: function generateIndicator(row, column) { + var divEl = this.hot.rootDocument.createElement('div'); + var columnSettings = this.headerStateManager.getHeaderSettings(row, column); + addClass(divEl, 'collapsibleIndicator'); + + if (columnSettings.isCollapsed) { + addClass(divEl, 'collapsed'); + fastInnerText(divEl, '+'); + } else { + addClass(divEl, 'expanded'); + fastInnerText(divEl, '-'); + } + + return divEl; + } + /** + * Adds the indicator to the headers. + * + * @private + * @param {number} column Column index. + * @param {HTMLElement} TH TH element. + */ + + }, { + key: "onAfterGetColHeader", + value: function onAfterGetColHeader(column, TH) { + var TR = TH.parentNode; + var THEAD = TR.parentNode; + var row = -1 * THEAD.childNodes.length + Array.prototype.indexOf.call(THEAD.childNodes, TR); + + var _this$headerStateMana = this.headerStateManager.getHeaderSettings(row, column), + collapsible = _this$headerStateMana.collapsible, + origColspan = _this$headerStateMana.origColspan; + + if (collapsible && origColspan > 1 && column >= this.hot.getSettings().fixedColumnsLeft) { + var button = this.generateIndicator(row, column); + TH.querySelector('div:first-child').appendChild(button); + } + } + /** + * Indicator mouse event callback. + * + * @private + * @param {object} event Mouse event. + * @param {object} coords Event coordinates. + */ + + }, { + key: "onBeforeOnCellMouseDown", + value: function onBeforeOnCellMouseDown(event, coords) { + if (hasClass(event.target, 'collapsibleIndicator')) { + if (hasClass(event.target, 'expanded')) { + this.eventManager.fireEvent(event.target, 'mouseup'); + this.toggleCollapsibleSection([coords], 'collapse'); + } else if (hasClass(event.target, 'collapsed')) { + this.eventManager.fireEvent(event.target, 'mouseup'); + this.toggleCollapsibleSection([coords], 'expand'); + } + + stopImmediatePropagation(event); + } + } + /** + * Updates the plugin state after HoT initialization. + * + * @private + */ + + }, { + key: "onInit", + value: function onInit() { + // @TODO: Workaround for broken plugin initialization abstraction (#6806). + this.updatePlugin(); + } + /** + * Updates the plugin state after new dataset load. + * + * @private + * @param {Array[]} sourceData Array of arrays or array of objects containing data. + * @param {boolean} initialLoad Flag that determines whether the data has been loaded + * during the initialization. + */ + + }, { + key: "onAfterLoadData", + value: function onAfterLoadData(sourceData, initialLoad) { + if (!initialLoad) { + this.updatePlugin(); + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + _classPrivateFieldSet$4(this, _collapsedColumnsMap, null); + + this.hot.columnIndexMapper.unregisterMap(this.pluginName); + + _get$Q(_getPrototypeOf$1i(CollapsibleColumns.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$v; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$t; + } + }, { + key: "PLUGIN_DEPS", + get: function get() { + return ['plugin:NestedHeaders']; + } + /** + * Cached reference to the NestedHeaders plugin. + * + * @private + * @type {NestedHeaders} + */ + + }]); + + return CollapsibleColumns; +}(BasePlugin); + +function _toConsumableArray$u(arr) { return _arrayWithoutHoles$s(arr) || _iterableToArray$u(arr) || _unsupportedIterableToArray$15(arr) || _nonIterableSpread$s(); } + +function _nonIterableSpread$s() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$15(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$15(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$15(o, minLen); } + +function _iterableToArray$u(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$s(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$15(arr); } + +function _arrayLikeToArray$15(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _typeof$1v(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1v = function _typeof(obj) { return typeof obj; }; } else { _typeof$1v = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1v(obj); } + +function _classCallCheck$2H(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2B(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); } } + +function _createClass$2B(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2B(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2B(Constructor, staticProps); return Constructor; } +/** + * Class responsible for making data operations. + * + * @class + * @private + */ + +var DataManager = /*#__PURE__*/function () { + function DataManager(nestedRowsPlugin, hotInstance) { + _classCallCheck$2H(this, DataManager); + + /** + * Main Handsontable instance reference. + * + * @type {object} + */ + this.hot = hotInstance; + /** + * Reference to the source data object. + * + * @type {Handsontable.CellValue[][]|Handsontable.RowObject[]} + */ + + this.data = null; + /** + * Reference to the NestedRows plugin. + * + * @type {object} + */ + + this.plugin = nestedRowsPlugin; + /** + * Map of row object parents. + * + * @type {WeakMap} + */ + + this.parentReference = new WeakMap(); + /** + * Nested structure cache. + * + * @type {object} + */ + + this.cache = { + levels: [], + levelCount: 0, + rows: [], + nodeInfo: new WeakMap() + }; + } + /** + * Set the data for the manager. + * + * @param {Handsontable.CellValue[][]|Handsontable.RowObject[]} data Data for the manager. + */ + + + _createClass$2B(DataManager, [{ + key: "setData", + value: function setData(data) { + this.data = data; + } + /** + * Get the data cached in the manager. + * + * @returns {Handsontable.CellValue[][]|Handsontable.RowObject[]} + */ + + }, { + key: "getData", + value: function getData() { + return this.data; + } + /** + * Load the "raw" source data, without NestedRows' modifications. + * + * @returns {Handsontable.CellValue[][]|Handsontable.RowObject[]} + */ + + }, { + key: "getRawSourceData", + value: function getRawSourceData() { + var rawSourceData = null; + this.plugin.disableCoreAPIModifiers(); + rawSourceData = this.hot.getSourceData(); + this.plugin.enableCoreAPIModifiers(); + return rawSourceData; + } + /** + * Update the Data Manager with new data and refresh cache. + * + * @param {Handsontable.CellValue[][]|Handsontable.RowObject[]} data Data for the manager. + */ + + }, { + key: "updateWithData", + value: function updateWithData(data) { + this.setData(data); + this.rewriteCache(); + } + /** + * Rewrite the nested structure cache. + * + * @private + */ + + }, { + key: "rewriteCache", + value: function rewriteCache() { + var _this = this; + + this.cache = { + levels: [], + levelCount: 0, + rows: [], + nodeInfo: new WeakMap() + }; + rangeEach(0, this.data.length - 1, function (i) { + _this.cacheNode(_this.data[i], 0, null); + }); + } + /** + * Cache a data node. + * + * @private + * @param {object} node Node to cache. + * @param {number} level Level of the node. + * @param {object} parent Parent of the node. + */ + + }, { + key: "cacheNode", + value: function cacheNode(node, level, parent) { + var _this2 = this; + + if (!this.cache.levels[level]) { + this.cache.levels[level] = []; + this.cache.levelCount += 1; + } + + this.cache.levels[level].push(node); + this.cache.rows.push(node); + this.cache.nodeInfo.set(node, { + parent: parent, + row: this.cache.rows.length - 1, + level: level + }); + + if (this.hasChildren(node)) { + arrayEach(node.__children, function (elem) { + _this2.cacheNode(elem, level + 1, node); + }); + } + } + /** + * Get the date for the provided visual row number. + * + * @param {number} row Row index. + * @returns {object} + */ + + }, { + key: "getDataObject", + value: function getDataObject(row) { + return row === null || row === void 0 ? null : this.cache.rows[row]; + } + /** + * Read the row tree in search for a specific row index or row object. + * + * @private + * @param {object} parent The initial parent object. + * @param {number} readCount Number of read nodes. + * @param {number} neededIndex The row index we search for. + * @param {object} neededObject The row object we search for. + * @returns {number|object} + */ + + }, { + key: "readTreeNodes", + value: function readTreeNodes(parent, readCount, neededIndex, neededObject) { + var _this3 = this; + + var rootLevel = false; + var readNodesCount = readCount; + + if (isNaN(readNodesCount) && readNodesCount.end) { + return readNodesCount; + } + + var parentObj = parent; + + if (!parentObj) { + parentObj = { + __children: this.data + }; + rootLevel = true; + readNodesCount -= 1; + } + + if (neededIndex !== null && neededIndex !== void 0 && readNodesCount === neededIndex) { + return { + result: parentObj, + end: true + }; + } + + if (neededObject !== null && neededObject !== void 0 && parentObj === neededObject) { + return { + result: readNodesCount, + end: true + }; + } + + readNodesCount += 1; + + if (parentObj.__children) { + arrayEach(parentObj.__children, function (val) { + _this3.parentReference.set(val, rootLevel ? null : parentObj); + + readNodesCount = _this3.readTreeNodes(val, readNodesCount, neededIndex, neededObject); + + if (isNaN(readNodesCount) && readNodesCount.end) { + return false; + } + }); + } + + return readNodesCount; + } + /** + * Mock a parent node. + * + * @private + * @returns {*} + */ + + }, { + key: "mockParent", + value: function mockParent() { + var fakeParent = this.mockNode(); + fakeParent.__children = this.data; + return fakeParent; + } + /** + * Mock a data node. + * + * @private + * @returns {{}} + */ + + }, { + key: "mockNode", + value: function mockNode() { + var fakeNode = {}; + objectEach(this.data[0], function (val, key) { + fakeNode[key] = null; + }); + return fakeNode; + } + /** + * Get the row index for the provided row object. + * + * @param {object} rowObj The row object. + * @returns {number} Row index. + */ + + }, { + key: "getRowIndex", + value: function getRowIndex(rowObj) { + return rowObj === null || rowObj === void 0 ? null : this.cache.nodeInfo.get(rowObj).row; + } + /** + * Get the index of the provided row index/row object within its parent. + * + * @param {number|object} row Row index / row object. + * @returns {number} + */ + + }, { + key: "getRowIndexWithinParent", + value: function getRowIndexWithinParent(row) { + var rowObj = null; + + if (isNaN(row)) { + rowObj = row; + } else { + rowObj = this.getDataObject(row); + } + + var parent = this.getRowParent(row); + + if (parent === null || parent === void 0) { + return this.data.indexOf(rowObj); + } + + return parent.__children.indexOf(rowObj); + } + /** + * Count all rows (including all parents and children). + * + * @returns {number} + */ + + }, { + key: "countAllRows", + value: function countAllRows() { + var rootNodeMock = { + __children: this.data + }; + return this.countChildren(rootNodeMock); + } + /** + * Count children of the provided parent. + * + * @param {object|number} parent Parent node. + * @returns {number} Children count. + */ + + }, { + key: "countChildren", + value: function countChildren(parent) { + var _this4 = this; + + var rowCount = 0; + var parentNode = parent; + + if (!isNaN(parentNode)) { + parentNode = this.getDataObject(parentNode); + } + + if (!parentNode || !parentNode.__children) { + return 0; + } + + arrayEach(parentNode.__children, function (elem) { + rowCount += 1; + + if (elem.__children) { + rowCount += _this4.countChildren(elem); + } + }); + return rowCount; + } + /** + * Get the parent of the row at the provided index. + * + * @param {number|object} row Physical row index. + * @returns {object} + */ + + }, { + key: "getRowParent", + value: function getRowParent(row) { + var rowObject; + + if (isNaN(row)) { + rowObject = row; + } else { + rowObject = this.getDataObject(row); + } + + return this.getRowObjectParent(rowObject); + } + /** + * Get the parent of the provided row object. + * + * @private + * @param {object} rowObject The row object (tree node). + * @returns {object|null} + */ + + }, { + key: "getRowObjectParent", + value: function getRowObjectParent(rowObject) { + if (!rowObject || _typeof$1v(rowObject) !== 'object') { + return null; + } + + return this.cache.nodeInfo.get(rowObject).parent; + } + /** + * Get the nesting level for the row with the provided row index. + * + * @param {number} row Row index. + * @returns {number|null} Row level or null, when row doesn't exist. + */ + + }, { + key: "getRowLevel", + value: function getRowLevel(row) { + var rowObject = null; + + if (isNaN(row)) { + rowObject = row; + } else { + rowObject = this.getDataObject(row); + } + + return rowObject ? this.getRowObjectLevel(rowObject) : null; + } + /** + * Get the nesting level for the row with the provided row index. + * + * @private + * @param {object} rowObject Row object. + * @returns {number} Row level. + */ + + }, { + key: "getRowObjectLevel", + value: function getRowObjectLevel(rowObject) { + return rowObject === null || rowObject === void 0 ? null : this.cache.nodeInfo.get(rowObject).level; + } + /** + * Check if the provided row/row element has children. + * + * @param {number|object} row Row number or row element. + * @returns {boolean} + */ + + }, { + key: "hasChildren", + value: function hasChildren(row) { + var rowObj = row; + + if (!isNaN(rowObj)) { + rowObj = this.getDataObject(rowObj); + } + + return !!(rowObj.__children && rowObj.__children.length); + } + /** + * Returns `true` if the row at the provided index has a parent. + * + * @param {number} index Row index. + * @returns {boolean} `true` if the row at the provided index has a parent, `false` otherwise. + */ + + }, { + key: "isChild", + value: function isChild(index) { + return this.getRowParent(index) !== null; + } + /** + * Return `true` of the row at the provided index is located at the topmost level. + * + * @param {number} index Row index. + * @returns {boolean} `true` of the row at the provided index is located at the topmost level, `false` otherwise. + */ + + }, { + key: "isRowHighestLevel", + value: function isRowHighestLevel(index) { + return !this.isChild(index); + } + /** + * Return `true` if the provided row index / row object represents a parent in the nested structure. + * + * @param {number|object} row Row index / row object. + * @returns {boolean} `true` if the row is a parent, `false` otherwise. + */ + + }, { + key: "isParent", + value: function isParent(row) { + var _rowObj$__children; + + var rowObj = row; + + if (!isNaN(rowObj)) { + rowObj = this.getDataObject(rowObj); + } + + return rowObj && !!rowObj.__children && ((_rowObj$__children = rowObj.__children) === null || _rowObj$__children === void 0 ? void 0 : _rowObj$__children.length) !== 0; + } + /** + * Add a child to the provided parent. It's optional to add a row object as the "element". + * + * @param {object} parent The parent row object. + * @param {object} [element] The element to add as a child. + */ + + }, { + key: "addChild", + value: function addChild(parent, element) { + var childElement = element; + this.hot.runHooks('beforeAddChild', parent, childElement); + var parentIndex = null; + + if (parent) { + parentIndex = this.getRowIndex(parent); + } + + this.hot.runHooks('beforeCreateRow', parentIndex + this.countChildren(parent) + 1, 1); + var functionalParent = parent; + + if (!parent) { + functionalParent = this.mockParent(); + } + + if (!functionalParent.__children) { + functionalParent.__children = []; + } + + if (!childElement) { + childElement = this.mockNode(); + } + + functionalParent.__children.push(childElement); + + this.rewriteCache(); + var newRowIndex = this.getRowIndex(childElement); + this.hot.rowIndexMapper.insertIndexes(newRowIndex, 1); + this.hot.runHooks('afterCreateRow', newRowIndex, 1); + this.hot.runHooks('afterAddChild', parent, childElement); + } + /** + * Add a child node to the provided parent at a specified index. + * + * @param {object} parent Parent node. + * @param {number} index Index to insert the child element at. + * @param {object} [element] Element (node) to insert. + */ + + }, { + key: "addChildAtIndex", + value: function addChildAtIndex(parent, index, element) { + var childElement = element; + + if (!childElement) { + childElement = this.mockNode(); + } + + this.hot.runHooks('beforeAddChild', parent, childElement, index); + + if (parent) { + this.hot.runHooks('beforeCreateRow', index, 1); + + parent.__children.splice(index, null, childElement); + + this.plugin.disableCoreAPIModifiers(); + this.hot.setSourceDataAtCell(this.getRowIndexWithinParent(parent), '__children', parent.__children, 'NestedRows.addChildAtIndex'); + this.plugin.enableCoreAPIModifiers(); + this.hot.runHooks('afterCreateRow', index, 1); + } else { + this.plugin.disableCoreAPIModifiers(); + this.hot.alter('insert_row', index, 1, 'NestedRows.addChildAtIndex'); + this.plugin.enableCoreAPIModifiers(); + } + + this.updateWithData(this.getRawSourceData()); // Workaround for refreshing cache losing the reference to the mocked row. + + childElement = this.getDataObject(index); + this.hot.runHooks('afterAddChild', parent, childElement, index); + } + /** + * Add a sibling element at the specified index. + * + * @param {number} index New element sibling's index. + * @param {('above'|'below')} where Direction in which the sibling is to be created. + */ + + }, { + key: "addSibling", + value: function addSibling(index) { + var where = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'below'; + var translatedIndex = this.translateTrimmedRow(index); + var parent = this.getRowParent(translatedIndex); + var indexWithinParent = this.getRowIndexWithinParent(translatedIndex); + + switch (where) { + case 'below': + this.addChildAtIndex(parent, indexWithinParent + 1, null); + break; + + case 'above': + this.addChildAtIndex(parent, indexWithinParent, null); + break; + } + } + /** + * Detach the provided element from its parent and add it right after it. + * + * @param {object|Array} elements Row object or an array of selected coordinates. + * @param {boolean} [forceRender=true] If true (default), it triggers render after finished. + */ + + }, { + key: "detachFromParent", + value: function detachFromParent(elements) { + var _this5 = this; + + var forceRender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var element = null; + var rowObjects = []; + + if (Array.isArray(elements)) { + rangeEach(elements[0], elements[2], function (i) { + var translatedIndex = _this5.translateTrimmedRow(i); + + rowObjects.push(_this5.getDataObject(translatedIndex)); + }); + rangeEach(0, rowObjects.length - 2, function (i) { + _this5.detachFromParent(rowObjects[i], false); + }); + element = rowObjects[rowObjects.length - 1]; + } else { + element = elements; + } + + var childRowIndex = this.getRowIndex(element); + var indexWithinParent = this.getRowIndexWithinParent(element); + var parent = this.getRowParent(element); + var grandparent = this.getRowParent(parent); + var grandparentRowIndex = this.getRowIndex(grandparent); + var movedElementRowIndex = null; + this.hot.runHooks('beforeDetachChild', parent, element); + + if (indexWithinParent !== null && indexWithinParent !== void 0) { + this.hot.runHooks('beforeRemoveRow', childRowIndex, 1, [childRowIndex], this.plugin.pluginName); + + parent.__children.splice(indexWithinParent, 1); + + this.rewriteCache(); + this.hot.runHooks('afterRemoveRow', childRowIndex, 1, [childRowIndex], this.plugin.pluginName); + + if (grandparent) { + movedElementRowIndex = grandparentRowIndex + this.countChildren(grandparent); + this.hot.runHooks('beforeCreateRow', movedElementRowIndex, 1, this.plugin.pluginName); + + grandparent.__children.push(element); + } else { + movedElementRowIndex = this.hot.countRows() + 1; + this.hot.runHooks('beforeCreateRow', movedElementRowIndex, 1, this.plugin.pluginName); + this.data.push(element); + } + } + + this.rewriteCache(); + this.hot.runHooks('afterCreateRow', movedElementRowIndex, 1, this.plugin.pluginName); + this.hot.runHooks('afterDetachChild', parent, element); + + if (forceRender) { + this.hot.render(); + } + } + /** + * Filter the data by the `logicRows` array. + * + * @private + * @param {number} index Index of the first row to remove. + * @param {number} amount Number of elements to remove. + * @param {Array} logicRows Array of indexes to remove. + */ + + }, { + key: "filterData", + value: function filterData(index, amount, logicRows) { + var _this6 = this; + + // TODO: why are the first 2 arguments not used? + var elementsToRemove = []; + arrayEach(logicRows, function (elem) { + elementsToRemove.push(_this6.getDataObject(elem)); + }); + arrayEach(elementsToRemove, function (elem) { + var indexWithinParent = _this6.getRowIndexWithinParent(elem); + + var tempParent = _this6.getRowParent(elem); + + if (tempParent === null) { + _this6.data.splice(indexWithinParent, 1); + } else { + tempParent.__children.splice(indexWithinParent, 1); + } + }); + this.rewriteCache(); + } + /** + * Used to splice the source data. Needed to properly modify the nested structure, which wouldn't work with the + * default script. + * + * @private + * @param {number} index Physical index of the element at the splice beginning. + * @param {number} amount Number of elements to be removed. + * @param {object[]} elements Array of row objects to add. + */ + + }, { + key: "spliceData", + value: function spliceData(index, amount, elements) { + var previousElement = this.getDataObject(index - 1); + var newRowParent = null; + var indexWithinParent = index; + + if (previousElement && previousElement.__children && previousElement.__children.length === 0) { + newRowParent = previousElement; + indexWithinParent = 0; + } else if (index < this.countAllRows()) { + newRowParent = this.getRowParent(index); + indexWithinParent = this.getRowIndexWithinParent(index); + } + + if (newRowParent) { + if (elements) { + var _newRowParent$__child; + + (_newRowParent$__child = newRowParent.__children).splice.apply(_newRowParent$__child, [indexWithinParent, amount].concat(_toConsumableArray$u(elements))); + } else { + newRowParent.__children.splice(indexWithinParent, amount); + } + } else if (elements) { + var _this$data; + + (_this$data = this.data).splice.apply(_this$data, [indexWithinParent, amount].concat(_toConsumableArray$u(elements))); + } else { + this.data.splice(indexWithinParent, amount); + } + + this.rewriteCache(); + } + /** + * Update the `__children` key of the upmost parent of the provided row object. + * + * @private + * @param {object} rowElement Row object. + */ + + }, { + key: "syncRowWithRawSource", + value: function syncRowWithRawSource(rowElement) { + var upmostParent = rowElement; + var tempParent = null; + + do { + tempParent = this.getRowParent(tempParent); + + if (tempParent !== null) { + upmostParent = tempParent; + } + } while (tempParent !== null); + + this.plugin.disableCoreAPIModifiers(); + this.hot.setSourceDataAtCell(this.getRowIndex(upmostParent), '__children', upmostParent.__children, 'NestedRows.syncRowWithRawSource'); + this.plugin.enableCoreAPIModifiers(); + } + /* eslint-disable jsdoc/require-param */ + + /** + * Move a single row. + * + * @param {number} fromIndex Index of the row to be moved. + * @param {number} toIndex Index of the destination. + * @param {boolean} moveToCollapsed `true` if moving a row to a collapsed parent. + * @param {boolean} moveToLastChild `true` if moving a row to be a last child of the new parent. + */ + + /* eslint-enable jsdoc/require-param */ + + }, { + key: "moveRow", + value: function moveRow(fromIndex, toIndex, moveToCollapsed, moveToLastChild) { + var moveToLastRow = toIndex === this.hot.countRows(); + var fromParent = this.getRowParent(fromIndex); + var indexInFromParent = this.getRowIndexWithinParent(fromIndex); + + var elemToMove = fromParent.__children.slice(indexInFromParent, indexInFromParent + 1); + + var movingUp = fromIndex > toIndex; + var toParent = moveToLastRow ? this.getRowParent(toIndex - 1) : this.getRowParent(toIndex); + + if (toParent === null || toParent === void 0) { + toParent = this.getRowParent(toIndex - 1); + } + + if (toParent === null || toParent === void 0) { + toParent = this.getDataObject(toIndex - 1); + } + + if (!toParent) { + toParent = this.getDataObject(toIndex); + toParent.__children = []; + } else if (!toParent.__children) { + toParent.__children = []; + } + + var indexInTargetParent = moveToLastRow || moveToCollapsed || moveToLastChild ? toParent.__children.length : this.getRowIndexWithinParent(toIndex); + var sameParent = fromParent === toParent; + + toParent.__children.splice(indexInTargetParent, 0, elemToMove[0]); + + fromParent.__children.splice(indexInFromParent + (movingUp && sameParent ? 1 : 0), 1); // Sync the changes in the cached data with the actual data stored in HOT. + + + this.syncRowWithRawSource(fromParent); + + if (!sameParent) { + this.syncRowWithRawSource(toParent); + } + } + /** + * Translate the visual row index to the physical index, taking into consideration the state of collapsed rows. + * + * @private + * @param {number} row Row index. + * @returns {number} + */ + + }, { + key: "translateTrimmedRow", + value: function translateTrimmedRow(row) { + if (this.plugin.collapsingUI) { + return this.plugin.collapsingUI.translateTrimmedRow(row); + } + + return row; + } + /** + * Translate the physical row index to the visual index, taking into consideration the state of collapsed rows. + * + * @private + * @param {number} row Row index. + * @returns {number} + */ + + }, { + key: "untranslateTrimmedRow", + value: function untranslateTrimmedRow(row) { + if (this.plugin.collapsingUI) { + return this.plugin.collapsingUI.untranslateTrimmedRow(row); + } + + return row; + } + }]); + + return DataManager; +}(); + +function _classCallCheck$2I(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * Base class for the Nested Rows' UI sub-classes. + * + * @class + * @util + * @private + */ +var BaseUI$3 = function BaseUI(pluginInstance, hotInstance) { + _classCallCheck$2I(this, BaseUI); + + /** + * Instance of Handsontable. + * + * @type {Core} + */ + this.hot = hotInstance; + /** + * Reference to the main plugin instance. + */ + + this.plugin = pluginInstance; +}; + +function _typeof$1w(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1w = function _typeof(obj) { return typeof obj; }; } else { _typeof$1w = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1w(obj); } + +function _classCallCheck$2J(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2C(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); } } + +function _createClass$2C(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2C(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2C(Constructor, staticProps); return Constructor; } + +function _inherits$1j(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1k(subClass, superClass); } + +function _setPrototypeOf$1k(o, p) { _setPrototypeOf$1k = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1k(o, p); } + +function _createSuper$1j(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1k(); return function _createSuperInternal() { var Super = _getPrototypeOf$1j(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1j(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1j(this, result); }; } + +function _possibleConstructorReturn$1j(self, call) { if (call && (_typeof$1w(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1j(self); } + +function _assertThisInitialized$1j(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1k() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1j(o) { _getPrototypeOf$1j = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1j(o); } +/** + * Class responsible for the UI in the Nested Rows' row headers. + * + * @class HeadersUI + * @private + * @util + * @augments BaseUI + */ + +var HeadersUI = /*#__PURE__*/function (_BaseUI) { + _inherits$1j(HeadersUI, _BaseUI); + + var _super = _createSuper$1j(HeadersUI); + + function HeadersUI(nestedRowsPlugin, hotInstance) { + var _this; + + _classCallCheck$2J(this, HeadersUI); + + _this = _super.call(this, nestedRowsPlugin, hotInstance); + /** + * Reference to the DataManager instance connected with the Nested Rows plugin. + * + * @type {DataManager} + */ + + _this.dataManager = _this.plugin.dataManager; // /** + // * Level cache array. + // * + // * @type {Array} + // */ + // this.levelCache = this.dataManager.cache.levels; + + /** + * Reference to the CollapsingUI instance connected with the Nested Rows plugin. + * + * @type {CollapsingUI} + */ + + _this.collapsingUI = _this.plugin.collapsingUI; + /** + * Cache for the row headers width. + * + * @type {null|number} + */ + + _this.rowHeaderWidthCache = null; + return _this; + } + /** + * Append nesting indicators and buttons to the row headers. + * + * @private + * @param {number} row Row index. + * @param {HTMLElement} TH TH 3element. + */ + + + _createClass$2C(HeadersUI, [{ + key: "appendLevelIndicators", + value: function appendLevelIndicators(row, TH) { + var rowIndex = this.hot.toPhysicalRow(row); + var rowLevel = this.dataManager.getRowLevel(rowIndex); + var rowObject = this.dataManager.getDataObject(rowIndex); + var innerDiv = TH.getElementsByTagName('DIV')[0]; + var innerSpan = innerDiv.querySelector('span.rowHeader'); + var previousIndicators = innerDiv.querySelectorAll('[class^="ht_nesting"]'); + arrayEach(previousIndicators, function (elem) { + if (elem) { + innerDiv.removeChild(elem); + } + }); + addClass(TH, HeadersUI.CSS_CLASSES.indicatorContainer); + + if (rowLevel) { + var rootDocument = this.hot.rootDocument; + var initialContent = innerSpan.cloneNode(true); + innerDiv.innerHTML = ''; + rangeEach(0, rowLevel - 1, function () { + var levelIndicator = rootDocument.createElement('SPAN'); + addClass(levelIndicator, HeadersUI.CSS_CLASSES.emptyIndicator); + innerDiv.appendChild(levelIndicator); + }); + innerDiv.appendChild(initialContent); + } + + if (this.dataManager.hasChildren(rowObject)) { + var buttonsContainer = this.hot.rootDocument.createElement('DIV'); + addClass(TH, HeadersUI.CSS_CLASSES.parent); + + if (this.collapsingUI.areChildrenCollapsed(rowIndex)) { + addClass(buttonsContainer, "".concat(HeadersUI.CSS_CLASSES.button, " ").concat(HeadersUI.CSS_CLASSES.expandButton)); + } else { + addClass(buttonsContainer, "".concat(HeadersUI.CSS_CLASSES.button, " ").concat(HeadersUI.CSS_CLASSES.collapseButton)); + } + + innerDiv.appendChild(buttonsContainer); + } + } + /** + * Update the row header width according to number of levels in the dataset. + * + * @private + * @param {number} deepestLevel Cached deepest level of nesting. + */ + + }, { + key: "updateRowHeaderWidth", + value: function updateRowHeaderWidth(deepestLevel) { + var deepestLevelIndex = deepestLevel; + + if (!deepestLevelIndex) { + deepestLevelIndex = this.dataManager.cache.levelCount; + } + + this.rowHeaderWidthCache = Math.max(50, 11 + 10 * deepestLevelIndex + 25); + this.hot.render(); + } + }], [{ + key: "CSS_CLASSES", + get: + /** + * CSS classes used in the row headers. + * + * @type {object} + */ + function get() { + return { + indicatorContainer: 'ht_nestingLevels', + parent: 'ht_nestingParent', + indicator: 'ht_nestingLevel', + emptyIndicator: 'ht_nestingLevel_empty', + button: 'ht_nestingButton', + expandButton: 'ht_nestingExpand', + collapseButton: 'ht_nestingCollapse' + }; + } + }]); + + return HeadersUI; +}(BaseUI$3); + +function _typeof$1x(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1x = function _typeof(obj) { return typeof obj; }; } else { _typeof$1x = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1x(obj); } + +function _toConsumableArray$v(arr) { return _arrayWithoutHoles$t(arr) || _iterableToArray$v(arr) || _unsupportedIterableToArray$16(arr) || _nonIterableSpread$t(); } + +function _nonIterableSpread$t() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$16(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$16(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$16(o, minLen); } + +function _iterableToArray$v(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$t(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$16(arr); } + +function _arrayLikeToArray$16(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$2K(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2D(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); } } + +function _createClass$2D(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2D(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2D(Constructor, staticProps); return Constructor; } + +function _inherits$1k(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1l(subClass, superClass); } + +function _setPrototypeOf$1l(o, p) { _setPrototypeOf$1l = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1l(o, p); } + +function _createSuper$1k(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1l(); return function _createSuperInternal() { var Super = _getPrototypeOf$1k(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1k(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1k(this, result); }; } + +function _possibleConstructorReturn$1k(self, call) { if (call && (_typeof$1x(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1k(self); } + +function _assertThisInitialized$1k(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1l() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1k(o) { _getPrototypeOf$1k = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1k(o); } +/** + * Class responsible for the UI for collapsing and expanding groups. + * + * @class + * @util + * @private + * @augments BaseUI + */ + +var CollapsingUI = /*#__PURE__*/function (_BaseUI) { + _inherits$1k(CollapsingUI, _BaseUI); + + var _super = _createSuper$1k(CollapsingUI); + + function CollapsingUI(nestedRowsPlugin, hotInstance) { + var _this; + + _classCallCheck$2K(this, CollapsingUI); + + _this = _super.call(this, nestedRowsPlugin, hotInstance); + /** + * Reference to the TrimRows plugin. + */ + + _this.dataManager = _this.plugin.dataManager; + _this.collapsedRows = []; + _this.collapsedRowsStash = { + stash: function stash() { + var forceRender = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + _this.lastCollapsedRows = _this.collapsedRows.slice(0); // Workaround for wrong indexes being set in the trimRows plugin + + _this.expandMultipleChildren(_this.lastCollapsedRows, forceRender); + }, + shiftStash: function shiftStash(baseIndex, targetIndex) { + var delta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1; + + if (targetIndex === null || targetIndex === void 0) { + targetIndex = Infinity; + } + + arrayEach(_this.lastCollapsedRows, function (elem, i) { + if (elem >= baseIndex && elem < targetIndex) { + _this.lastCollapsedRows[i] = elem + delta; + } + }); + }, + applyStash: function applyStash() { + var forceRender = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + + _this.collapseMultipleChildren(_this.lastCollapsedRows, forceRender); + + _this.lastCollapsedRows = void 0; + }, + trimStash: function trimStash(realElementIndex, amount) { + rangeEach(realElementIndex, realElementIndex + amount - 1, function (i) { + var indexOfElement = _this.lastCollapsedRows.indexOf(i); + + if (indexOfElement > -1) { + _this.lastCollapsedRows.splice(indexOfElement, 1); + } + }); + } + }; + return _this; + } + /** + * Collapse the children of the row passed as an argument. + * + * @param {number|object} row The parent row. + * @param {boolean} [forceRender=true] Whether to render the table after the function ends. + * @param {boolean} [doTrimming=true] I determine whether collapsing should envolve trimming rows. + * @returns {Array} + */ + + + _createClass$2D(CollapsingUI, [{ + key: "collapseChildren", + value: function collapseChildren(row) { + var _this2 = this; + + var forceRender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var doTrimming = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var rowsToCollapse = []; + var rowObject = null; + var rowIndex = null; + var rowsToTrim = null; + + if (isNaN(row)) { + rowObject = row; + rowIndex = this.dataManager.getRowIndex(rowObject); + } else { + rowObject = this.dataManager.getDataObject(row); + rowIndex = row; + } + + if (this.dataManager.hasChildren(rowObject)) { + arrayEach(rowObject.__children, function (elem) { + rowsToCollapse.push(_this2.dataManager.getRowIndex(elem)); + }); + } + + rowsToTrim = this.collapseRows(rowsToCollapse, true, false); + + if (doTrimming) { + this.trimRows(rowsToTrim); + } + + if (forceRender) { + this.renderAndAdjust(); + } + + if (this.collapsedRows.indexOf(rowIndex) === -1) { + this.collapsedRows.push(rowIndex); + } + + return rowsToTrim; + } + /** + * Collapse multiple children. + * + * @param {Array} rows Rows to collapse (including their children). + * @param {boolean} [forceRender=true] `true` if the table should be rendered after finishing the function. + * @param {boolean} [doTrimming=true] I determine whether collapsing should envolve trimming rows. + */ + + }, { + key: "collapseMultipleChildren", + value: function collapseMultipleChildren(rows) { + var _this3 = this; + + var forceRender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var doTrimming = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var rowsToTrim = []; + arrayEach(rows, function (elem) { + rowsToTrim.push.apply(rowsToTrim, _toConsumableArray$v(_this3.collapseChildren(elem, false, false))); + }); + + if (doTrimming) { + this.trimRows(rowsToTrim); + } + + if (forceRender) { + this.renderAndAdjust(); + } + } + /** + * Collapse a single row. + * + * @param {number} rowIndex Index of the row to collapse. + * @param {boolean} [recursive=true] `true` if it should collapse the row's children. + */ + + }, { + key: "collapseRow", + value: function collapseRow(rowIndex) { + var recursive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + this.collapseRows([rowIndex], recursive); + } + /** + * Collapse multiple rows. + * + * @param {Array} rowIndexes Array of row indexes to collapse. + * @param {boolean} [recursive=true] `true` if it should collapse the rows' children. + * @param {boolean} [doTrimming=true] I determine whether collapsing should envolve trimming rows. + * @returns {Array} Rows prepared for trimming (or trimmed, if doTrimming == true). + */ + + }, { + key: "collapseRows", + value: function collapseRows(rowIndexes) { + var _this4 = this; + + var recursive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var doTrimming = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var rowsToTrim = []; + arrayEach(rowIndexes, function (elem) { + rowsToTrim.push(elem); + + if (recursive) { + _this4.collapseChildRows(elem, rowsToTrim); + } + }); + + if (doTrimming) { + this.trimRows(rowsToTrim); + } + + return rowsToTrim; + } + /** + * Collapse child rows of the row at the provided index. + * + * @param {number} parentIndex Index of the parent node. + * @param {Array} [rowsToTrim=[]] Array of rows to trim. Defaults to an empty array. + * @param {boolean} [recursive] `true` if the collapsing process should be recursive. + * @param {boolean} [doTrimming=true] I determine whether collapsing should envolve trimming rows. + */ + + }, { + key: "collapseChildRows", + value: function collapseChildRows(parentIndex) { + var _this5 = this; + + var rowsToTrim = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + var doTrimming = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + + if (this.dataManager.hasChildren(parentIndex)) { + var parentObject = this.dataManager.getDataObject(parentIndex); + arrayEach(parentObject.__children, function (elem) { + var elemIndex = _this5.dataManager.getRowIndex(elem); + + rowsToTrim.push(elemIndex); + + _this5.collapseChildRows(elemIndex, rowsToTrim); + }); + } + + if (doTrimming) { + this.trimRows(rowsToTrim); + } + } + /** + * Expand a single row. + * + * @param {number} rowIndex Index of the row to expand. + * @param {boolean} [recursive=true] `true` if it should expand the row's children recursively. + */ + + }, { + key: "expandRow", + value: function expandRow(rowIndex) { + var recursive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + this.expandRows([rowIndex], recursive); + } + /** + * Expand multiple rows. + * + * @param {Array} rowIndexes Array of indexes of the rows to expand. + * @param {boolean} [recursive=true] `true` if it should expand the rows' children recursively. + * @param {boolean} [doTrimming=true] I determine whether collapsing should envolve trimming rows. + * @returns {Array} Array of row indexes to be untrimmed. + */ + + }, { + key: "expandRows", + value: function expandRows(rowIndexes) { + var _this6 = this; + + var recursive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var doTrimming = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var rowsToUntrim = []; + arrayEach(rowIndexes, function (elem) { + rowsToUntrim.push(elem); + + if (recursive) { + _this6.expandChildRows(elem, rowsToUntrim); + } + }); + + if (doTrimming) { + this.untrimRows(rowsToUntrim); + } + + return rowsToUntrim; + } + /** + * Expand child rows of the provided index. + * + * @param {number} parentIndex Index of the parent row. + * @param {Array} [rowsToUntrim=[]] Array of the rows to be untrimmed. + * @param {boolean} [recursive] `true` if it should expand the rows' children recursively. + * @param {boolean} [doTrimming=false] I determine whether collapsing should envolve trimming rows. + */ + + }, { + key: "expandChildRows", + value: function expandChildRows(parentIndex) { + var _this7 = this; + + var rowsToUntrim = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + var doTrimming = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false; + + if (this.dataManager.hasChildren(parentIndex)) { + var parentObject = this.dataManager.getDataObject(parentIndex); + arrayEach(parentObject.__children, function (elem) { + if (!_this7.isAnyParentCollapsed(elem)) { + var elemIndex = _this7.dataManager.getRowIndex(elem); + + rowsToUntrim.push(elemIndex); + + _this7.expandChildRows(elemIndex, rowsToUntrim); + } + }); + } + + if (doTrimming) { + this.untrimRows(rowsToUntrim); + } + } + /** + * Expand the children of the row passed as an argument. + * + * @param {number|object} row Parent row. + * @param {boolean} [forceRender=true] Whether to render the table after the function ends. + * @param {boolean} [doTrimming=true] If set to `true`, the trimming will be applied when the function finishes. + * @returns {number[]} + */ + + }, { + key: "expandChildren", + value: function expandChildren(row) { + var _this8 = this; + + var forceRender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var doTrimming = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var rowsToExpand = []; + var rowObject = null; + var rowIndex = null; + var rowsToUntrim = null; + + if (isNaN(row)) { + rowObject = row; + rowIndex = this.dataManager.getRowIndex(row); + } else { + rowObject = this.dataManager.getDataObject(row); + rowIndex = row; + } + + this.collapsedRows.splice(this.collapsedRows.indexOf(rowIndex), 1); + + if (this.dataManager.hasChildren(rowObject)) { + arrayEach(rowObject.__children, function (elem) { + var childIndex = _this8.dataManager.getRowIndex(elem); + + rowsToExpand.push(childIndex); + }); + } + + rowsToUntrim = this.expandRows(rowsToExpand, true, false); + + if (doTrimming) { + this.untrimRows(rowsToUntrim); + } + + if (forceRender) { + this.renderAndAdjust(); + } + + return rowsToUntrim; + } + /** + * Expand multiple rows' children. + * + * @param {Array} rows Array of rows which children are about to be expanded. + * @param {boolean} [forceRender=true] `true` if the table should render after finishing the function. + * @param {boolean} [doTrimming=true] `true` if the rows should be untrimmed after finishing the function. + */ + + }, { + key: "expandMultipleChildren", + value: function expandMultipleChildren(rows) { + var _this9 = this; + + var forceRender = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var doTrimming = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var rowsToUntrim = []; + arrayEach(rows, function (elem) { + rowsToUntrim.push.apply(rowsToUntrim, _toConsumableArray$v(_this9.expandChildren(elem, false, false))); + }); + + if (doTrimming) { + this.untrimRows(rowsToUntrim); + } + + if (forceRender) { + this.renderAndAdjust(); + } + } + /** + * Collapse all collapsable rows. + */ + + }, { + key: "collapseAll", + value: function collapseAll() { + var _this10 = this; + + var data = this.dataManager.getData(); + var parentsToCollapse = []; + arrayEach(data, function (elem) { + if (_this10.dataManager.hasChildren(elem)) { + parentsToCollapse.push(elem); + } + }); + this.collapseMultipleChildren(parentsToCollapse); + this.renderAndAdjust(); + } + /** + * Expand all collapsable rows. + */ + + }, { + key: "expandAll", + value: function expandAll() { + var _this11 = this; + + var data = this.dataManager.getData(); + var parentsToExpand = []; + arrayEach(data, function (elem) { + if (_this11.dataManager.hasChildren(elem)) { + parentsToExpand.push(elem); + } + }); + this.expandMultipleChildren(parentsToExpand); + this.renderAndAdjust(); + } + /** + * Trim rows. + * + * @param {Array} rows Physical row indexes. + */ + + }, { + key: "trimRows", + value: function trimRows(rows) { + var _this12 = this; + + this.hot.batchExecution(function () { + arrayEach(rows, function (physicalRow) { + _this12.plugin.collapsedRowsMap.setValueAtIndex(physicalRow, true); + }); + }, true); + } + /** + * Untrim rows. + * + * @param {Array} rows Physical row indexes. + */ + + }, { + key: "untrimRows", + value: function untrimRows(rows) { + var _this13 = this; + + this.hot.batchExecution(function () { + arrayEach(rows, function (physicalRow) { + _this13.plugin.collapsedRowsMap.setValueAtIndex(physicalRow, false); + }); + }, true); + } + /** + * Check if all child rows are collapsed. + * + * @private + * @param {number|object|null} row The parent row. `null` for the top level. + * @returns {boolean} + */ + + }, { + key: "areChildrenCollapsed", + value: function areChildrenCollapsed(row) { + var _this14 = this; + + var rowObj = isNaN(row) ? row : this.dataManager.getDataObject(row); + var allCollapsed = true; // Checking the children of the top-level "parent" + + if (rowObj === null) { + rowObj = { + __children: this.dataManager.data + }; + } + + if (this.dataManager.hasChildren(rowObj)) { + arrayEach(rowObj.__children, function (elem) { + var rowIndex = _this14.dataManager.getRowIndex(elem); + + if (!_this14.plugin.collapsedRowsMap.getValueAtIndex(rowIndex)) { + allCollapsed = false; + return false; + } + }); + } + + return allCollapsed; + } + /** + * Check if any of the row object parents are collapsed. + * + * @private + * @param {object} rowObj Row object. + * @returns {boolean} + */ + + }, { + key: "isAnyParentCollapsed", + value: function isAnyParentCollapsed(rowObj) { + var parent = rowObj; + + while (parent !== null) { + parent = this.dataManager.getRowParent(parent); + var parentIndex = this.dataManager.getRowIndex(parent); + + if (this.collapsedRows.indexOf(parentIndex) > -1) { + return true; + } + } + + return false; + } + /** + * Toggle collapsed state. Callback for the `beforeOnCellMousedown` hook. + * + * @private + * @param {MouseEvent} event `mousedown` event. + * @param {object} coords Coordinates of the clicked cell/header. + */ + + }, { + key: "toggleState", + value: function toggleState(event, coords) { + if (coords.col >= 0) { + return; + } + + var row = this.translateTrimmedRow(coords.row); + + if (hasClass(event.target, HeadersUI.CSS_CLASSES.button)) { + if (this.areChildrenCollapsed(row)) { + this.expandChildren(row); + } else { + this.collapseChildren(row); + } + + stopImmediatePropagation(event); + } + } + /** + * Translate visual row after trimming to physical base row index. + * + * @private + * @param {number} row Row index. + * @returns {number} Base row index. + */ + + }, { + key: "translateTrimmedRow", + value: function translateTrimmedRow(row) { + return this.hot.toPhysicalRow(row); + } + /** + * Translate physical row after trimming to visual base row index. + * + * @private + * @param {number} row Row index. + * @returns {number} Base row index. + */ + + }, { + key: "untranslateTrimmedRow", + value: function untranslateTrimmedRow(row) { + return this.hot.toVisualRow(row); + } + /** + * Helper function to render the table and call the `adjustElementsSize` method. + * + * @private + */ + + }, { + key: "renderAndAdjust", + value: function renderAndAdjust() { + this.hot.render(); // Dirty workaround to prevent scroll height not adjusting to the table height. Needs refactoring in the future. + + this.hot.view.adjustElementsSize(); + } + }]); + + return CollapsingUI; +}(BaseUI$3); + +function _typeof$1y(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1y = function _typeof(obj) { return typeof obj; }; } else { _typeof$1y = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1y(obj); } + +function _classCallCheck$2L(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2E(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); } } + +function _createClass$2E(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2E(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2E(Constructor, staticProps); return Constructor; } + +function _inherits$1l(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1m(subClass, superClass); } + +function _setPrototypeOf$1m(o, p) { _setPrototypeOf$1m = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1m(o, p); } + +function _createSuper$1l(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1m(); return function _createSuperInternal() { var Super = _getPrototypeOf$1l(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1l(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1l(this, result); }; } + +function _possibleConstructorReturn$1l(self, call) { if (call && (_typeof$1y(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1l(self); } + +function _assertThisInitialized$1l(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1m() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1l(o) { _getPrototypeOf$1l = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1l(o); } +var privatePool$k = new WeakMap(); +/** + * Class responsible for the Context Menu entries for the Nested Rows plugin. + * + * @class ContextMenuUI + * @util + * @private + * @augments BaseUI + */ + +var ContextMenuUI = /*#__PURE__*/function (_BaseUI) { + _inherits$1l(ContextMenuUI, _BaseUI); + + var _super = _createSuper$1l(ContextMenuUI); + + function ContextMenuUI(nestedRowsPlugin, hotInstance) { + var _this; + + _classCallCheck$2L(this, ContextMenuUI); + + _this = _super.call(this, nestedRowsPlugin, hotInstance); + privatePool$k.set(_assertThisInitialized$1l(_this), { + row_above: function row_above(key, selection) { + var lastSelection = selection[selection.length - 1]; + + _this.dataManager.addSibling(lastSelection.start.row, 'above'); + }, + row_below: function row_below(key, selection) { + var lastSelection = selection[selection.length - 1]; + + _this.dataManager.addSibling(lastSelection.start.row, 'below'); + } + }); + /** + * Reference to the DataManager instance connected with the Nested Rows plugin. + * + * @type {DataManager} + */ + + _this.dataManager = _this.plugin.dataManager; + return _this; + } + /** + * Append options to the context menu. (Propagated from the `afterContextMenuDefaultOptions` hook callback) + * f. + * + * @private + * @param {object} defaultOptions Default context menu options. + * @returns {*} + */ + + + _createClass$2E(ContextMenuUI, [{ + key: "appendOptions", + value: function appendOptions(defaultOptions) { + var _this2 = this; + + var newEntries = [{ + key: 'add_child', + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_NESTED_ROWS_INSERT_CHILD); + }, + callback: function callback() { + var translatedRowIndex = _this2.dataManager.translateTrimmedRow(_this2.hot.getSelectedLast()[0]); + + var parent = _this2.dataManager.getDataObject(translatedRowIndex); + + _this2.dataManager.addChild(parent); + }, + disabled: function disabled() { + var selected = _this2.hot.getSelectedLast(); + + return !selected || selected[0] < 0 || _this2.hot.selection.isSelectedByColumnHeader() || _this2.hot.countRows() >= _this2.hot.getSettings().maxRows; + } + }, { + key: 'detach_from_parent', + name: function name() { + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_NESTED_ROWS_DETACH_CHILD); + }, + callback: function callback() { + _this2.dataManager.detachFromParent(_this2.hot.getSelectedLast()); + }, + disabled: function disabled() { + var selected = _this2.hot.getSelectedLast(); + + var translatedRowIndex = _this2.dataManager.translateTrimmedRow(selected[0]); + + var parent = _this2.dataManager.getRowParent(translatedRowIndex); + + return !parent || !selected || selected[0] < 0 || _this2.hot.selection.isSelectedByColumnHeader() || _this2.hot.countRows() >= _this2.hot.getSettings().maxRows; + } + }, { + name: '---------' + }]; + rangeEach(0, defaultOptions.items.length - 1, function (i) { + if (i === 0) { + arrayEach(newEntries, function (val, j) { + defaultOptions.items.splice(i + j, 0, val); + }); + return false; + } + }); + return this.modifyRowInsertingOptions(defaultOptions); + } + /** + * Modify how the row inserting options work. + * + * @private + * @param {object} defaultOptions Default context menu items. + * @returns {*} + */ + + }, { + key: "modifyRowInsertingOptions", + value: function modifyRowInsertingOptions(defaultOptions) { + var priv = privatePool$k.get(this); + rangeEach(0, defaultOptions.items.length - 1, function (i) { + var option = priv[defaultOptions.items[i].key]; + + if (option !== null && option !== void 0) { + defaultOptions.items[i].callback = option; + } + }); + return defaultOptions; + } + }]); + + return ContextMenuUI; +}(BaseUI$3); + +var _templateObject$d; + +function _toConsumableArray$w(arr) { return _arrayWithoutHoles$u(arr) || _iterableToArray$w(arr) || _unsupportedIterableToArray$17(arr) || _nonIterableSpread$u(); } + +function _nonIterableSpread$u() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$17(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$17(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$17(o, minLen); } + +function _iterableToArray$w(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$u(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$17(arr); } + +function _arrayLikeToArray$17(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _taggedTemplateLiteral$d(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); } + +function _classCallCheck$2M(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2F(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); } } + +function _createClass$2F(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2F(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2F(Constructor, staticProps); return Constructor; } +/** + * Helper class for the row-move-related operations. + * + * @class RowMoveController + * @plugin NestedRows + * @private + */ + +var RowMoveController = /*#__PURE__*/function () { + function RowMoveController(plugin) { + _classCallCheck$2M(this, RowMoveController); + + /** + * Reference to the Nested Rows plugin instance. + * + * @type {NestedRows} + */ + this.plugin = plugin; + /** + * Reference to the Handsontable instance. + * + * @type {Handsontable.Core} + */ + + this.hot = plugin.hot; + /** + * Reference to the Data Manager class instance. + * + * @type {DataManager} + */ + + this.dataManager = plugin.dataManager; + /** + * Reference to the Collapsing UI class instance. + * + * @type {CollapsingUI} + */ + + this.collapsingUI = plugin.collapsingUI; + } + /** + * `beforeRowMove` hook callback. + * + * @param {Array} rows Array of visual row indexes to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements + * will be placed after the moving action. To check the visualization of the final index, please take a look at + * [documentation](/docs/demo-moving.html). + * @param {undefined|number} dropIndex Visual row index, being a drop index for the moved rows. Points to where we + * are going to drop the moved elements. To check visualization of drop index please take a look at + * [documentation](/docs/demo-moving.html). + * @param {boolean} movePossible Indicates if it's possible to move rows to the desired position. + * @fires Hooks#afterRowMove + * @returns {boolean} + */ + + + _createClass$2F(RowMoveController, [{ + key: "onBeforeRowMove", + value: function onBeforeRowMove(rows, finalIndex, dropIndex, movePossible) { + var _this = this; + + var improperUsage = this.displayAPICompatibilityWarning({ + rows: rows, + finalIndex: finalIndex, + dropIndex: dropIndex, + movePossible: movePossible + }); + + if (improperUsage) { + return false; + } + + this.movedToCollapsed = false; + var dropToLastRow = dropIndex === this.hot.countRows(); + var physicalDropIndex = dropToLastRow ? this.hot.countSourceRows() : this.dataManager.translateTrimmedRow(dropIndex); + var allowMove = true; + var physicalStartIndexes = rows.map(function (rowIndex) { + // Don't do the logic for the rest of the rows, as it's bound to fail anyway. + if (!allowMove) { + return false; + } + + var physicalRowIndex = _this.dataManager.translateTrimmedRow(rowIndex); + + allowMove = _this.shouldAllowMoving(physicalRowIndex, physicalDropIndex); + return physicalRowIndex; + }); + var willDataChange = physicalStartIndexes.indexOf(physicalDropIndex) === -1; + + if (!allowMove || !willDataChange) { + return false; + } + + var baseParent = this.getBaseParent(physicalStartIndexes); + var targetParent = this.getTargetParent(dropToLastRow, physicalDropIndex); + var sameParent = baseParent === targetParent; + this.movedToCollapsed = this.collapsingUI.areChildrenCollapsed(targetParent); // Stash the current state of collapsed rows + + this.collapsingUI.collapsedRowsStash.stash(); + this.shiftCollapsibleParentsLocations(physicalStartIndexes, physicalDropIndex, sameParent); + this.moveRows(physicalStartIndexes, physicalDropIndex, targetParent); + this.dataManager.updateWithData(this.dataManager.getRawSourceData()); + this.moveCellsMeta(physicalStartIndexes, physicalDropIndex); + this.collapsingUI.collapsedRowsStash.applyStash(false); // TODO: Trying to mock real work of the `ManualRowMove` plugin. It was blocked by returning `false` below. + + this.hot.runHooks('afterRowMove', rows, finalIndex, dropIndex, movePossible, movePossible && this.isRowOrderChanged(rows, finalIndex)); // Not necessary - added to keep compatibility with other plugins (namely: columnSummary). + + this.hot.render(); + this.selectCells(rows, dropIndex); + return false; + } + /** + * Display a `dragRows`/`moveRows` method compatibility warning if needed. + * + * @param {object} beforeMoveRowHookArgs A set of arguments from the `beforeMoveRow` hook. + * @returns {boolean} `true` if is a result of an improper usage of the moving API. + */ + + }, { + key: "displayAPICompatibilityWarning", + value: function displayAPICompatibilityWarning(beforeMoveRowHookArgs) { + var rows = beforeMoveRowHookArgs.rows, + finalIndex = beforeMoveRowHookArgs.finalIndex, + dropIndex = beforeMoveRowHookArgs.dropIndex, + movePossible = beforeMoveRowHookArgs.movePossible; + var shouldTerminate = false; + + if (isUndefined(dropIndex)) { + warn(toSingleLine(_templateObject$d || (_templateObject$d = _taggedTemplateLiteral$d(["Since version 8.0.0 of the Handsontable the 'moveRows' method isn't used for moving rows \n when the NestedRows plugin is enabled. Please use the 'dragRows' method instead."], ["Since version 8.0.0 of the Handsontable the 'moveRows' method isn't used for moving rows\\x20\n when the NestedRows plugin is enabled. Please use the 'dragRows' method instead."])))); // TODO: Trying to mock real work of the `ManualRowMove` plugin. It was blocked by returning `false` below. + + this.hot.runHooks('afterRowMove', rows, finalIndex, dropIndex, movePossible, false); + shouldTerminate = true; + } + + return shouldTerminate; + } + /** + * Check if the moving action should be allowed. + * + * @param {number} physicalRowIndex Physical start row index. + * @param {number} physicalDropIndex Physical drop index. + * @returns {boolean} `true` if it should continue with the moving action. + */ + + }, { + key: "shouldAllowMoving", + value: function shouldAllowMoving(physicalRowIndex, physicalDropIndex) { + /* + We can't move rows when any of them is: + - a parent + - a top-level element + - is being moved to the top level + - is being moved to the position of any of the moved rows (not changing position) + */ + return !(this.dataManager.isParent(physicalRowIndex) || this.dataManager.isRowHighestLevel(physicalRowIndex) || physicalRowIndex === physicalDropIndex || physicalDropIndex === 0); + } + /** + * Get the base row parent. + * + * @param {number} physicalStartIndexes Physical start row index. + * @returns {object|null} The base row parent. + */ + + }, { + key: "getBaseParent", + value: function getBaseParent(physicalStartIndexes) { + return this.dataManager.getRowParent(physicalStartIndexes[0]); + } + /** + * Get the target row parent. + * + * @param {boolean} dropToLastRow `true` if the row is moved to the last row of the table. + * @param {number} physicalDropIndex Physical drop row index. + * @returns {object|null} The target row parent. + */ + + }, { + key: "getTargetParent", + value: function getTargetParent(dropToLastRow, physicalDropIndex) { + var targetParent = this.dataManager.getRowParent(dropToLastRow ? physicalDropIndex - 1 : physicalDropIndex); // If we try to move an element to the place of a top-level parent, snap the element to the previous top-level + // parent's children instead + + if (targetParent === null || targetParent === void 0) { + targetParent = this.dataManager.getRowParent(physicalDropIndex - 1); + } + + return targetParent; + } + /** + * Shift the cached collapsible rows position according to the move action. + * + * @param {number[]} physicalStartIndexes Physical start row indexes. + * @param {number} physicalDropIndex Physical drop index. + * @param {boolean} sameParent `true` if the row's being moved between siblings of the same parent. + */ + + }, { + key: "shiftCollapsibleParentsLocations", + value: function shiftCollapsibleParentsLocations(physicalStartIndexes, physicalDropIndex, sameParent) { + if (!sameParent) { + if (Math.max.apply(Math, _toConsumableArray$w(physicalStartIndexes)) <= physicalDropIndex) { + this.collapsingUI.collapsedRowsStash.shiftStash(physicalStartIndexes[0], physicalDropIndex, -1 * physicalStartIndexes.length); + } else { + this.collapsingUI.collapsedRowsStash.shiftStash(physicalDropIndex, physicalStartIndexes[0], physicalStartIndexes.length); + } + } + } + /** + * Move the rows at the provided coordinates. + * + * @param {number[]} physicalStartIndexes Physical indexes of the rows about to be moved. + * @param {number} physicalDropIndex Physical drop index. + * @param {object} targetParent Parent of the destination row. + */ + + }, { + key: "moveRows", + value: function moveRows(physicalStartIndexes, physicalDropIndex, targetParent) { + var _this2 = this; + + var moveToLastChild = physicalDropIndex === this.dataManager.getRowIndex(targetParent) + this.dataManager.countChildren(targetParent) + 1; + this.hot.batchRender(function () { + physicalStartIndexes.forEach(function (physicalStartIndex) { + _this2.dataManager.moveRow(physicalStartIndex, physicalDropIndex, _this2.movedToCollapsed, moveToLastChild); + }); + }); + } + /** + * Move the cell meta for multiple rows. + * + * @param {number[]} baseIndexes Array of indexes for the rows being moved. + * @param {number} targetIndex Index of the destination of the move. + */ + + }, { + key: "moveCellsMeta", + value: function moveCellsMeta(baseIndexes, targetIndex) { + var _this3 = this, + _this$hot; + + var rowsOfMeta = []; + var movingDown = Math.max.apply(Math, _toConsumableArray$w(baseIndexes)) < targetIndex; + baseIndexes.forEach(function (baseIndex) { + rowsOfMeta.push(_this3.hot.getCellMetaAtRow(baseIndex)); + }); + this.hot.spliceCellsMeta(baseIndexes[0], baseIndexes.length); + + (_this$hot = this.hot).spliceCellsMeta.apply(_this$hot, [targetIndex - (movingDown ? rowsOfMeta.length : 0), 0].concat(rowsOfMeta)); + } + /** + * Select cells after the move. + * + * @param {Array} rows Array of visual row indexes to be moved. + * @param {undefined|number} dropIndex Visual row index, being a drop index for the moved rows. Points to where we + * are going to drop the moved elements. To check visualization of drop index please take a look at + * [documentation](/docs/demo-moving.html). + */ + + }, { + key: "selectCells", + value: function selectCells(rows, dropIndex) { + var rowsLen = rows.length; + var startRow = 0; + var endRow = 0; + var selection = null; + var lastColIndex = null; + + if (this.movedToCollapsed) { + var physicalDropIndex = null; + + if (rows[rowsLen - 1] < dropIndex) { + physicalDropIndex = this.dataManager.translateTrimmedRow(dropIndex - rowsLen); + } else { + physicalDropIndex = this.dataManager.translateTrimmedRow(dropIndex); + } + + var parentObject = this.dataManager.getRowParent(physicalDropIndex === null ? this.hot.countSourceRows() - 1 : physicalDropIndex - 1); + var parentIndex = this.dataManager.getRowIndex(parentObject); + startRow = this.dataManager.untranslateTrimmedRow(parentIndex); + endRow = startRow; + } else if (rows[rowsLen - 1] < dropIndex) { + endRow = dropIndex - 1; + startRow = endRow - rowsLen + 1; + } else { + startRow = dropIndex; + endRow = startRow + rowsLen - 1; + } + + selection = this.hot.selection; + lastColIndex = this.hot.countCols() - 1; + selection.setRangeStart(new CellCoords(startRow, 0)); + selection.setRangeEnd(new CellCoords(endRow, lastColIndex), true); + } // TODO: Reimplementation of function which is inside the `ManualRowMove` plugin. + + /** + * Indicates if order of rows was changed. + * + * @param {Array} movedRows Array of visual row indexes to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements + * will be placed after the moving action. To check the visualization of the final index, please take a look at + * [documentation](/docs/demo-moving.html). + * @returns {boolean} + */ + + }, { + key: "isRowOrderChanged", + value: function isRowOrderChanged(movedRows, finalIndex) { + return movedRows.some(function (row, nrOfMovedElement) { + return row - nrOfMovedElement !== finalIndex; + }); + } + }]); + + return RowMoveController; +}(); + +function _typeof$1z(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1z = function _typeof(obj) { return typeof obj; }; } else { _typeof$1z = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1z(obj); } + +function _toConsumableArray$x(arr) { return _arrayWithoutHoles$v(arr) || _iterableToArray$x(arr) || _unsupportedIterableToArray$18(arr) || _nonIterableSpread$v(); } + +function _nonIterableSpread$v() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$18(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$18(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$18(o, minLen); } + +function _iterableToArray$x(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$v(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$18(arr); } + +function _arrayLikeToArray$18(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _classCallCheck$2N(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2G(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); } } + +function _createClass$2G(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2G(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2G(Constructor, staticProps); return Constructor; } + +function _get$R(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$R = Reflect.get; } else { _get$R = function _get(target, property, receiver) { var base = _superPropBase$R(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$R(target, property, receiver || target); } + +function _superPropBase$R(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1m(object); if (object === null) break; } return object; } + +function _inherits$1m(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1n(subClass, superClass); } + +function _setPrototypeOf$1n(o, p) { _setPrototypeOf$1n = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1n(o, p); } + +function _createSuper$1m(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1n(); return function _createSuperInternal() { var Super = _getPrototypeOf$1m(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1m(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1m(this, result); }; } + +function _possibleConstructorReturn$1m(self, call) { if (call && (_typeof$1z(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1m(self); } + +function _assertThisInitialized$1m(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1n() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1m(o) { _getPrototypeOf$1m = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1m(o); } +var PLUGIN_KEY$w = 'nestedRows'; +var PLUGIN_PRIORITY$u = 300; +var privatePool$l = new WeakMap(); +/** + * @plugin NestedRows + * + * @description + * Plugin responsible for displaying and operating on data sources with nested structures. + */ + +var NestedRows = /*#__PURE__*/function (_BasePlugin) { + _inherits$1m(NestedRows, _BasePlugin); + + var _super = _createSuper$1m(NestedRows); + + function NestedRows(hotInstance) { + var _this; + + _classCallCheck$2N(this, NestedRows); + + _this = _super.call(this, hotInstance); + /** + * Reference to the DataManager instance. + * + * @private + * @type {object} + */ + + _this.dataManager = null; + /** + * Reference to the HeadersUI instance. + * + * @private + * @type {object} + */ + + _this.headersUI = null; + /** + * Map of skipped rows by plugin. + * + * @private + * @type {null|TrimmingMap} + */ + + _this.collapsedRowsMap = null; + privatePool$l.set(_assertThisInitialized$1m(_this), { + movedToCollapsed: false, + skipRender: null, + skipCoreAPIModifiers: false + }); + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link NestedRows#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$2G(NestedRows, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$w]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.collapsedRowsMap = this.hot.rowIndexMapper.registerMap('nestedRows', new TrimmingMap()); + this.dataManager = new DataManager(this, this.hot); + this.collapsingUI = new CollapsingUI(this, this.hot); + this.headersUI = new HeadersUI(this, this.hot); + this.contextMenuUI = new ContextMenuUI(this, this.hot); + this.rowMoveController = new RowMoveController(this); + this.addHook('afterInit', function () { + return _this2.onAfterInit.apply(_this2, arguments); + }); + this.addHook('beforeRender', function () { + return _this2.onBeforeRender.apply(_this2, arguments); + }); + this.addHook('modifyRowData', function () { + return _this2.onModifyRowData.apply(_this2, arguments); + }); + this.addHook('modifySourceLength', function () { + return _this2.onModifySourceLength.apply(_this2, arguments); + }); + this.addHook('beforeDataSplice', function () { + return _this2.onBeforeDataSplice.apply(_this2, arguments); + }); + this.addHook('beforeDataFilter', function () { + return _this2.onBeforeDataFilter.apply(_this2, arguments); + }); + this.addHook('afterContextMenuDefaultOptions', function () { + return _this2.onAfterContextMenuDefaultOptions.apply(_this2, arguments); + }); + this.addHook('afterGetRowHeader', function () { + return _this2.onAfterGetRowHeader.apply(_this2, arguments); + }); + this.addHook('beforeOnCellMouseDown', function () { + return _this2.onBeforeOnCellMouseDown.apply(_this2, arguments); + }); + this.addHook('beforeRemoveRow', function () { + return _this2.onBeforeRemoveRow.apply(_this2, arguments); + }); + this.addHook('afterRemoveRow', function () { + return _this2.onAfterRemoveRow.apply(_this2, arguments); + }); + this.addHook('beforeAddChild', function () { + return _this2.onBeforeAddChild.apply(_this2, arguments); + }); + this.addHook('afterAddChild', function () { + return _this2.onAfterAddChild.apply(_this2, arguments); + }); + this.addHook('beforeDetachChild', function () { + return _this2.onBeforeDetachChild.apply(_this2, arguments); + }); + this.addHook('afterDetachChild', function () { + return _this2.onAfterDetachChild.apply(_this2, arguments); + }); + this.addHook('modifyRowHeaderWidth', function () { + return _this2.onModifyRowHeaderWidth.apply(_this2, arguments); + }); + this.addHook('afterCreateRow', function () { + return _this2.onAfterCreateRow.apply(_this2, arguments); + }); + this.addHook('beforeRowMove', function () { + return _this2.onBeforeRowMove.apply(_this2, arguments); + }); + this.addHook('beforeLoadData', function (data) { + return _this2.onBeforeLoadData(data); + }); + + _get$R(_getPrototypeOf$1m(NestedRows.prototype), "enablePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.hot.rowIndexMapper.unregisterMap('nestedRows'); + + _get$R(_getPrototypeOf$1m(NestedRows.prototype), "disablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + var vanillaSourceData = this.hot.getSourceData(); + this.enablePlugin(); + this.dataManager.updateWithData(vanillaSourceData); + + _get$R(_getPrototypeOf$1m(NestedRows.prototype), "updatePlugin", this).call(this); + } + /** + * `beforeRowMove` hook callback. + * + * @private + * @param {Array} rows Array of visual row indexes to be moved. + * @param {number} finalIndex Visual row index, being a start index for the moved rows. Points to where the elements + * will be placed after the moving action. To check the visualization of the final index, please take a look at + * [documentation](/docs/demo-moving.html). + * @param {undefined|number} dropIndex Visual row index, being a drop index for the moved rows. Points to where we + * are going to drop the moved elements. To check visualization of drop index please take a look at + * [documentation](/docs/demo-moving.html). + * @param {boolean} movePossible Indicates if it's possible to move rows to the desired position. + * @fires Hooks#afterRowMove + * @returns {boolean} + */ + + }, { + key: "onBeforeRowMove", + value: function onBeforeRowMove(rows, finalIndex, dropIndex, movePossible) { + return this.rowMoveController.onBeforeRowMove(rows, finalIndex, dropIndex, movePossible); + } + /** + * Enable the modify hook skipping flag - allows retrieving the data from Handsontable without this plugin's + * modifications. + */ + + }, { + key: "disableCoreAPIModifiers", + value: function disableCoreAPIModifiers() { + var priv = privatePool$l.get(this); + priv.skipCoreAPIModifiers = true; + } + /** + * Disable the modify hook skipping flag. + */ + + }, { + key: "enableCoreAPIModifiers", + value: function enableCoreAPIModifiers() { + var priv = privatePool$l.get(this); + priv.skipCoreAPIModifiers = false; + } + /** + * `beforeOnCellMousedown` hook callback. + * + * @private + * @param {MouseEvent} event Mousedown event. + * @param {object} coords Cell coords. + * @param {HTMLElement} TD Clicked cell. + */ + + }, { + key: "onBeforeOnCellMouseDown", + value: function onBeforeOnCellMouseDown(event, coords, TD) { + this.collapsingUI.toggleState(event, coords, TD); + } + /** + * The modifyRowData hook callback. + * + * @private + * @param {number} row Visual row index. + * @returns {boolean} + */ + + }, { + key: "onModifyRowData", + value: function onModifyRowData(row) { + var priv = privatePool$l.get(this); + + if (priv.skipCoreAPIModifiers) { + return; + } + + return this.dataManager.getDataObject(row); + } + /** + * Modify the source data length to match the length of the nested structure. + * + * @private + * @returns {number} + */ + + }, { + key: "onModifySourceLength", + value: function onModifySourceLength() { + var priv = privatePool$l.get(this); + + if (priv.skipCoreAPIModifiers) { + return; + } + + return this.dataManager.countAllRows(); + } + /** + * @private + * @param {number} index The index where the data was spliced. + * @param {number} amount An amount of items to remove. + * @param {object} element An element to add. + * @returns {boolean} + */ + + }, { + key: "onBeforeDataSplice", + value: function onBeforeDataSplice(index, amount, element) { + var priv = privatePool$l.get(this); + + if (priv.skipCoreAPIModifiers || this.dataManager.isRowHighestLevel(index)) { + return true; + } + + this.dataManager.spliceData(index, amount, element); + return false; + } + /** + * Called before the source data filtering. Returning `false` stops the native filtering. + * + * @private + * @param {number} index The index where the data filtering starts. + * @param {number} amount An amount of rows which filtering applies to. + * @param {number} physicalRows Physical row indexes. + * @returns {boolean} + */ + + }, { + key: "onBeforeDataFilter", + value: function onBeforeDataFilter(index, amount, physicalRows) { + var priv = privatePool$l.get(this); + this.collapsingUI.collapsedRowsStash.stash(); + this.collapsingUI.collapsedRowsStash.trimStash(physicalRows[0], amount); + this.collapsingUI.collapsedRowsStash.shiftStash(physicalRows[0], null, -1 * amount); + this.dataManager.filterData(index, amount, physicalRows); + priv.skipRender = true; + return false; + } + /** + * `afterContextMenuDefaultOptions` hook callback. + * + * @private + * @param {object} defaultOptions The default context menu items order. + * @returns {boolean} + */ + + }, { + key: "onAfterContextMenuDefaultOptions", + value: function onAfterContextMenuDefaultOptions(defaultOptions) { + return this.contextMenuUI.appendOptions(defaultOptions); + } + /** + * `afterGetRowHeader` hook callback. + * + * @private + * @param {number} row Row index. + * @param {HTMLElement} TH Row header element. + */ + + }, { + key: "onAfterGetRowHeader", + value: function onAfterGetRowHeader(row, TH) { + this.headersUI.appendLevelIndicators(row, TH); + } + /** + * `modifyRowHeaderWidth` hook callback. + * + * @private + * @param {number} rowHeaderWidth The initial row header width(s). + * @returns {number} + */ + + }, { + key: "onModifyRowHeaderWidth", + value: function onModifyRowHeaderWidth(rowHeaderWidth) { + return this.headersUI.rowHeaderWidthCache || rowHeaderWidth; + } + /** + * `onAfterRemoveRow` hook callback. + * + * @private + * @param {number} index Removed row. + * @param {number} amount Amount of removed rows. + * @param {Array} logicRows An array of the removed physical rows. + * @param {string} source Source of action. + */ + + }, { + key: "onAfterRemoveRow", + value: function onAfterRemoveRow(index, amount, logicRows, source) { + var _this3 = this; + + if (source === this.pluginName) { + return; + } + + var priv = privatePool$l.get(this); + setTimeout(function () { + priv.skipRender = null; + + _this3.headersUI.updateRowHeaderWidth(); + + _this3.collapsingUI.collapsedRowsStash.applyStash(); + }, 0); + } + /** + * Callback for the `beforeRemoveRow` change list of removed physical indexes by reference. Removing parent node + * has effect in removing children nodes. + * + * @private + * @param {number} index Visual index of starter row. + * @param {number} amount Amount of rows to be removed. + * @param {Array} physicalRows List of physical indexes. + */ + + }, { + key: "onBeforeRemoveRow", + value: function onBeforeRemoveRow(index, amount, physicalRows) { + var _this4 = this; + + var modifiedPhysicalRows = Array.from(physicalRows.reduce(function (removedRows, physicalIndex) { + if (_this4.dataManager.isParent(physicalIndex)) { + var children = _this4.dataManager.getDataObject(physicalIndex).__children; // Preserve a parent in the list of removed rows. + + + removedRows.add(physicalIndex); + + if (Array.isArray(children)) { + // Add a children to the list of removed rows. + children.forEach(function (child) { + return removedRows.add(_this4.dataManager.getRowIndex(child)); + }); + } + + return removedRows; + } // Don't modify list of removed rows when already checked element isn't a parent. + + + return removedRows.add(physicalIndex); + }, new Set())); // Modifying hook's argument by the reference. + + physicalRows.length = 0; + physicalRows.push.apply(physicalRows, _toConsumableArray$x(modifiedPhysicalRows)); + } + /** + * `beforeAddChild` hook callback. + * + * @private + */ + + }, { + key: "onBeforeAddChild", + value: function onBeforeAddChild() { + this.collapsingUI.collapsedRowsStash.stash(); + } + /** + * `afterAddChild` hook callback. + * + * @private + * @param {object} parent Parent element. + * @param {object} element New child element. + */ + + }, { + key: "onAfterAddChild", + value: function onAfterAddChild(parent, element) { + this.collapsingUI.collapsedRowsStash.shiftStash(this.dataManager.getRowIndex(element)); + this.collapsingUI.collapsedRowsStash.applyStash(); + this.headersUI.updateRowHeaderWidth(); + } + /** + * `beforeDetachChild` hook callback. + * + * @private + */ + + }, { + key: "onBeforeDetachChild", + value: function onBeforeDetachChild() { + this.collapsingUI.collapsedRowsStash.stash(); + } + /** + * `afterDetachChild` hook callback. + * + * @private + * @param {object} parent Parent element. + * @param {object} element New child element. + */ + + }, { + key: "onAfterDetachChild", + value: function onAfterDetachChild(parent, element) { + this.collapsingUI.collapsedRowsStash.shiftStash(this.dataManager.getRowIndex(element), null, -1); + this.collapsingUI.collapsedRowsStash.applyStash(); + this.headersUI.updateRowHeaderWidth(); + } + /** + * `afterCreateRow` hook callback. + * + * @private + * @param {number} index Represents the visual index of first newly created row in the data source array. + * @param {number} amount Number of newly created rows in the data source array. + * @param {string} source String that identifies source of hook call. + */ + + }, { + key: "onAfterCreateRow", + value: function onAfterCreateRow(index, amount, source) { + if (source === this.pluginName) { + return; + } + + this.dataManager.updateWithData(this.dataManager.getRawSourceData()); + } + /** + * `afterInit` hook callback. + * + * @private + */ + + }, { + key: "onAfterInit", + value: function onAfterInit() { + var deepestLevel = Math.max.apply(Math, _toConsumableArray$x(this.dataManager.cache.levels)); + + if (deepestLevel > 0) { + this.headersUI.updateRowHeaderWidth(deepestLevel); + } + } + /** + * `beforeRender` hook callback. + * + * @param {boolean} force Indicates if the render call was trigered by a change of settings or data. + * @param {object} skipRender An object, holder for skipRender functionality. + * @private + */ + + }, { + key: "onBeforeRender", + value: function onBeforeRender(force, skipRender) { + var priv = privatePool$l.get(this); + + if (priv.skipRender) { + skipRender.skipRender = true; + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.rowIndexMapper.unregisterMap('nestedRows'); + + _get$R(_getPrototypeOf$1m(NestedRows.prototype), "destroy", this).call(this); + } + /** + * `beforeLoadData` hook callback. + * + * @param {Array} data The source data. + * @private + */ + + }, { + key: "onBeforeLoadData", + value: function onBeforeLoadData(data) { + this.dataManager.setData(data); + this.dataManager.rewriteCache(); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$w; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$u; + } + }]); + + return NestedRows; +}(BasePlugin); + +function _slicedToArray$M(arr, i) { return _arrayWithHoles$O(arr) || _iterableToArrayLimit$M(arr, i) || _unsupportedIterableToArray$19(arr, i) || _nonIterableRest$O(); } + +function _nonIterableRest$O() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$19(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$19(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$19(o, minLen); } + +function _arrayLikeToArray$19(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$M(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$O(arr) { if (Array.isArray(arr)) return arr; } +/** + * @param {HiddenColumns} hiddenColumnsPlugin The plugin instance. + * @returns {object} + */ + +function hideColumnItem(hiddenColumnsPlugin) { + return { + key: 'hidden_columns_hide', + name: function name() { + var selection = this.getSelectedLast(); + var pluralForm = 0; + + if (Array.isArray(selection)) { + var _selection = _slicedToArray$M(selection, 4), + fromColumn = _selection[1], + toColumn = _selection[3]; + + if (fromColumn - toColumn !== 0) { + pluralForm = 1; + } + } + + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_HIDE_COLUMN, pluralForm); + }, + callback: function callback() { + var _this$getSelectedRang = this.getSelectedRangeLast(), + from = _this$getSelectedRang.from, + to = _this$getSelectedRang.to; + + var start = Math.max(Math.min(from.col, to.col), 0); + var end = Math.max(from.col, to.col); + var columnsToHide = []; + + for (var visualColumn = start; visualColumn <= end; visualColumn += 1) { + columnsToHide.push(visualColumn); + } + + var firstHiddenColumn = columnsToHide[0]; + var lastHiddenColumn = columnsToHide[columnsToHide.length - 1]; // Looking for a visual index on the right and then (when not found) on the left. + + var columnToSelect = this.columnIndexMapper.getFirstNotHiddenIndex(lastHiddenColumn + 1, 1, true, firstHiddenColumn - 1); + hiddenColumnsPlugin.hideColumns(columnsToHide); + + if (Number.isInteger(columnToSelect) && columnToSelect >= 0) { + this.selectColumns(columnToSelect); + } else { + this.deselectCell(); + } + + this.render(); + this.view.adjustElementsSize(true); + }, + disabled: false, + hidden: function hidden() { + return !(this.selection.isSelectedByColumnHeader() || this.selection.isSelectedByCorner()); + } + }; +} + +function _toConsumableArray$y(arr) { return _arrayWithoutHoles$w(arr) || _iterableToArray$y(arr) || _unsupportedIterableToArray$1a(arr) || _nonIterableSpread$w(); } + +function _nonIterableSpread$w() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$1a(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1a(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1a(o, minLen); } + +function _iterableToArray$y(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$w(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$1a(arr); } + +function _arrayLikeToArray$1a(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } +/** + * @param {HiddenColumns} hiddenColumnsPlugin The plugin instance. + * @returns {object} + */ + +function showColumnItem(hiddenColumnsPlugin) { + var columns = []; + return { + key: 'hidden_columns_show', + name: function name() { + var pluralForm = columns.length > 1 ? 1 : 0; + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_SHOW_COLUMN, pluralForm); + }, + callback: function callback() { + var _this$columnIndexMapp, _this$columnIndexMapp2; + + if (columns.length === 0) { + return; + } + + var startVisualColumn = columns[0]; + var endVisualColumn = columns[columns.length - 1]; // Add to the selection one more visual column on the left. + + startVisualColumn = (_this$columnIndexMapp = this.columnIndexMapper.getFirstNotHiddenIndex(startVisualColumn - 1, -1)) !== null && _this$columnIndexMapp !== void 0 ? _this$columnIndexMapp : 0; // Add to the selection one more visual column on the right. + + endVisualColumn = (_this$columnIndexMapp2 = this.columnIndexMapper.getFirstNotHiddenIndex(endVisualColumn + 1, 1)) !== null && _this$columnIndexMapp2 !== void 0 ? _this$columnIndexMapp2 : this.countCols() - 1; + hiddenColumnsPlugin.showColumns(columns); // We render columns at first. It was needed for getting fixed columns. + // Please take a look at #6864 for broader description. + + this.render(); + this.view.adjustElementsSize(true); + var allColumnsSelected = endVisualColumn - startVisualColumn + 1 === this.countCols(); // When all headers needs to be selected then do nothing. The header selection is + // automatically handled by corner click. + + if (!allColumnsSelected) { + this.selectColumns(startVisualColumn, endVisualColumn); + } + }, + disabled: false, + hidden: function hidden() { + var _this = this; + + var hiddenPhysicalColumns = arrayMap(hiddenColumnsPlugin.getHiddenColumns(), function (visualColumnIndex) { + return _this.toPhysicalColumn(visualColumnIndex); + }); + + if (!(this.selection.isSelectedByColumnHeader() || this.selection.isSelectedByCorner()) || hiddenPhysicalColumns.length < 1) { + return true; + } + + columns.length = 0; + var selectedRangeLast = this.getSelectedRangeLast(); + var visualStartColumn = selectedRangeLast.getTopLeftCorner().col; + var visualEndColumn = selectedRangeLast.getBottomRightCorner().col; + var columnIndexMapper = this.columnIndexMapper; + var renderableStartColumn = columnIndexMapper.getRenderableFromVisualIndex(visualStartColumn); + var renderableEndColumn = columnIndexMapper.getRenderableFromVisualIndex(visualEndColumn); + var notTrimmedColumnIndexes = columnIndexMapper.getNotTrimmedIndexes(); + var physicalColumnIndexes = []; + + if (visualStartColumn !== visualEndColumn) { + var visualColumnsInRange = visualEndColumn - visualStartColumn + 1; + var renderedColumnsInRange = renderableEndColumn - renderableStartColumn + 1; // Collect not trimmed columns if there are some hidden columns in the selection range. + + if (visualColumnsInRange > renderedColumnsInRange) { + var physicalIndexesInRange = notTrimmedColumnIndexes.slice(visualStartColumn, visualEndColumn + 1); + physicalColumnIndexes.push.apply(physicalColumnIndexes, _toConsumableArray$y(physicalIndexesInRange.filter(function (physicalIndex) { + return hiddenPhysicalColumns.includes(physicalIndex); + }))); + } // Handled column is the first rendered index and there are some visual indexes before it. + + } else if (renderableStartColumn === 0 && renderableStartColumn < visualStartColumn) { + // not trimmed indexes -> array of mappings from visual (native array's index) to physical indexes (value). + physicalColumnIndexes.push.apply(physicalColumnIndexes, _toConsumableArray$y(notTrimmedColumnIndexes.slice(0, visualStartColumn))); // physical indexes + // When all columns are hidden and the context menu is triggered using top-left corner. + } else if (renderableStartColumn === null) { + // Show all hidden columns. + physicalColumnIndexes.push.apply(physicalColumnIndexes, _toConsumableArray$y(notTrimmedColumnIndexes.slice(0, this.countCols()))); + } else { + var lastVisualIndex = this.countCols() - 1; + var lastRenderableIndex = columnIndexMapper.getRenderableFromVisualIndex(columnIndexMapper.getFirstNotHiddenIndex(lastVisualIndex, -1)); // Handled column is the last rendered index and there are some visual indexes after it. + + if (renderableEndColumn === lastRenderableIndex && lastVisualIndex > visualEndColumn) { + physicalColumnIndexes.push.apply(physicalColumnIndexes, _toConsumableArray$y(notTrimmedColumnIndexes.slice(visualEndColumn + 1))); + } + } + + arrayEach(physicalColumnIndexes, function (physicalColumnIndex) { + columns.push(_this.toVisualColumn(physicalColumnIndex)); + }); + return columns.length === 0; + } + }; +} + +function _typeof$1A(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1A = function _typeof(obj) { return typeof obj; }; } else { _typeof$1A = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1A(obj); } + +function _classCallCheck$2O(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2H(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); } } + +function _createClass$2H(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2H(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2H(Constructor, staticProps); return Constructor; } + +function _get$S(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$S = Reflect.get; } else { _get$S = function _get(target, property, receiver) { var base = _superPropBase$S(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$S(target, property, receiver || target); } + +function _superPropBase$S(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1n(object); if (object === null) break; } return object; } + +function _inherits$1n(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1o(subClass, superClass); } + +function _setPrototypeOf$1o(o, p) { _setPrototypeOf$1o = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1o(o, p); } + +function _createSuper$1n(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1o(); return function _createSuperInternal() { var Super = _getPrototypeOf$1n(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1n(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1n(this, result); }; } + +function _possibleConstructorReturn$1n(self, call) { if (call && (_typeof$1A(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1n(self); } + +function _assertThisInitialized$1n(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1o() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1n(o) { _getPrototypeOf$1n = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1n(o); } + +function _classPrivateFieldGet$5(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet$5(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; } +Hooks.getSingleton().register('beforeHideColumns'); +Hooks.getSingleton().register('afterHideColumns'); +Hooks.getSingleton().register('beforeUnhideColumns'); +Hooks.getSingleton().register('afterUnhideColumns'); +var PLUGIN_KEY$x = 'hiddenColumns'; +var PLUGIN_PRIORITY$v = 310; +/** + * @plugin HiddenColumns + * + * @description + * Plugin allows to hide certain columns. The hiding is achieved by not rendering the columns. The plugin not modifies + * the source data and do not participate in data transformation (the shape of data returned by `getData*` methods stays intact). + * + * Possible plugin settings: + * * `copyPasteEnabled` as `Boolean` (default `true`) + * * `columns` as `Array` + * * `indicators` as `Boolean` (default `false`). + * + * @example + * + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData(), + * hiddenColumns: { + * copyPasteEnabled: true, + * indicators: true, + * columns: [1, 2, 5] + * } + * }); + * + * // access to hiddenColumns plugin instance: + * const hiddenColumnsPlugin = hot.getPlugin('hiddenColumns'); + * + * // show single column + * hiddenColumnsPlugin.showColumn(1); + * + * // show multiple columns + * hiddenColumnsPlugin.showColumn(1, 2, 9); + * + * // or as an array + * hiddenColumnsPlugin.showColumns([1, 2, 9]); + * + * // hide single column + * hiddenColumnsPlugin.hideColumn(1); + * + * // hide multiple columns + * hiddenColumnsPlugin.hideColumn(1, 2, 9); + * + * // or as an array + * hiddenColumnsPlugin.hideColumns([1, 2, 9]); + * + * // rerender the table to see all changes + * hot.render(); + * ``` + */ + +var _settings = new WeakMap(); + +var _hiddenColumnsMap = new WeakMap(); + +var HiddenColumns = /*#__PURE__*/function (_BasePlugin) { + _inherits$1n(HiddenColumns, _BasePlugin); + + var _super = _createSuper$1n(HiddenColumns); + + function HiddenColumns() { + var _this; + + _classCallCheck$2O(this, HiddenColumns); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _settings.set(_assertThisInitialized$1n(_this), { + writable: true, + value: {} + }); + + _hiddenColumnsMap.set(_assertThisInitialized$1n(_this), { + writable: true, + value: null + }); + + return _this; + } + + _createClass$2H(HiddenColumns, [{ + key: "isEnabled", + value: + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link HiddenColumns#enablePlugin} method is called. + * + * @returns {boolean} + */ + function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$x]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var pluginSettings = this.hot.getSettings()[PLUGIN_KEY$x]; + + if (isObject$1(pluginSettings)) { + _classPrivateFieldSet$5(this, _settings, pluginSettings); + + if (isUndefined(pluginSettings.copyPasteEnabled)) { + pluginSettings.copyPasteEnabled = true; + } + } + + _classPrivateFieldSet$5(this, _hiddenColumnsMap, new HidingMap()); + + _classPrivateFieldGet$5(this, _hiddenColumnsMap).addLocalHook('init', function () { + return _this2.onMapInit(); + }); + + this.hot.columnIndexMapper.registerMap(this.pluginName, _classPrivateFieldGet$5(this, _hiddenColumnsMap)); + this.addHook('afterContextMenuDefaultOptions', function () { + return _this2.onAfterContextMenuDefaultOptions.apply(_this2, arguments); + }); + this.addHook('afterGetCellMeta', function (row, col, cellProperties) { + return _this2.onAfterGetCellMeta(row, col, cellProperties); + }); + this.addHook('modifyColWidth', function (width, col) { + return _this2.onModifyColWidth(width, col); + }); + this.addHook('afterGetColHeader', function () { + return _this2.onAfterGetColHeader.apply(_this2, arguments); + }); + this.addHook('modifyCopyableRange', function (ranges) { + return _this2.onModifyCopyableRange(ranges); + }); + + _get$S(_getPrototypeOf$1n(HiddenColumns.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$S(_getPrototypeOf$1n(HiddenColumns.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.hot.columnIndexMapper.unregisterMap(this.pluginName); + + _classPrivateFieldSet$5(this, _settings, {}); + + _get$S(_getPrototypeOf$1n(HiddenColumns.prototype), "disablePlugin", this).call(this); + + this.resetCellsMeta(); + } + /** + * Shows the provided columns. + * + * @param {number[]} columns Array of visual column indexes. + */ + + }, { + key: "showColumns", + value: function showColumns(columns) { + var _this3 = this; + + var currentHideConfig = this.getHiddenColumns(); + var isValidConfig = this.isValidConfig(columns); + var destinationHideConfig = currentHideConfig; + + var hidingMapValues = _classPrivateFieldGet$5(this, _hiddenColumnsMap).getValues().slice(); + + var isAnyColumnShowed = columns.length > 0; + + if (isValidConfig && isAnyColumnShowed) { + var physicalColumns = columns.map(function (visualColumn) { + return _this3.hot.toPhysicalColumn(visualColumn); + }); // Preparing new values for hiding map. + + arrayEach(physicalColumns, function (physicalColumn) { + hidingMapValues[physicalColumn] = false; + }); // Preparing new hiding config. + + destinationHideConfig = arrayReduce(hidingMapValues, function (hiddenIndexes, isHidden, physicalIndex) { + if (isHidden) { + hiddenIndexes.push(_this3.hot.toVisualColumn(physicalIndex)); + } + + return hiddenIndexes; + }, []); + } + + var continueHiding = this.hot.runHooks('beforeUnhideColumns', currentHideConfig, destinationHideConfig, isValidConfig && isAnyColumnShowed); + + if (continueHiding === false) { + return; + } + + if (isValidConfig && isAnyColumnShowed) { + _classPrivateFieldGet$5(this, _hiddenColumnsMap).setValues(hidingMapValues); + } // @TODO Should call once per render cycle, currently fired separately in different plugins + + + this.hot.view.adjustElementsSize(); + this.hot.runHooks('afterUnhideColumns', currentHideConfig, destinationHideConfig, isValidConfig && isAnyColumnShowed, isValidConfig && destinationHideConfig.length < currentHideConfig.length); + } + /** + * Shows a single column. + * + * @param {...number} column Visual column index. + */ + + }, { + key: "showColumn", + value: function showColumn() { + for (var _len2 = arguments.length, column = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + column[_key2] = arguments[_key2]; + } + + this.showColumns(column); + } + /** + * Hides the columns provided in the array. + * + * @param {number[]} columns Array of visual column indexes. + */ + + }, { + key: "hideColumns", + value: function hideColumns(columns) { + var _this4 = this; + + var currentHideConfig = this.getHiddenColumns(); + var isConfigValid = this.isValidConfig(columns); + var destinationHideConfig = currentHideConfig; + + if (isConfigValid) { + destinationHideConfig = Array.from(new Set(currentHideConfig.concat(columns))); + } + + var continueHiding = this.hot.runHooks('beforeHideColumns', currentHideConfig, destinationHideConfig, isConfigValid); + + if (continueHiding === false) { + return; + } + + if (isConfigValid) { + this.hot.batchExecution(function () { + arrayEach(columns, function (visualColumn) { + _classPrivateFieldGet$5(_this4, _hiddenColumnsMap).setValueAtIndex(_this4.hot.toPhysicalColumn(visualColumn), true); + }); + }, true); + } + + this.hot.runHooks('afterHideColumns', currentHideConfig, destinationHideConfig, isConfigValid, isConfigValid && destinationHideConfig.length > currentHideConfig.length); + } + /** + * Hides a single column. + * + * @param {...number} column Visual column index. + */ + + }, { + key: "hideColumn", + value: function hideColumn() { + for (var _len3 = arguments.length, column = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + column[_key3] = arguments[_key3]; + } + + this.hideColumns(column); + } + /** + * Returns an array of visual indexes of hidden columns. + * + * @returns {number[]} + */ + + }, { + key: "getHiddenColumns", + value: function getHiddenColumns() { + var _this5 = this; + + return arrayMap(_classPrivateFieldGet$5(this, _hiddenColumnsMap).getHiddenIndexes(), function (physicalColumnIndex) { + return _this5.hot.toVisualColumn(physicalColumnIndex); + }); + } + /** + * Checks if the provided column is hidden. + * + * @param {number} column Visual column index. + * @returns {boolean} + */ + + }, { + key: "isHidden", + value: function isHidden(column) { + return _classPrivateFieldGet$5(this, _hiddenColumnsMap).getValueAtIndex(this.hot.toPhysicalColumn(column)) || false; + } + /** + * Get if trim config is valid. Check whether all of the provided column indexes are within the bounds of the table. + * + * @param {Array} hiddenColumns List of hidden column indexes. + * @returns {boolean} + */ + + }, { + key: "isValidConfig", + value: function isValidConfig(hiddenColumns) { + var nrOfColumns = this.hot.countCols(); + + if (Array.isArray(hiddenColumns) && hiddenColumns.length > 0) { + return hiddenColumns.every(function (visualColumn) { + return Number.isInteger(visualColumn) && visualColumn >= 0 && visualColumn < nrOfColumns; + }); + } + + return false; + } + /** + * Reset all rendered cells meta. + * + * @private + */ + + }, { + key: "resetCellsMeta", + value: function resetCellsMeta() { + arrayEach(this.hot.getCellsMeta(), function (meta) { + if (meta) { + meta.skipColumnOnPaste = false; + } + }); + } + /** + * Adds the additional column width for the hidden column indicators. + * + * @private + * @param {number|undefined} width Column width. + * @param {number} column Visual column index. + * @returns {number} + */ + + }, { + key: "onModifyColWidth", + value: function onModifyColWidth(width, column) { + // Hook is triggered internally only for the visible columns. Conditional will be handled for the API + // calls of the `getColWidth` function on not visible indexes. + if (this.isHidden(column)) { + return 0; + } + + if (_classPrivateFieldGet$5(this, _settings).indicators && (this.isHidden(column + 1) || this.isHidden(column - 1))) { + // Add additional space for hidden column indicator. + if (typeof width === 'number' && this.hot.hasColHeaders()) { + return width + 15; + } + } + } + /** + * Sets the copy-related cell meta. + * + * @private + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {object} cellProperties Object containing the cell properties. + */ + + }, { + key: "onAfterGetCellMeta", + value: function onAfterGetCellMeta(row, column, cellProperties) { + if (_classPrivateFieldGet$5(this, _settings).copyPasteEnabled === false && this.isHidden(column)) { + // Cell property handled by the `Autofill` and the `CopyPaste` plugins. + cellProperties.skipColumnOnPaste = true; + } + + if (this.isHidden(column - 1)) { + cellProperties.className = cellProperties.className || ''; + + if (cellProperties.className.indexOf('afterHiddenColumn') === -1) { + cellProperties.className += ' afterHiddenColumn'; + } + } else if (cellProperties.className) { + var classArr = cellProperties.className.split(' '); + + if (classArr.length > 0) { + var containAfterHiddenColumn = classArr.indexOf('afterHiddenColumn'); + + if (containAfterHiddenColumn > -1) { + classArr.splice(containAfterHiddenColumn, 1); + } + + cellProperties.className = classArr.join(' '); + } + } + } + /** + * Modifies the copyable range, accordingly to the provided config. + * + * @private + * @param {Array} ranges An array of objects defining copyable cells. + * @returns {Array} + */ + + }, { + key: "onModifyCopyableRange", + value: function onModifyCopyableRange(ranges) { + var _this6 = this; + + // Ranges shouldn't be modified when `copyPasteEnabled` option is set to `true` (by default). + if (_classPrivateFieldGet$5(this, _settings).copyPasteEnabled) { + return ranges; + } + + var newRanges = []; + + var pushRange = function pushRange(startRow, endRow, startCol, endCol) { + newRanges.push({ + startRow: startRow, + endRow: endRow, + startCol: startCol, + endCol: endCol + }); + }; + + arrayEach(ranges, function (range) { + var isHidden = true; + var rangeStart = 0; + rangeEach(range.startCol, range.endCol, function (visualColumn) { + if (_this6.isHidden(visualColumn)) { + if (!isHidden) { + pushRange(range.startRow, range.endRow, rangeStart, visualColumn - 1); + } + + isHidden = true; + } else { + if (isHidden) { + rangeStart = visualColumn; + } + + if (visualColumn === range.endCol) { + pushRange(range.startRow, range.endRow, rangeStart, visualColumn); + } + + isHidden = false; + } + }); + }); + return newRanges; + } + /** + * Adds the needed classes to the headers. + * + * @private + * @param {number} column Visual column index. + * @param {HTMLElement} TH Header's TH element. + */ + + }, { + key: "onAfterGetColHeader", + value: function onAfterGetColHeader(column, TH) { + if (!_classPrivateFieldGet$5(this, _settings).indicators || column < 0) { + return; + } + + var classList = []; + + if (column >= 1 && this.isHidden(column - 1)) { + classList.push('afterHiddenColumn'); + } + + if (column < this.hot.countCols() - 1 && this.isHidden(column + 1)) { + classList.push('beforeHiddenColumn'); + } + + addClass(TH, classList); + } + /** + * Add Show-hide columns to context menu. + * + * @private + * @param {object} options An array of objects containing information about the pre-defined Context Menu items. + */ + + }, { + key: "onAfterContextMenuDefaultOptions", + value: function onAfterContextMenuDefaultOptions(options) { + options.items.push({ + name: KEY + }, hideColumnItem(this), showColumnItem(this)); + } + /** + * On map initialized hook callback. + * + * @private + */ + + }, { + key: "onMapInit", + value: function onMapInit() { + if (Array.isArray(_classPrivateFieldGet$5(this, _settings).columns)) { + this.hideColumns(_classPrivateFieldGet$5(this, _settings).columns); + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.columnIndexMapper.unregisterMap(this.pluginName); + + _classPrivateFieldSet$5(this, _settings, null); + + _classPrivateFieldSet$5(this, _hiddenColumnsMap, null); + + _get$S(_getPrototypeOf$1n(HiddenColumns.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$x; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$v; + } + /** + * Cached plugin settings. + * + * @private + * @type {object} + */ + + }]); + + return HiddenColumns; +}(BasePlugin); + +function _slicedToArray$N(arr, i) { return _arrayWithHoles$P(arr) || _iterableToArrayLimit$N(arr, i) || _unsupportedIterableToArray$1b(arr, i) || _nonIterableRest$P(); } + +function _nonIterableRest$P() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$1b(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1b(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1b(o, minLen); } + +function _arrayLikeToArray$1b(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit$N(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles$P(arr) { if (Array.isArray(arr)) return arr; } +/** + * @param {HiddenRows} hiddenRowsPlugin The plugin instance. + * @returns {object} + */ + +function hideRowItem(hiddenRowsPlugin) { + return { + key: 'hidden_rows_hide', + name: function name() { + var selection = this.getSelectedLast(); + var pluralForm = 0; + + if (Array.isArray(selection)) { + var _selection = _slicedToArray$N(selection, 3), + fromRow = _selection[0], + toRow = _selection[2]; + + if (fromRow - toRow !== 0) { + pluralForm = 1; + } + } + + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_HIDE_ROW, pluralForm); + }, + callback: function callback() { + var _this$getSelectedRang = this.getSelectedRangeLast(), + from = _this$getSelectedRang.from, + to = _this$getSelectedRang.to; + + var start = Math.max(Math.min(from.row, to.row), 0); + var end = Math.max(from.row, to.row); + var rowsToHide = []; + + for (var visualRow = start; visualRow <= end; visualRow += 1) { + rowsToHide.push(visualRow); + } + + var firstHiddenRow = rowsToHide[0]; + var lastHiddenRow = rowsToHide[rowsToHide.length - 1]; // Looking for a visual index on the top and then (when not found) on the bottom. + + var rowToSelect = this.rowIndexMapper.getFirstNotHiddenIndex(lastHiddenRow + 1, 1, true, firstHiddenRow - 1); + hiddenRowsPlugin.hideRows(rowsToHide); + + if (Number.isInteger(rowToSelect) && rowToSelect >= 0) { + this.selectRows(rowToSelect); + } else { + this.deselectCell(); + } + + this.render(); + this.view.adjustElementsSize(true); + }, + disabled: false, + hidden: function hidden() { + return !(this.selection.isSelectedByRowHeader() || this.selection.isSelectedByCorner()); + } + }; +} + +function _toConsumableArray$z(arr) { return _arrayWithoutHoles$x(arr) || _iterableToArray$z(arr) || _unsupportedIterableToArray$1c(arr) || _nonIterableSpread$x(); } + +function _nonIterableSpread$x() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray$1c(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1c(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1c(o, minLen); } + +function _iterableToArray$z(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); } + +function _arrayWithoutHoles$x(arr) { if (Array.isArray(arr)) return _arrayLikeToArray$1c(arr); } + +function _arrayLikeToArray$1c(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } +/** + * @param {HiddenRows} hiddenRowsPlugin The plugin instance. + * @returns {object} + */ + +function showRowItem(hiddenRowsPlugin) { + var rows = []; + return { + key: 'hidden_rows_show', + name: function name() { + var pluralForm = rows.length > 1 ? 1 : 0; + return this.getTranslatedPhrase(CONTEXTMENU_ITEMS_SHOW_ROW, pluralForm); + }, + callback: function callback() { + var _this$rowIndexMapper$, _this$rowIndexMapper$2; + + if (rows.length === 0) { + return; + } + + var startVisualRow = rows[0]; + var endVisualRow = rows[rows.length - 1]; // Add to the selection one more visual row on the top. + + startVisualRow = (_this$rowIndexMapper$ = this.rowIndexMapper.getFirstNotHiddenIndex(startVisualRow - 1, -1)) !== null && _this$rowIndexMapper$ !== void 0 ? _this$rowIndexMapper$ : 0; // Add to the selection one more visual row on the bottom. + + endVisualRow = (_this$rowIndexMapper$2 = this.rowIndexMapper.getFirstNotHiddenIndex(endVisualRow + 1, 1)) !== null && _this$rowIndexMapper$2 !== void 0 ? _this$rowIndexMapper$2 : this.countRows() - 1; + hiddenRowsPlugin.showRows(rows); // We render rows at first. It was needed for getting fixed rows. + // Please take a look at #6864 for broader description. + + this.render(); + this.view.adjustElementsSize(true); + var allRowsSelected = endVisualRow - startVisualRow + 1 === this.countRows(); // When all headers needs to be selected then do nothing. The header selection is + // automatically handled by corner click. + + if (!allRowsSelected) { + this.selectRows(startVisualRow, endVisualRow); + } + }, + disabled: false, + hidden: function hidden() { + var _this = this; + + var hiddenPhysicalRows = arrayMap(hiddenRowsPlugin.getHiddenRows(), function (visualRowIndex) { + return _this.toPhysicalRow(visualRowIndex); + }); + + if (!(this.selection.isSelectedByRowHeader() || this.selection.isSelectedByCorner()) || hiddenPhysicalRows.length < 1) { + return true; + } + + rows.length = 0; + var selectedRangeLast = this.getSelectedRangeLast(); + var visualStartRow = selectedRangeLast.getTopLeftCorner().row; + var visualEndRow = selectedRangeLast.getBottomRightCorner().row; + var rowIndexMapper = this.rowIndexMapper; + var renderableStartRow = rowIndexMapper.getRenderableFromVisualIndex(visualStartRow); + var renderableEndRow = rowIndexMapper.getRenderableFromVisualIndex(visualEndRow); + var notTrimmedRowIndexes = rowIndexMapper.getNotTrimmedIndexes(); + var physicalRowIndexes = []; + + if (visualStartRow !== visualEndRow) { + var visualRowsInRange = visualEndRow - visualStartRow + 1; + var renderedRowsInRange = renderableEndRow - renderableStartRow + 1; // Collect not trimmed rows if there are some hidden rows in the selection range. + + if (visualRowsInRange > renderedRowsInRange) { + var physicalIndexesInRange = notTrimmedRowIndexes.slice(visualStartRow, visualEndRow + 1); + physicalRowIndexes.push.apply(physicalRowIndexes, _toConsumableArray$z(physicalIndexesInRange.filter(function (physicalIndex) { + return hiddenPhysicalRows.includes(physicalIndex); + }))); + } // Handled row is the first rendered index and there are some visual indexes before it. + + } else if (renderableStartRow === 0 && renderableStartRow < visualStartRow) { + // not trimmed indexes -> array of mappings from visual (native array's index) to physical indexes (value). + physicalRowIndexes.push.apply(physicalRowIndexes, _toConsumableArray$z(notTrimmedRowIndexes.slice(0, visualStartRow))); // physical indexes + // When all rows are hidden and the context menu is triggered using top-left corner. + } else if (renderableStartRow === null) { + // Show all hidden rows. + physicalRowIndexes.push.apply(physicalRowIndexes, _toConsumableArray$z(notTrimmedRowIndexes.slice(0, this.countRows()))); + } else { + var lastVisualIndex = this.countRows() - 1; + var lastRenderableIndex = rowIndexMapper.getRenderableFromVisualIndex(rowIndexMapper.getFirstNotHiddenIndex(lastVisualIndex, -1)); // Handled row is the last rendered index and there are some visual indexes after it. + + if (renderableEndRow === lastRenderableIndex && lastVisualIndex > visualEndRow) { + physicalRowIndexes.push.apply(physicalRowIndexes, _toConsumableArray$z(notTrimmedRowIndexes.slice(visualEndRow + 1))); + } + } + + arrayEach(physicalRowIndexes, function (physicalRowIndex) { + rows.push(_this.toVisualRow(physicalRowIndex)); + }); + return rows.length === 0; + } + }; +} + +function _typeof$1B(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1B = function _typeof(obj) { return typeof obj; }; } else { _typeof$1B = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1B(obj); } + +function _classCallCheck$2P(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2I(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); } } + +function _createClass$2I(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2I(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2I(Constructor, staticProps); return Constructor; } + +function _get$T(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$T = Reflect.get; } else { _get$T = function _get(target, property, receiver) { var base = _superPropBase$T(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$T(target, property, receiver || target); } + +function _superPropBase$T(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1o(object); if (object === null) break; } return object; } + +function _inherits$1o(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1p(subClass, superClass); } + +function _setPrototypeOf$1p(o, p) { _setPrototypeOf$1p = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1p(o, p); } + +function _createSuper$1o(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1p(); return function _createSuperInternal() { var Super = _getPrototypeOf$1o(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1o(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1o(this, result); }; } + +function _possibleConstructorReturn$1o(self, call) { if (call && (_typeof$1B(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1o(self); } + +function _assertThisInitialized$1o(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1p() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1o(o) { _getPrototypeOf$1o = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1o(o); } + +function _classPrivateFieldGet$6(receiver, privateMap) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to get private field on non-instance"); } if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet$6(receiver, privateMap, value) { var descriptor = privateMap.get(receiver); if (!descriptor) { throw new TypeError("attempted to set private field on non-instance"); } if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } return value; } +Hooks.getSingleton().register('beforeHideRows'); +Hooks.getSingleton().register('afterHideRows'); +Hooks.getSingleton().register('beforeUnhideRows'); +Hooks.getSingleton().register('afterUnhideRows'); +var PLUGIN_KEY$y = 'hiddenRows'; +var PLUGIN_PRIORITY$w = 320; +/** + * @plugin HiddenRows + * + * @description + * Plugin allows to hide certain rows. The hiding is achieved by rendering the rows with height set as 0px. + * The plugin not modifies the source data and do not participate in data transformation (the shape of data returned + * by `getData*` methods stays intact). + * + * Possible plugin settings: + * * `copyPasteEnabled` as `Boolean` (default `true`) + * * `rows` as `Array` + * * `indicators` as `Boolean` (default `false`). + * + * @example + * + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData(), + * hiddenRows: { + * copyPasteEnabled: true, + * indicators: true, + * rows: [1, 2, 5] + * } + * }); + * + * // access to hiddenRows plugin instance + * const hiddenRowsPlugin = hot.getPlugin('hiddenRows'); + * + * // show single row + * hiddenRowsPlugin.showRow(1); + * + * // show multiple rows + * hiddenRowsPlugin.showRow(1, 2, 9); + * + * // or as an array + * hiddenRowsPlugin.showRows([1, 2, 9]); + * + * // hide single row + * hiddenRowsPlugin.hideRow(1); + * + * // hide multiple rows + * hiddenRowsPlugin.hideRow(1, 2, 9); + * + * // or as an array + * hiddenRowsPlugin.hideRows([1, 2, 9]); + * + * // rerender the table to see all changes + * hot.render(); + * ``` + */ + +var _settings$1 = new WeakMap(); + +var _hiddenRowsMap = new WeakMap(); + +var HiddenRows = /*#__PURE__*/function (_BasePlugin) { + _inherits$1o(HiddenRows, _BasePlugin); + + var _super = _createSuper$1o(HiddenRows); + + function HiddenRows() { + var _this; + + _classCallCheck$2P(this, HiddenRows); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _super.call.apply(_super, [this].concat(args)); + + _settings$1.set(_assertThisInitialized$1o(_this), { + writable: true, + value: {} + }); + + _hiddenRowsMap.set(_assertThisInitialized$1o(_this), { + writable: true, + value: null + }); + + return _this; + } + + _createClass$2I(HiddenRows, [{ + key: "isEnabled", + value: + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link HiddenRows#enablePlugin} method is called. + * + * @returns {boolean} + */ + function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$y]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + var pluginSettings = this.hot.getSettings()[PLUGIN_KEY$y]; + + if (isObject$1(pluginSettings)) { + _classPrivateFieldSet$6(this, _settings$1, pluginSettings); + + if (isUndefined(pluginSettings.copyPasteEnabled)) { + pluginSettings.copyPasteEnabled = true; + } + } + + _classPrivateFieldSet$6(this, _hiddenRowsMap, new HidingMap()); + + _classPrivateFieldGet$6(this, _hiddenRowsMap).addLocalHook('init', function () { + return _this2.onMapInit(); + }); + + this.hot.rowIndexMapper.registerMap(this.pluginName, _classPrivateFieldGet$6(this, _hiddenRowsMap)); + this.addHook('afterContextMenuDefaultOptions', function () { + return _this2.onAfterContextMenuDefaultOptions.apply(_this2, arguments); + }); + this.addHook('afterGetCellMeta', function (row, col, cellProperties) { + return _this2.onAfterGetCellMeta(row, col, cellProperties); + }); + this.addHook('modifyRowHeight', function (height, row) { + return _this2.onModifyRowHeight(height, row); + }); + this.addHook('afterGetRowHeader', function () { + return _this2.onAfterGetRowHeader.apply(_this2, arguments); + }); + this.addHook('modifyCopyableRange', function (ranges) { + return _this2.onModifyCopyableRange(ranges); + }); + + _get$T(_getPrototypeOf$1o(HiddenRows.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + this.disablePlugin(); + this.enablePlugin(); + + _get$T(_getPrototypeOf$1o(HiddenRows.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.hot.rowIndexMapper.unregisterMap(this.pluginName); + + _classPrivateFieldSet$6(this, _settings$1, {}); + + _get$T(_getPrototypeOf$1o(HiddenRows.prototype), "disablePlugin", this).call(this); + + this.resetCellsMeta(); + } + /** + * Shows the rows provided in the array. + * + * @param {number[]} rows Array of visual row indexes. + */ + + }, { + key: "showRows", + value: function showRows(rows) { + var _this3 = this; + + var currentHideConfig = this.getHiddenRows(); + var isValidConfig = this.isValidConfig(rows); + var destinationHideConfig = currentHideConfig; + + var hidingMapValues = _classPrivateFieldGet$6(this, _hiddenRowsMap).getValues().slice(); + + var isAnyRowShowed = rows.length > 0; + + if (isValidConfig && isAnyRowShowed) { + var physicalRows = rows.map(function (visualRow) { + return _this3.hot.toPhysicalRow(visualRow); + }); // Preparing new values for hiding map. + + arrayEach(physicalRows, function (physicalRow) { + hidingMapValues[physicalRow] = false; + }); // Preparing new hiding config. + + destinationHideConfig = arrayReduce(hidingMapValues, function (hiddenIndexes, isHidden, physicalIndex) { + if (isHidden) { + hiddenIndexes.push(_this3.hot.toVisualRow(physicalIndex)); + } + + return hiddenIndexes; + }, []); + } + + var continueHiding = this.hot.runHooks('beforeUnhideRows', currentHideConfig, destinationHideConfig, isValidConfig && isAnyRowShowed); + + if (continueHiding === false) { + return; + } + + if (isValidConfig && isAnyRowShowed) { + _classPrivateFieldGet$6(this, _hiddenRowsMap).setValues(hidingMapValues); + } + + this.hot.runHooks('afterUnhideRows', currentHideConfig, destinationHideConfig, isValidConfig && isAnyRowShowed, isValidConfig && destinationHideConfig.length < currentHideConfig.length); + } + /** + * Shows the row provided as row index (counting from 0). + * + * @param {...number} row Visual row index. + */ + + }, { + key: "showRow", + value: function showRow() { + for (var _len2 = arguments.length, row = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + row[_key2] = arguments[_key2]; + } + + this.showRows(row); + } + /** + * Hides the rows provided in the array. + * + * @param {number[]} rows Array of visual row indexes. + */ + + }, { + key: "hideRows", + value: function hideRows(rows) { + var _this4 = this; + + var currentHideConfig = this.getHiddenRows(); + var isConfigValid = this.isValidConfig(rows); + var destinationHideConfig = currentHideConfig; + + if (isConfigValid) { + destinationHideConfig = Array.from(new Set(currentHideConfig.concat(rows))); + } + + var continueHiding = this.hot.runHooks('beforeHideRows', currentHideConfig, destinationHideConfig, isConfigValid); + + if (continueHiding === false) { + return; + } + + if (isConfigValid) { + this.hot.batchExecution(function () { + arrayEach(rows, function (visualRow) { + _classPrivateFieldGet$6(_this4, _hiddenRowsMap).setValueAtIndex(_this4.hot.toPhysicalRow(visualRow), true); + }); + }, true); + } + + this.hot.runHooks('afterHideRows', currentHideConfig, destinationHideConfig, isConfigValid, isConfigValid && destinationHideConfig.length > currentHideConfig.length); + } + /** + * Hides the row provided as row index (counting from 0). + * + * @param {...number} row Visual row index. + */ + + }, { + key: "hideRow", + value: function hideRow() { + for (var _len3 = arguments.length, row = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + row[_key3] = arguments[_key3]; + } + + this.hideRows(row); + } + /** + * Returns an array of visual indexes of hidden rows. + * + * @returns {number[]} + */ + + }, { + key: "getHiddenRows", + value: function getHiddenRows() { + var _this5 = this; + + return arrayMap(_classPrivateFieldGet$6(this, _hiddenRowsMap).getHiddenIndexes(), function (physicalRowIndex) { + return _this5.hot.toVisualRow(physicalRowIndex); + }); + } + /** + * Checks if the provided row is hidden. + * + * @param {number} row Visual row index. + * @returns {boolean} + */ + + }, { + key: "isHidden", + value: function isHidden(row) { + return _classPrivateFieldGet$6(this, _hiddenRowsMap).getValueAtIndex(this.hot.toPhysicalRow(row)) || false; + } + /** + * Checks whether all of the provided row indexes are within the bounds of the table. + * + * @param {Array} hiddenRows List of hidden visual row indexes. + * @returns {boolean} + */ + + }, { + key: "isValidConfig", + value: function isValidConfig(hiddenRows) { + var nrOfRows = this.hot.countRows(); + + if (Array.isArray(hiddenRows) && hiddenRows.length > 0) { + return hiddenRows.every(function (visualRow) { + return Number.isInteger(visualRow) && visualRow >= 0 && visualRow < nrOfRows; + }); + } + + return false; + } + /** + * Resets all rendered cells meta. + * + * @private + */ + + }, { + key: "resetCellsMeta", + value: function resetCellsMeta() { + arrayEach(this.hot.getCellsMeta(), function (meta) { + if (meta) { + meta.skipRowOnPaste = false; + } + }); + } + /** + * Adds the additional row height for the hidden row indicators. + * + * @private + * @param {number|undefined} height Row height. + * @param {number} row Visual row index. + * @returns {number} + */ + + }, { + key: "onModifyRowHeight", + value: function onModifyRowHeight(height, row) { + // Hook is triggered internally only for the visible rows. Conditional will be handled for the API + // calls of the `getRowHeight` function on not visible indexes. + if (this.isHidden(row)) { + return 0; + } + + return height; + } + /** + * Sets the copy-related cell meta. + * + * @private + * @param {number} row Visual row index. + * @param {number} column Visual column index. + * @param {object} cellProperties Object containing the cell properties. + */ + + }, { + key: "onAfterGetCellMeta", + value: function onAfterGetCellMeta(row, column, cellProperties) { + if (_classPrivateFieldGet$6(this, _settings$1).copyPasteEnabled === false && this.isHidden(row)) { + // Cell property handled by the `Autofill` and the `CopyPaste` plugins. + cellProperties.skipRowOnPaste = true; + } + + if (this.isHidden(row - 1)) { + cellProperties.className = cellProperties.className || ''; + + if (cellProperties.className.indexOf('afterHiddenRow') === -1) { + cellProperties.className += ' afterHiddenRow'; + } + } else if (cellProperties.className) { + var classArr = cellProperties.className.split(' '); + + if (classArr.length > 0) { + var containAfterHiddenRow = classArr.indexOf('afterHiddenRow'); + + if (containAfterHiddenRow > -1) { + classArr.splice(containAfterHiddenRow, 1); + } + + cellProperties.className = classArr.join(' '); + } + } + } + /** + * Modifies the copyable range, accordingly to the provided config. + * + * @private + * @param {Array} ranges An array of objects defining copyable cells. + * @returns {Array} + */ + + }, { + key: "onModifyCopyableRange", + value: function onModifyCopyableRange(ranges) { + var _this6 = this; + + // Ranges shouldn't be modified when `copyPasteEnabled` option is set to `true` (by default). + if (_classPrivateFieldGet$6(this, _settings$1).copyPasteEnabled) { + return ranges; + } + + var newRanges = []; + + var pushRange = function pushRange(startRow, endRow, startCol, endCol) { + newRanges.push({ + startRow: startRow, + endRow: endRow, + startCol: startCol, + endCol: endCol + }); + }; + + arrayEach(ranges, function (range) { + var isHidden = true; + var rangeStart = 0; + rangeEach(range.startRow, range.endRow, function (visualRow) { + if (_this6.isHidden(visualRow)) { + if (!isHidden) { + pushRange(rangeStart, visualRow - 1, range.startCol, range.endCol); + } + + isHidden = true; + } else { + if (isHidden) { + rangeStart = visualRow; + } + + if (visualRow === range.endRow) { + pushRange(rangeStart, visualRow, range.startCol, range.endCol); + } + + isHidden = false; + } + }); + }); + return newRanges; + } + /** + * Adds the needed classes to the headers. + * + * @private + * @param {number} row Visual row index. + * @param {HTMLElement} TH Header's TH element. + */ + + }, { + key: "onAfterGetRowHeader", + value: function onAfterGetRowHeader(row, TH) { + if (!_classPrivateFieldGet$6(this, _settings$1).indicators || row < 0) { + return; + } + + var classList = []; + + if (row >= 1 && this.isHidden(row - 1)) { + classList.push('afterHiddenRow'); + } + + if (row < this.hot.countRows() - 1 && this.isHidden(row + 1)) { + classList.push('beforeHiddenRow'); + } + + addClass(TH, classList); + } + /** + * Add Show-hide rows to context menu. + * + * @private + * @param {object} options An array of objects containing information about the pre-defined Context Menu items. + */ + + }, { + key: "onAfterContextMenuDefaultOptions", + value: function onAfterContextMenuDefaultOptions(options) { + options.items.push({ + name: KEY + }, hideRowItem(this), showRowItem(this)); + } + /** + * On map initialized hook callback. + * + * @private + */ + + }, { + key: "onMapInit", + value: function onMapInit() { + if (Array.isArray(_classPrivateFieldGet$6(this, _settings$1).rows)) { + this.hideRows(_classPrivateFieldGet$6(this, _settings$1).rows); + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.rowIndexMapper.unregisterMap(this.pluginName); + + _classPrivateFieldSet$6(this, _settings$1, null); + + _classPrivateFieldSet$6(this, _hiddenRowsMap, null); + + _get$T(_getPrototypeOf$1o(HiddenRows.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$y; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$w; + } + /** + * Cached settings from Handsontable settings. + * + * @private + * @type {object} + */ + + }]); + + return HiddenRows; +}(BasePlugin); + +function _typeof$1C(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof$1C = function _typeof(obj) { return typeof obj; }; } else { _typeof$1C = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof$1C(obj); } + +function _classCallCheck$2Q(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties$2J(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); } } + +function _createClass$2J(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2J(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2J(Constructor, staticProps); return Constructor; } + +function _get$U(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get$U = Reflect.get; } else { _get$U = function _get(target, property, receiver) { var base = _superPropBase$U(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get$U(target, property, receiver || target); } + +function _superPropBase$U(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf$1p(object); if (object === null) break; } return object; } + +function _inherits$1p(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf$1q(subClass, superClass); } + +function _setPrototypeOf$1q(o, p) { _setPrototypeOf$1q = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf$1q(o, p); } + +function _createSuper$1p(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$1q(); return function _createSuperInternal() { var Super = _getPrototypeOf$1p(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$1p(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$1p(this, result); }; } + +function _possibleConstructorReturn$1p(self, call) { if (call && (_typeof$1C(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized$1p(self); } + +function _assertThisInitialized$1p(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct$1q() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf$1p(o) { _getPrototypeOf$1p = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf$1p(o); } +var PLUGIN_KEY$z = 'trimRows'; +var PLUGIN_PRIORITY$x = 330; +/** + * @plugin TrimRows + * + * @description + * The plugin allows to trim certain rows. The trimming is achieved by applying the transformation algorithm to the data + * transformation. In this case, when the row is trimmed it is not accessible using `getData*` methods thus the trimmed + * data is not visible to other plugins. + * + * @example + * ```js + * const container = document.getElementById('example'); + * const hot = new Handsontable(container, { + * data: getData(), + * // hide selected rows on table initialization + * trimRows: [1, 2, 5] + * }); + * + * // access the trimRows plugin instance + * const trimRowsPlugin = hot.getPlugin('trimRows'); + * + * // hide single row + * trimRowsPlugin.trimRow(1); + * + * // hide multiple rows + * trimRowsPlugin.trimRow(1, 2, 9); + * + * // or as an array + * trimRowsPlugin.trimRows([1, 2, 9]); + * + * // show single row + * trimRowsPlugin.untrimRow(1); + * + * // show multiple rows + * trimRowsPlugin.untrimRow(1, 2, 9); + * + * // or as an array + * trimRowsPlugin.untrimRows([1, 2, 9]); + * + * // rerender table to see the changes + * hot.render(); + * ``` + */ + +var TrimRows = /*#__PURE__*/function (_BasePlugin) { + _inherits$1p(TrimRows, _BasePlugin); + + var _super = _createSuper$1p(TrimRows); + + function TrimRows(hotInstance) { + var _this; + + _classCallCheck$2Q(this, TrimRows); + + _this = _super.call(this, hotInstance); + /** + * Map of skipped rows by the plugin. + * + * @private + * @type {null|TrimmingMap} + */ + + _this.trimmedRowsMap = null; + return _this; + } + /** + * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit} + * hook and if it returns `true` than the {@link AutoRowSize#enablePlugin} method is called. + * + * @returns {boolean} + */ + + + _createClass$2J(TrimRows, [{ + key: "isEnabled", + value: function isEnabled() { + return !!this.hot.getSettings()[PLUGIN_KEY$z]; + } + /** + * Enables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "enablePlugin", + value: function enablePlugin() { + var _this2 = this; + + if (this.enabled) { + return; + } + + this.trimmedRowsMap = this.hot.rowIndexMapper.registerMap('trimRows', new TrimmingMap()); + this.trimmedRowsMap.addLocalHook('init', function () { + return _this2.onMapInit(); + }); + + _get$U(_getPrototypeOf$1p(TrimRows.prototype), "enablePlugin", this).call(this); + } + /** + * Updates the plugin state. This method is executed when {@link Core#updateSettings} is invoked. + */ + + }, { + key: "updatePlugin", + value: function updatePlugin() { + var _this3 = this; + + var trimmedRows = this.hot.getSettings()[PLUGIN_KEY$z]; + + if (Array.isArray(trimmedRows)) { + this.hot.batchExecution(function () { + _this3.trimmedRowsMap.clear(); + + arrayEach(trimmedRows, function (physicalRow) { + _this3.trimmedRowsMap.setValueAtIndex(physicalRow, true); + }); + }, true); + } + + _get$U(_getPrototypeOf$1p(TrimRows.prototype), "updatePlugin", this).call(this); + } + /** + * Disables the plugin functionality for this Handsontable instance. + */ + + }, { + key: "disablePlugin", + value: function disablePlugin() { + this.hot.rowIndexMapper.unregisterMap('trimRows'); + + _get$U(_getPrototypeOf$1p(TrimRows.prototype), "disablePlugin", this).call(this); + } + /** + * Get list of trimmed rows. + * + * @returns {Array} Physical rows. + */ + + }, { + key: "getTrimmedRows", + value: function getTrimmedRows() { + return this.trimmedRowsMap.getTrimmedIndexes(); + } + /** + * Trims the rows provided in the array. + * + * @param {number[]} rows Array of physical row indexes. + * @fires Hooks#beforeTrimRow + * @fires Hooks#afterTrimRow + */ + + }, { + key: "trimRows", + value: function trimRows(rows) { + var _this4 = this; + + var currentTrimConfig = this.getTrimmedRows(); + var isValidConfig = this.isValidConfig(rows); + var destinationTrimConfig = currentTrimConfig; + + if (isValidConfig) { + destinationTrimConfig = Array.from(new Set(currentTrimConfig.concat(rows))); + } + + var allowTrimRow = this.hot.runHooks('beforeTrimRow', currentTrimConfig, destinationTrimConfig, isValidConfig); + + if (allowTrimRow === false) { + return; + } + + if (isValidConfig) { + this.hot.batchExecution(function () { + arrayEach(rows, function (physicalRow) { + _this4.trimmedRowsMap.setValueAtIndex(physicalRow, true); + }); + }, true); + } + + this.hot.runHooks('afterTrimRow', currentTrimConfig, destinationTrimConfig, isValidConfig, isValidConfig && destinationTrimConfig.length > currentTrimConfig.length); + } + /** + * Trims the row provided as physical row index (counting from 0). + * + * @param {...number} row Physical row index. + */ + + }, { + key: "trimRow", + value: function trimRow() { + for (var _len = arguments.length, row = new Array(_len), _key = 0; _key < _len; _key++) { + row[_key] = arguments[_key]; + } + + this.trimRows(row); + } + /** + * Untrims the rows provided in the array. + * + * @param {number[]} rows Array of physical row indexes. + * @fires Hooks#beforeUntrimRow + * @fires Hooks#afterUntrimRow + */ + + }, { + key: "untrimRows", + value: function untrimRows(rows) { + var currentTrimConfig = this.getTrimmedRows(); + var isValidConfig = this.isValidConfig(rows); + var destinationTrimConfig = currentTrimConfig; + var trimmingMapValues = this.trimmedRowsMap.getValues().slice(); + var isAnyRowUntrimmed = rows.length > 0; + + if (isValidConfig && isAnyRowUntrimmed) { + // Preparing new values for trimming map. + arrayEach(rows, function (physicalRow) { + trimmingMapValues[physicalRow] = false; + }); // Preparing new trimming config. + + destinationTrimConfig = arrayReduce(trimmingMapValues, function (trimmedIndexes, isTrimmed, physicalIndex) { + if (isTrimmed) { + trimmedIndexes.push(physicalIndex); + } + + return trimmedIndexes; + }, []); + } + + var allowUntrimRow = this.hot.runHooks('beforeUntrimRow', currentTrimConfig, destinationTrimConfig, isValidConfig && isAnyRowUntrimmed); + + if (allowUntrimRow === false) { + return; + } + + if (isValidConfig && isAnyRowUntrimmed) { + this.trimmedRowsMap.setValues(trimmingMapValues); + } + + this.hot.runHooks('afterUntrimRow', currentTrimConfig, destinationTrimConfig, isValidConfig && isAnyRowUntrimmed, isValidConfig && destinationTrimConfig.length < currentTrimConfig.length); + } + /** + * Untrims the row provided as row index (counting from 0). + * + * @param {...number} row Physical row index. + */ + + }, { + key: "untrimRow", + value: function untrimRow() { + for (var _len2 = arguments.length, row = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + row[_key2] = arguments[_key2]; + } + + this.untrimRows(row); + } + /** + * Checks if given row is hidden. + * + * @param {number} physicalRow Physical row index. + * @returns {boolean} + */ + + }, { + key: "isTrimmed", + value: function isTrimmed(physicalRow) { + return this.trimmedRowsMap.getValueAtIndex(physicalRow) || false; + } + /** + * Untrims all trimmed rows. + */ + + }, { + key: "untrimAll", + value: function untrimAll() { + this.untrimRows(this.getTrimmedRows()); + } + /** + * Get if trim config is valid. Check whether all of the provided row indexes are within source data. + * + * @param {Array} trimmedRows List of physical row indexes. + * @returns {boolean} + */ + + }, { + key: "isValidConfig", + value: function isValidConfig(trimmedRows) { + var sourceRows = this.hot.countSourceRows(); + return trimmedRows.every(function (trimmedRow) { + return Number.isInteger(trimmedRow) && trimmedRow >= 0 && trimmedRow < sourceRows; + }); + } + /** + * On map initialized hook callback. + * + * @private + */ + + }, { + key: "onMapInit", + value: function onMapInit() { + var _this5 = this; + + var trimmedRows = this.hot.getSettings()[PLUGIN_KEY$z]; + + if (Array.isArray(trimmedRows)) { + this.hot.batchExecution(function () { + arrayEach(trimmedRows, function (physicalRow) { + _this5.trimmedRowsMap.setValueAtIndex(physicalRow, true); + }); + }, true); + } + } + /** + * Destroys the plugin instance. + */ + + }, { + key: "destroy", + value: function destroy() { + this.hot.rowIndexMapper.unregisterMap('trimRows'); + + _get$U(_getPrototypeOf$1p(TrimRows.prototype), "destroy", this).call(this); + } + }], [{ + key: "PLUGIN_KEY", + get: function get() { + return PLUGIN_KEY$z; + } + }, { + key: "PLUGIN_PRIORITY", + get: function get() { + return PLUGIN_PRIORITY$x; + } + }]); + + return TrimRows; +}(BasePlugin); + +_register(BaseEditor); +_register(AutocompleteEditor); +_register(CheckboxEditor); +_register(DateEditor); +_register(DropdownEditor); +_register(HandsontableEditor); +_register(NumericEditor); +_register(PasswordEditor); +_register(SelectEditor); +_register(TextEditor); +_register$1(baseRenderer); +_register$1(autocompleteRenderer); +_register$1(checkboxRenderer); +_register$1(htmlRenderer); +_register$1(numericRenderer); +_register$1(passwordRenderer); +_register$1(textRenderer); +_register$2(autocompleteValidator); +_register$2(dateValidator); +_register$2(numericValidator); +_register$2(timeValidator); +_register$3(AutocompleteCellType); +_register$3(CheckboxCellType); +_register$3(DateCellType); +_register$3(DropdownCellType); +_register$3(HandsontableCellType); +_register$3(NumericCellType); +_register$3(PasswordCellType); +_register$3(TimeCellType); +_register$3(TextCellType); +jQueryWrapper(Handsontable); +registerPlugin(AutoColumnSize); +registerPlugin(Autofill); +registerPlugin(AutoRowSize); +registerPlugin(BindRowsWithHeaders); +registerPlugin(CollapsibleColumns); +registerPlugin(ColumnSorting); +registerPlugin(ColumnSummary); +registerPlugin(Comments); +registerPlugin(ContextMenu); +registerPlugin(CopyPaste); +registerPlugin(CustomBorders); +registerPlugin(DragToScroll); +registerPlugin(DropdownMenu); +registerPlugin(ExportFile); +registerPlugin(Filters); +registerPlugin(Formulas); +registerPlugin(HeaderTooltips); +registerPlugin(HiddenColumns); +registerPlugin(HiddenRows); +registerPlugin(ManualColumnFreeze); +registerPlugin(ManualColumnMove); +registerPlugin(ManualColumnResize); +registerPlugin(ManualRowMove); +registerPlugin(ManualRowResize); +registerPlugin(MergeCells); +registerPlugin(MultiColumnSorting); +registerPlugin(MultipleSelectionHandles); +registerPlugin(NestedHeaders); +registerPlugin(NestedRows); +registerPlugin(ObserveChanges); +registerPlugin(PersistentState); +registerPlugin(Search); +registerPlugin(TouchScroll); +registerPlugin(TrimRows); +registerPlugin(UndoRedo); // TODO: Remove this exports after rewrite tests about this module + +Handsontable.__GhostTable = GhostTable; +Handsontable._getListenersCounter = getListenersCounter; // For MemoryLeak tests + +Handsontable._getRegisteredMapsCounter = getRegisteredMapsCounter; // For MemoryLeak tests + +Handsontable.DefaultSettings = metaSchemaFactory(); +Handsontable.EventManager = EventManager; // Export Hooks singleton + +Handsontable.hooks = Hooks.getSingleton(); // Export all helpers to the Handsontable object + +var HELPERS = [arrayHelpers, browserHelpers, dataHelpers, dateHelpers, featureHelpers, functionHelpers, mixedHelpers, numberHelpers, objectHelpers, stringHelpers, unicodeHelpers, parseTableHelpers]; +var DOM = [domHelpers, domEventHelpers]; +Handsontable.helper = {}; +Handsontable.dom = {}; // Fill general helpers. + +arrayEach(HELPERS, function (helper) { + arrayEach(Object.getOwnPropertyNames(helper), function (key) { + if (key.charAt(0) !== '_') { + Handsontable.helper[key] = helper[key]; + } + }); +}); // Fill DOM helpers. + +arrayEach(DOM, function (helper) { + arrayEach(Object.getOwnPropertyNames(helper), function (key) { + if (key.charAt(0) !== '_') { + Handsontable.dom[key] = helper[key]; + } + }); +}); // Export cell types. + +Handsontable.cellTypes = {}; +arrayEach(getNames$3(), function (cellTypeName) { + Handsontable.cellTypes[cellTypeName] = _getItem$3(cellTypeName); +}); +Handsontable.cellTypes.registerCellType = _register$3; +Handsontable.cellTypes.getCellType = _getItem$3; // Export all registered editors from the Handsontable. + +Handsontable.editors = {}; +arrayEach(getNames(), function (editorName) { + Handsontable.editors["".concat(toUpperCaseFirst(editorName), "Editor")] = _getItem(editorName); +}); +Handsontable.editors.registerEditor = _register; +Handsontable.editors.getEditor = _getItem; // Export all registered renderers from the Handsontable. + +Handsontable.renderers = {}; +arrayEach(getNames$1(), function (rendererName) { + var renderer = _getItem$1(rendererName); + + if (rendererName === 'base') { + Handsontable.renderers.cellDecorator = renderer; + } + + Handsontable.renderers["".concat(toUpperCaseFirst(rendererName), "Renderer")] = renderer; +}); +Handsontable.renderers.registerRenderer = _register$1; +Handsontable.renderers.getRenderer = _getItem$1; // Export all registered validators from the Handsontable. + +Handsontable.validators = {}; +arrayEach(getNames$2(), function (validatorName) { + Handsontable.validators["".concat(toUpperCaseFirst(validatorName), "Validator")] = _getItem$2(validatorName); +}); +Handsontable.validators.registerValidator = _register$2; +Handsontable.validators.getValidator = _getItem$2; // Export all registered plugins from the Handsontable. +// Make sure to initialize the plugin dictionary as an empty object. Otherwise, while +// transpiling the files into ES and CommonJS format, the injected CoreJS helper +// `import "core-js/modules/es.object.get-own-property-names";` won't be processed +// by the `./config/plugin/babel/add-import-extension` babel plugin. Thus, the distribution +// files will be broken. The reason is not known right now (probably it's caused by bug in +// the Babel or missing something in the plugin). + +Handsontable.plugins = {}; +arrayEach(getPluginsNames(), function (pluginName) { + Handsontable.plugins[pluginName] = getPlugin(pluginName); +}); +Handsontable.plugins["".concat(toUpperCaseFirst(BasePlugin.PLUGIN_KEY), "Plugin")] = BasePlugin; +Handsontable.plugins.registerPlugin = registerPlugin; +Handsontable.plugins.getPlugin = getPlugin; + +class CsvPlugin extends obsidian.Plugin { + constructor() { + super(...arguments); + // function to create the view + this.csvViewCreator = (leaf) => { + return new CsvView(leaf); + }; + // this function used the regular 'document' svg, + // but adds the supplied extension into the icon as well + this.addDocumentIcon = (extension) => { + obsidian.addIcon(`document-${extension}`, ` + + + ${extension} + + `); + }; + } + onload() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = (yield this.loadData()) || {}; + // register a custom icon + this.addDocumentIcon("csv"); + // register the view and extensions + this.registerView("csv", this.csvViewCreator); + this.registerExtensions(["csv"], "csv"); + }); + } +} +class ExtHandsontable extends Handsontable { + constructor(element, options, context) { + super(element, options); + this.extContext = context; + } +} +// This is the custom view +class CsvView extends obsidian.TextFileView { + // constructor + constructor(leaf) { + super(leaf); + this.headers = null; + this.hotChange = (changes, source) => { + if (source === 'loadData') { + return; //don't save this change + } + this.requestSave(); + }; + this.hotSort = (currentSortConfig, destinationSortConfigs) => { + this.requestSave(); + }; + this.hotColumnMove = (movedColumns, finalIndex, dropIndex, movePossible, orderChanged) => { + this.requestSave(); + }; + this.hotRowMove = (movedRows, finalIndex, dropIndex, movePossible, orderChanged) => { + this.requestSave(); + }; + this.hotCreateCol = (index, amount, source) => { + this.requestSave(); + }; + this.hotCreateRow = (index, amount, source) => { + this.requestSave(); + }; + this.hotRemoveCol = (index, amount, physicalColumns, source) => { + this.requestSave(); + }; + this.hotRemoveRow = (index, amount, physicalRows, source) => { + this.requestSave(); + }; + this.toggleHeaders = (value) => { + value = value || false; // just in case it's undefined + // turning headers on + if (value) { + // we haven't specified headers yet + if (this.hotSettings.colHeaders === true) { + // get the data + let data = this.hot.getSourceDataArray(); + // take the first row off the data to use as headers + this.hotSettings.colHeaders = data.shift(); + // reload the data without this first row + this.hot.loadData(data); + // update the settings + this.hot.updateSettings(this.hotSettings); + } + } + // turning headers off + else { + // we have headers + if (this.hotSettings.colHeaders !== true) { + // get the data + let data = this.hot.getSourceDataArray(); + // put the headings back in as a row + data.unshift(this.hot.getColHeader()); + // specify true to just display alphabetical headers + this.hotSettings.colHeaders = true; + // reload the data with this new first row + this.hot.loadData(data); + // update the settings + this.hot.updateSettings(this.hotSettings); + } + } + // set this value to the state + this.hotState.saveValue('hasHeadings', value); + }; + // get the new file contents + this.getViewData = () => { + // get the *source* data (i.e. unfiltered) + let data = this.hot.getSourceDataArray(); + if (this.hotSettings.colHeaders !== true) { + data.unshift(this.hot.getColHeader()); + } + let csvString = papaparse_min.unparse(data); + return csvString; + // return Papa.unparse({fields: this.parseResult.fields, data: this.parseResult.data}, {header: false}); + // return Papa.unparse(this.parseResult); + }; + // set the file contents + this.setViewData = (data, clear) => { + this.loadingBar.show(); + setTimeout(() => this.loadDataAsync(data).then(() => this.loadingBar.hide()), 50); + }; + this.loadDataAsync = (data) => __awaiter(this, void 0, void 0, function* () { + return new Promise((resolve, reject) => { + // for the sake of persistent settings we need to set the root element id + this.hot.rootElement.id = this.file.path; + this.hotSettings.colHeaders = true; + // strip Byte Order Mark if necessary (damn you, Excel) + if (data.charCodeAt(0) === 0xFEFF) + data = data.slice(1); + // parse the incoming data string + papaparse_min.parse(data, { + header: false, + complete: results => { + this.parseResult = results; + // load the data into the table + this.hot.loadData(this.parseResult.data); + // we also need to update the settings so that the persistence will work + this.hot.updateSettings(this.hotSettings); + // load the persistent setting for headings + let hasHeadings = { value: false }; + this.hotState.loadValue('hasHeadings', hasHeadings); + this.headerToggle.setValue(hasHeadings.value); + // toggle the headers on or off based on the loaded value + this.toggleHeaders(hasHeadings.value); + resolve(); + } + }); + }); + }); + this.markdownCellRenderer = (instance, TD, row, col, prop, value, cellProperties) => { + TD.innerHTML = ''; + obsidian.MarkdownRenderer.renderMarkdown(value, TD, this.file.path || '', this || null); + return TD; + }; + // clear the view content + this.clear = () => { + }; + this.onResize = () => { + //@ts-ignore + this.hot.view.wt.wtOverlays.updateMainScrollableElements(); + this.hot.render(); + }; + this.loadingBar = document.createElement('div'); + this.loadingBar.addClass("progress-bar"); + this.loadingBar.innerHTML = `
Loading CSV...
`; + this.extContentEl.appendChild(this.loadingBar); + this.fileOptionsEl = document.createElement('div'); + this.fileOptionsEl.classList.add('csv-controls'); + this.extContentEl.appendChild(this.fileOptionsEl); + new obsidian.Setting(this.fileOptionsEl) + .setName('File Includes Headers') + .addToggle(toggle => { + this.headerToggle = toggle; + toggle.setValue(false).onChange(this.toggleHeaders); + }); + const tableContainer = document.createElement('div'); + tableContainer.classList.add('csv-table-wrapper'); + this.extContentEl.appendChild(tableContainer); + const hotContainer = document.createElement('div'); + tableContainer.appendChild(hotContainer); + Handsontable.renderers.registerRenderer('markdown', this.markdownCellRenderer); + Handsontable.editors.registerEditor('markdown', MarkdownCellEditor); + this.hotSettings = { + afterChange: this.hotChange, + afterColumnSort: this.hotSort, + afterColumnMove: this.hotColumnMove, + afterRowMove: this.hotRowMove, + afterCreateCol: this.hotCreateCol, + afterCreateRow: this.hotCreateRow, + afterRemoveCol: this.hotRemoveCol, + afterRemoveRow: this.hotRemoveRow, + licenseKey: 'non-commercial-and-evaluation', + colHeaders: true, + rowHeaders: true, + autoColumnSize: true, + autoRowSize: true, + renderer: 'markdown', + editor: 'markdown', + className: 'csv-table', + contextMenu: true, + currentRowClassName: 'active-row', + currentColClassName: 'active-col', + columnSorting: true, + dropdownMenu: true, + filters: true, + manualColumnFreeze: true, + manualColumnMove: false, + manualColumnResize: true, + manualRowMove: false, + manualRowResize: true, + persistentState: true, + // preventOverflow: true, + search: true, + height: '100%', + width: '100%', + }; + this.hot = new ExtHandsontable(hotContainer, this.hotSettings, { leaf: this.leaf }); + this.hotExport = this.hot.getPlugin('exportFile'); + this.hotState = this.hot.getPlugin('persistentState'); + this.hotFilters = this.hot.getPlugin('filters'); + } + // this.contentEl is not exposed, so cheat a bit. + get extContentEl() { + // @ts-ignore + return this.contentEl; + } + // gets the title of the document + getDisplayText() { + if (this.file) + return this.file.basename; + else + return "csv (no file)"; + } + // confirms this view can accept csv extension + canAcceptExtension(extension) { + return extension == 'csv'; + } + // the view type name + getViewType() { + return "csv"; + } + // icon for the view + getIcon() { + return "document-csv"; + } +} +class MarkdownCellEditor extends Handsontable.editors.BaseEditor { + init() { + const extContext = this.hot.extContext; + if (extContext && extContext.leaf && !this.eGui) { + // create the container + this.eGui = this.hot.rootDocument.createElement('DIV'); + Handsontable.dom.addClass(this.eGui, 'htMarkdownEditor'); + Handsontable.dom.addClass(this.eGui, 'csv-cell-edit'); + // create a markdown (editor) view + this.view = new obsidian.MarkdownView(extContext.leaf); + this.view.currentMode = this.view.sourceMode; + // @ts-ignore add the editor element to the container + this.eGui.appendChild(this.view.sourceMode.editorEl); + // hide the container + this.eGui.style.display = 'none'; + // add the container to the table root element + this.hot.rootElement.appendChild(this.eGui); + } + } + open(event) { + this.refreshDimensions(); + this.eGui.show(); + this.view.sourceMode.cmEditor.focus(); + this.view.sourceMode.cmEditor.refresh(); + } + refreshDimensions() { + this.TD = this.getEditedCell(); + // TD is outside of the viewport. + if (!this.TD) { + this.close(); + return; + } + //@ts-ignore + const { wtOverlays } = this.hot.view.wt; + const currentOffset = Handsontable.dom.offset(this.TD); + const containerOffset = Handsontable.dom.offset(this.hot.rootElement); + const scrollableContainer = wtOverlays.scrollableElement; + const editorSection = this.checkEditorSection(); + let width = Handsontable.dom.outerWidth(this.TD) + 1; + let height = Handsontable.dom.outerHeight(this.TD) + 1; + //@ts-ignore + let editTop = currentOffset.top - containerOffset.top - 1 - (scrollableContainer.scrollTop || 0); + //@ts-ignore + let editLeft = currentOffset.left - containerOffset.left - 1 - (scrollableContainer.scrollLeft || 0); + let cssTransformOffset; + switch (editorSection) { + case 'top': + cssTransformOffset = Handsontable.dom.getCssTransform(wtOverlays.topOverlay.clone.wtTable.holder.parentNode); + break; + case 'left': + cssTransformOffset = Handsontable.dom.getCssTransform(wtOverlays.leftOverlay.clone.wtTable.holder.parentNode); + break; + case 'top-left-corner': + cssTransformOffset = Handsontable.dom.getCssTransform(wtOverlays.topLeftCornerOverlay.clone.wtTable.holder.parentNode); + break; + case 'bottom-left-corner': + cssTransformOffset = Handsontable.dom.getCssTransform(wtOverlays.bottomLeftCornerOverlay.clone.wtTable.holder.parentNode); + break; + case 'bottom': + cssTransformOffset = Handsontable.dom.getCssTransform(wtOverlays.bottomOverlay.clone.wtTable.holder.parentNode); + break; + } + if (this.hot.getSelectedLast()[0] === 0) { + editTop += 1; + } + if (this.hot.getSelectedLast()[1] === 0) { + editLeft += 1; + } + const selectStyle = this.eGui.style; + if (cssTransformOffset && cssTransformOffset !== -1) { + //@ts-ignore + selectStyle[cssTransformOffset[0]] = cssTransformOffset[1]; + } + else { + Handsontable.dom.resetCssTransform(this.eGui); + } + const cellComputedStyle = Handsontable.dom.getComputedStyle(this.TD, this.hot.rootWindow); + //@ts-ignore + if (parseInt(cellComputedStyle.borderTopWidth, 10) > 0) { + height -= 1; + } + //@ts-ignore + if (parseInt(cellComputedStyle.borderLeftWidth, 10) > 0) { + width -= 1; + } + selectStyle.height = `${height}px`; + selectStyle.minWidth = `${width}px`; + selectStyle.maxWidth = `${width}px`; + selectStyle.top = `${editTop}px`; + selectStyle.left = `${editLeft}px`; + selectStyle.margin = '0px'; + } + getEditedCell() { + //@ts-ignore + const { wtOverlays } = this.hot.view.wt; + const editorSection = this.checkEditorSection(); + let editedCell; + switch (editorSection) { + case 'top': + editedCell = wtOverlays.topOverlay.clone.wtTable.getCell({ + row: this.row, + col: this.col + }); + this.eGui.style.zIndex = '101'; + break; + case 'top-left-corner': + case 'bottom-left-corner': + editedCell = wtOverlays.topLeftCornerOverlay.clone.wtTable.getCell({ + row: this.row, + col: this.col + }); + this.eGui.style.zIndex = '103'; + break; + case 'left': + editedCell = wtOverlays.leftOverlay.clone.wtTable.getCell({ + row: this.row, + col: this.col + }); + this.eGui.style.zIndex = '102'; + break; + default: + editedCell = this.hot.getCell(this.row, this.col); + this.eGui.style.zIndex = ''; + break; + } + return editedCell < 0 ? void 0 : editedCell; + } + close() { + this.eGui.hide(); + } + focus() { + this.view.sourceMode.cmEditor.focus(); + this.view.sourceMode.cmEditor.refresh(); + } + getValue() { + return this.view.sourceMode.get(); + } + setValue(newValue) { + this.view.sourceMode.set(newValue, true); + } +} + +module.exports = CsvPlugin; + + +/* nosourcemap */ \ No newline at end of file diff --git a/fforte_data/.obsidian/plugins/csv-obsidian/manifest.json b/fforte_data/.obsidian/plugins/csv-obsidian/manifest.json new file mode 100644 index 0000000..e355b94 --- /dev/null +++ b/fforte_data/.obsidian/plugins/csv-obsidian/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "csv-obsidian", + "name": "CSV Editor", + "author": "death_au", + "authorUrl": "https://github.com/deathau", + "description": "Edit CSV files in Obsidian", + "isDesktopOnly": false, + "version": "0.0.1", + "minAppVersion": "0.10.11" +} \ No newline at end of file diff --git a/fforte_data/.obsidian/plugins/csv-obsidian/styles.css b/fforte_data/.obsidian/plugins/csv-obsidian/styles.css new file mode 100644 index 0000000..31f6d8e --- /dev/null +++ b/fforte_data/.obsidian/plugins/csv-obsidian/styles.css @@ -0,0 +1,1999 @@ +@charset "UTF-8"; +.workspace-leaf-content[data-type=csv] .view-content { + padding: 0; + display: flex; + flex-direction: column; +} +.workspace-leaf-content[data-type=csv] .view-content .progress-bar { + z-index: 500; + padding: 40px; +} +.workspace-leaf-content[data-type=csv] .view-content .htMarkdownEditor { + position: absolute; + width: auto; + background: var(--background-primary); +} +.workspace-leaf-content[data-type=csv] .view-content .htMarkdownEditor .markdown-source-view { + padding: 0; +} +.workspace-leaf-content[data-type=csv] .view-content .htMarkdownEditor .markdown-source-view .CodeMirror-scroll { + padding: 0; + margin: 0; + padding-bottom: 8px; +} +.workspace-leaf-content[data-type=csv] .view-content .htMarkdownEditor .markdown-source-view .CodeMirror-sizer { + padding: 0 !important; + margin: 0 !important; + border: none; +} +.workspace-leaf-content[data-type=csv] .view-content .htMarkdownEditor .markdown-source-view .CodeMirror-lines { + padding: 0; +} +.workspace-leaf-content[data-type=csv] .view-content .htMarkdownEditor .markdown-source-view .CodeMirror-code { + padding: 0; +} +.workspace-leaf-content[data-type=csv] .view-content .csv-controls { + margin: 20px 8px 8px 8px; + padding: 8px; + background-color: var(--background-primary-alt); + min-width: 140px; + max-width: 240px; + border: 1px solid var(--background-modifier-border); + border-radius: 6px; + flex-grow: 0; + overflow: hidden; +} +.workspace-leaf-content[data-type=csv] .view-content .csv-table-wrapper { + position: relative; + flex-grow: 1; + width: 100%; +} +.workspace-leaf-content[data-type=csv] .view-content td > p:first-child { + margin-top: 0; +} +.workspace-leaf-content[data-type=csv] .view-content td > p:last-child { + margin-bottom: 0; +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table tbody tr { + background-color: var(--background-primary); +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table tbody tr:nth-child(2n) { + background-color: var(--background-primary-alt); +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table thead tr, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table tbody th { + background-color: var(--background-secondary); +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table tbody th.ht__highlight, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table thead th.ht__highlight { + background-color: var(--background-secondary-alt); +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table tbody th.ht__active_highlight, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table thead th.ht__active_highlight { + background-color: var(--interactive-accent); + color: var(--text-on-accent); +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table span.colHeader.columnSorting.descending::before { + background-image: none; + font-size: 0.75em; + content: "↓"; +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table span.colHeader.columnSorting.ascending::before { + background-image: none; + font-size: 0.75em; + content: "↑"; +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table th, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td { + background-color: transparent; + border-color: var(--background-modifier-border); + color: var(--text-normal); +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table.htRowHeaders thead tr th:nth-child(2), +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table tr:first-child th, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table tr:first-child td, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table th:first-child, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table th:nth-child(2), +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td:first-of-type { + border-color: var(--background-modifier-border); +} +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table .wtBorder, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td.area:before, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td.area-1:before, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td.area-2:before, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td.area-3:before, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td.area-4:before, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td.area-5:before, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td.area-6:before, +.workspace-leaf-content[data-type=csv] .view-content .handsontable.csv-table td.area-7:before { + background-color: var(--interactive-accent) !important; +} + +.htMenu.handsontable .ht_master table td.htCustomMenuRenderer, +.htMenu.handsontable tbody tr { + background-color: var(--background-primary); +} +.htMenu.handsontable th, +.htMenu.handsontable td, +.htMenu.handsontable table tbody tr td { + background-color: transparent; + border-color: var(--background-modifier-border); + color: var(--text-normal); +} +.htMenu.handsontable table tbody tr td.htDisabled { + color: var(--text-faint); +} +.htMenu.handsontable table tbody tr td.htSeparator, +.htMenu.handsontable .ht_master table.htCore { + border-color: var(--background-modifier-border); +} + +/*! + * Copyright (c) HANDSONCODE sp. z o. o. + * + * HANDSONTABLE is a software distributed by HANDSONCODE sp. z o. o., + * a Polish corporation, based in Gdynia, Poland, at 96/98 Aleja Zwycięstwa, + * registered with the National Court Register under number 538651, + * EU tax ID number: PL5862294002, share capital: PLN 62,800.00. + * + * This software is protected by applicable copyright laws, including + * international treaties, and dual-licensed – depending on whether + * your use is intended for or may result in commercial advantage + * or monetary compensation (commercial purposes), or not. + * + * If your use involves only such purposes as research, private study, + * evaluation and the like, you agree to be bound by the terms included + * in the "handsontable-non-commercial-license.pdf" file, available + * in the main directory of this software repository. + * + * By installing, copying, or otherwise using this software for + * commercial purposes, you agree to be bound by the terms included + * in the "handsontable-general-terms.pdf" file, available in the main + * directory of this software repository. + * + * HANDSONCODE PROVIDES THIS SOFTWARE ON AN "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND. IN NO EVENT + * AND UNDER NO LEGAL THEORY, SHALL HANDSONCODE BE LIABLE + * TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, + * INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING + * FROM USE OR INABILITY TO USE THIS SOFTWARE. + * + * Version: 8.3.1 + * Release date: 10/02/2021 (built at 09/02/2021 09:16:11) + */ +.handsontable .table td, .handsontable .table th { + border-top: none; +} + +.handsontable tr { + background: #fff; +} + +.handsontable td { + background-color: inherit; +} + +.handsontable .table caption + thead tr:first-child td, .handsontable .table caption + thead tr:first-child th, .handsontable .table colgroup + thead tr:first-child td, .handsontable .table colgroup + thead tr:first-child th, .handsontable .table thead:first-child tr:first-child td, .handsontable .table thead:first-child tr:first-child th { + border-top: 1px solid #ccc; +} + +.handsontable .table-bordered { + border: 0; + border-collapse: separate; +} + +.handsontable .table-bordered td, .handsontable .table-bordered th { + border-left: none; +} + +.handsontable .table-bordered td:first-child, .handsontable .table-bordered th:first-child { + border-left: 1px solid #ccc; +} + +.handsontable .table > tbody > tr > td, .handsontable .table > tbody > tr > th, .handsontable .table > tfoot > tr > td, .handsontable .table > tfoot > tr > th, .handsontable .table > thead > tr > td, .handsontable .table > thead > tr > th { + line-height: 21px; + padding: 0 4px; +} + +.col-lg-1.handsontable, .col-lg-2.handsontable, .col-lg-3.handsontable, .col-lg-4.handsontable, .col-lg-5.handsontable, .col-lg-6.handsontable, .col-lg-7.handsontable, .col-lg-8.handsontable, .col-lg-9.handsontable, .col-lg-10.handsontable, .col-lg-11.handsontable, .col-lg-12.handsontable, .col-md-1.handsontable, .col-md-2.handsontable, .col-md-3.handsontable, .col-md-4.handsontable, .col-md-5.handsontable, .col-md-6.handsontable, .col-md-7.handsontable, .col-md-8.handsontable, .col-md-9.handsontable .col-sm-1.handsontable, .col-md-10.handsontable, .col-md-11.handsontable, .col-md-12.handsontable, .col-sm-2.handsontable, .col-sm-3.handsontable, .col-sm-4.handsontable, .col-sm-5.handsontable, .col-sm-6.handsontable, .col-sm-7.handsontable, .col-sm-8.handsontable, .col-sm-9.handsontable .col-xs-1.handsontable, .col-sm-10.handsontable, .col-sm-11.handsontable, .col-sm-12.handsontable, .col-xs-2.handsontable, .col-xs-3.handsontable, .col-xs-4.handsontable, .col-xs-5.handsontable, .col-xs-6.handsontable, .col-xs-7.handsontable, .col-xs-8.handsontable, .col-xs-9.handsontable, .col-xs-10.handsontable, .col-xs-11.handsontable, .col-xs-12.handsontable { + padding-left: 0; + padding-right: 0; +} + +.handsontable .table-striped > tbody > tr:nth-of-type(2n) { + background-color: #fff; +} + +.handsontable { + position: relative; +} + +.handsontable .hide { + display: none; +} + +.handsontable .relative { + position: relative; +} + +.handsontable .wtHider { + width: 0; +} + +.handsontable .wtSpreader { + position: relative; + width: 0; + height: auto; +} + +.handsontable div, .handsontable input, .handsontable table, .handsontable tbody, .handsontable td, .handsontable textarea, .handsontable th, .handsontable thead { + box-sizing: content-box; + -webkit-box-sizing: content-box; + -moz-box-sizing: content-box; +} + +.handsontable input, .handsontable textarea { + min-height: 0; +} + +.handsontable table.htCore { + border-collapse: separate; + border-spacing: 0; + margin: 0; + border-width: 0; + table-layout: fixed; + width: 0; + outline-width: 0; + cursor: default; + max-width: none; + max-height: none; +} + +.handsontable col, .handsontable col.rowHeader { + width: 50px; +} + +.handsontable td, .handsontable th { + border-top-width: 0; + border-left-width: 0; + height: 22px; + empty-cells: show; + line-height: 21px; + padding: 0 4px; + background-color: #fff; + vertical-align: top; + overflow: hidden; + outline-width: 0; + white-space: pre-line; +} + +.handsontable td, .handsontable th, .handsontable th:last-child { + border-right: 1px solid #ccc; + border-bottom: 1px solid #ccc; +} + +.handsontable.htRowHeaders thead tr th:nth-child(2), .handsontable td:first-of-type, .handsontable th:first-child, .handsontable th:nth-child(2) { + border-left: 1px solid #ccc; +} + +.handsontable tr:first-child td, .handsontable tr:first-child th { + border-top: 1px solid #ccc; +} + +.ht_master:not(.innerBorderLeft):not(.emptyColumns) ~ .handsontable:not(.ht_clone_top) thead tr th:first-child, .ht_master:not(.innerBorderLeft):not(.emptyColumns) ~ .handsontable tbody tr th { + border-right-width: 0; +} + +.ht_master:not(.innerBorderTop):not(.innerBorderBottom) thead tr.lastChild th, .ht_master:not(.innerBorderTop):not(.innerBorderBottom) thead tr:last-child th, .ht_master:not(.innerBorderTop):not(.innerBorderBottom) ~ .handsontable thead tr.lastChild th, .ht_master:not(.innerBorderTop):not(.innerBorderBottom) ~ .handsontable thead tr:last-child th { + border-bottom-width: 0; +} + +.handsontable th { + background-color: #f0f0f0; + color: #222; + text-align: center; + font-weight: 400; + white-space: nowrap; +} + +.handsontable thead th { + padding: 0; +} + +.handsontable th.active { + background-color: #ccc; +} + +.handsontable thead th .relative { + padding: 2px 4px; +} + +.handsontable span.colHeader { + display: inline-block; + line-height: 1.1; +} + +.handsontable .wtBorder { + position: absolute; + font-size: 0; +} + +.handsontable .wtBorder.hidden { + display: none !important; +} + +.handsontable .wtBorder.current { + z-index: 10; +} + +.handsontable .wtBorder.area { + z-index: 8; +} + +.handsontable .wtBorder.fill { + z-index: 6; +} + +.handsontable .wtBorder.corner { + font-size: 0; + cursor: crosshair; +} + +.ht_clone_master { + z-index: 100; +} + +.ht_clone_right { + z-index: 110; +} + +.ht_clone_left { + z-index: 120; +} + +.ht_clone_bottom { + z-index: 130; +} + +.ht_clone_bottom_right_corner { + z-index: 140; +} + +.ht_clone_bottom_left_corner { + z-index: 150; +} + +.ht_clone_top { + z-index: 160; +} + +.ht_clone_top_right_corner { + z-index: 170; +} + +.ht_clone_top_left_corner { + z-index: 180; +} + +.handsontable tbody tr th:nth-last-child(2), .ht_clone_top_left_corner thead tr th:nth-last-child(2) { + border-right: 1px solid #ccc; +} + +.handsontable col.hidden { + width: 0 !important; +} + +.handsontable tr.hidden, .handsontable tr.hidden td, .handsontable tr.hidden th { + display: none; +} + +.ht_clone_bottom, .ht_clone_left, .ht_clone_top, .ht_master { + overflow: hidden; +} + +.ht_master .wtHolder { + overflow: auto; +} + +.handsontable .ht_clone_left thead, .handsontable .ht_master thead, .handsontable .ht_master tr th { + visibility: hidden; +} + +.ht_clone_bottom .wtHolder, .ht_clone_left .wtHolder, .ht_clone_top .wtHolder { + overflow: hidden; +} + +.handsontable.htAutoSize { + visibility: hidden; + left: -99000px; + position: absolute; + top: -99000px; +} + +.handsontable td.htInvalid { + background-color: #ff4c42 !important; +} + +.handsontable td.htNoWrap { + white-space: nowrap; +} + +#hot-display-license-info { + font-size: 10px; + color: #323232; + padding: 5px 0 3px; + font-family: Helvetica, Arial, sans-serif; + text-align: left; +} + +#hot-display-license-info a { + font-size: 10px; +} + +.handsontable .manualColumnResizer { + position: absolute; + top: 0; + cursor: col-resize; + z-index: 210; + width: 5px; + height: 25px; +} + +.handsontable .manualRowResizer { + position: absolute; + left: 0; + cursor: row-resize; + z-index: 210; + height: 5px; + width: 50px; +} + +.handsontable .manualColumnResizer.active, .handsontable .manualColumnResizer:hover, .handsontable .manualRowResizer.active, .handsontable .manualRowResizer:hover { + background-color: #34a9db; +} + +.handsontable .manualColumnResizerGuide { + position: absolute; + right: 0; + top: 0; + background-color: #34a9db; + display: none; + width: 0; + border-right: 1px dashed #777; + margin-left: 5px; +} + +.handsontable .manualRowResizerGuide { + position: absolute; + left: 0; + bottom: 0; + background-color: #34a9db; + display: none; + height: 0; + border-bottom: 1px dashed #777; + margin-top: 5px; +} + +.handsontable .manualColumnResizerGuide.active, .handsontable .manualRowResizerGuide.active { + display: block; + z-index: 209; +} + +.handsontable .columnSorting { + position: relative; +} + +.handsontable .columnSorting.sortAction:hover { + text-decoration: underline; + cursor: pointer; +} + +.handsontable span.colHeader.columnSorting:before { + top: 50%; + margin-top: -6px; + padding-left: 8px; + position: absolute; + right: -9px; + content: ""; + height: 10px; + width: 5px; + background-size: contain; + background-repeat: no-repeat; + background-position-x: right; +} + +.handsontable span.colHeader.columnSorting.ascending:before { + background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAoCAMAAADJ7yrpAAAAKlBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKE86IAAAADXRSTlMABBEmRGprlJW72e77tTkTKwAAAFNJREFUeAHtzjkSgCAUBNHPgsoy97+ulGXRqJE5L+xkxoYt2UdsLb5bqFINz+aLuuLn5rIu2RkO3fZpWENimNgiw6iBYRTPMLJjGFxQZ1hxxb/xBI1qC8k39CdKAAAAAElFTkSuQmCC"); +} + +.handsontable span.colHeader.columnSorting.descending:before { + background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAoCAMAAADJ7yrpAAAAKlBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKE86IAAAADXRSTlMABBEmRGprlJW72e77tTkTKwAAAFJJREFUeAHtzjkSgCAQRNFmQYUZ7n9dKUvru0TmvPAn3br0QfgdZ5xx6x+rQn23GqTYnq1FDcnuzZIO2WmedVqIRVxgGKEyjNgYRjKGkZ1hFIZ3I70LyM0VtU8AAAAASUVORK5CYII="); +} + +.htGhostTable .htCore span.colHeader.columnSorting:not(.indicatorDisabled):after { + content: "*"; + display: inline-block; + position: relative; + padding-right: 20px; +} + +.handsontable td.area, .handsontable td.area-1, .handsontable td.area-2, .handsontable td.area-3, .handsontable td.area-4, .handsontable td.area-5, .handsontable td.area-6, .handsontable td.area-7 { + position: relative; +} + +.handsontable td.area-1:before, .handsontable td.area-2:before, .handsontable td.area-3:before, .handsontable td.area-4:before, .handsontable td.area-5:before, .handsontable td.area-6:before, .handsontable td.area-7:before, .handsontable td.area:before { + content: ""; + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; + bottom: -100% \9 ; + background: #005eff; +} + +@media (-ms-high-contrast: none), screen and (-ms-high-contrast: active) { + .handsontable td.area-1:before, .handsontable td.area-2:before, .handsontable td.area-3:before, .handsontable td.area-4:before, .handsontable td.area-5:before, .handsontable td.area-6:before, .handsontable td.area-7:before, .handsontable td.area:before { + bottom: -100%; + } +} +.handsontable td.area:before { + opacity: 0.1; +} + +.handsontable td.area-1:before { + opacity: 0.2; +} + +.handsontable td.area-2:before { + opacity: 0.27; +} + +.handsontable td.area-3:before { + opacity: 0.35; +} + +.handsontable td.area-4:before { + opacity: 0.41; +} + +.handsontable td.area-5:before { + opacity: 0.47; +} + +.handsontable td.area-6:before { + opacity: 0.54; +} + +.handsontable td.area-7:before { + opacity: 0.58; +} + +.handsontable tbody th.ht__highlight, .handsontable thead th.ht__highlight { + background-color: #dcdcdc; +} + +.handsontable tbody th.ht__active_highlight, .handsontable thead th.ht__active_highlight { + background-color: #8eb0e7; + color: #000; +} + +.handsontableInput { + border: none; + outline-width: 0; + margin: 0; + padding: 1px 5px 0; + font-family: inherit; + line-height: 21px; + font-size: inherit; + box-shadow: inset 0 0 0 2px #5292f7; + resize: none; + display: block; + color: #000; + border-radius: 0; + background-color: #fff; +} + +.handsontableInput:focus { + outline: none; +} + +.handsontableInputHolder { + position: absolute; + top: 0; + left: 0; +} + +.htSelectEditor { + -webkit-appearance: menulist-button !important; + position: absolute; + width: auto; +} + +.htSelectEditor:focus { + outline: none; +} + +.handsontable .htDimmed { + color: #777; +} + +.handsontable .htSubmenu { + position: relative; +} + +.handsontable .htSubmenu :after { + content: "â–¶"; + color: #777; + position: absolute; + right: 5px; + font-size: 9px; +} + +.handsontable .htLeft { + text-align: left; +} + +.handsontable .htCenter { + text-align: center; +} + +.handsontable .htRight { + text-align: right; +} + +.handsontable .htJustify { + text-align: justify; +} + +.handsontable .htTop { + vertical-align: top; +} + +.handsontable .htMiddle { + vertical-align: middle; +} + +.handsontable .htBottom { + vertical-align: bottom; +} + +.handsontable .htPlaceholder { + color: #999; +} + +.handsontable.listbox { + margin: 0; +} + +.handsontable.listbox .ht_master table { + border: 1px solid #ccc; + border-collapse: separate; + background: #fff; +} + +.handsontable.listbox td, .handsontable.listbox th, .handsontable.listbox tr:first-child td, .handsontable.listbox tr:first-child th, .handsontable.listbox tr:last-child th { + border-color: transparent; +} + +.handsontable.listbox td, .handsontable.listbox th { + white-space: nowrap; + text-overflow: ellipsis; +} + +.handsontable.listbox td.htDimmed { + cursor: default; + color: inherit; + font-style: inherit; +} + +.handsontable.listbox .wtBorder { + visibility: hidden; +} + +.handsontable.listbox tr:hover td, .handsontable.listbox tr td.current { + background: #eee; +} + +.ht_editor_hidden { + z-index: -1; +} + +.ht_editor_visible { + z-index: 200; +} + +.handsontable td.htSearchResult { + background: #fcedd9; + color: #583707; +} + +.collapsibleIndicator { + position: absolute; + top: 50%; + transform: translateY(-50%); + right: 5px; + border: 1px solid #a6a6a6; + line-height: 10px; + color: #222; + border-radius: 10px; + font-size: 10px; + width: 10px; + height: 10px; + cursor: pointer; + -webkit-box-shadow: 0 0 0 6px #eee; + -moz-box-shadow: 0 0 0 6px #eee; + box-shadow: 0 0 0 6px #eee; + background: #eee; +} + +.handsontable.mobile, .handsontable.mobile .wtHolder { + -webkit-touch-callout: none; + -webkit-user-select: none; + -khtml-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + -webkit-tap-highlight-color: rgba(0, 0, 0, 0); + -webkit-overflow-scrolling: touch; +} + +.htMobileEditorContainer { + display: none; + position: absolute; + top: 0; + width: 70%; + height: 54pt; + background: #f8f8f8; + border-radius: 20px; + border: 1px solid #ebebeb; + z-index: 999; + box-sizing: border-box; + -webkit-box-sizing: border-box; + -webkit-text-size-adjust: none; +} + +.topLeftSelectionHandle-HitArea:not(.ht_master .topLeftSelectionHandle-HitArea), .topLeftSelectionHandle:not(.ht_master .topLeftSelectionHandle) { + z-index: 9999; +} + +.bottomRightSelectionHandle, .bottomRightSelectionHandle-HitArea, .topLeftSelectionHandle, .topLeftSelectionHandle-HitArea { + left: -10000px; + top: -10000px; +} + +.htMobileEditorContainer.active { + display: block; +} + +.htMobileEditorContainer .inputs { + position: absolute; + right: 210pt; + bottom: 10pt; + top: 10pt; + left: 14px; + height: 34pt; +} + +.htMobileEditorContainer .inputs textarea { + font-size: 13pt; + border: 1px solid #a1a1a1; + -webkit-appearance: none; + -webkit-box-shadow: none; + -moz-box-shadow: none; + box-shadow: none; + position: absolute; + left: 14px; + right: 14px; + top: 0; + bottom: 0; + padding: 7pt; +} + +.htMobileEditorContainer .cellPointer { + position: absolute; + top: -13pt; + height: 0; + width: 0; + left: 30px; + border-left: 13pt solid transparent; + border-right: 13pt solid transparent; + border-bottom: 13pt solid #ebebeb; +} + +.htMobileEditorContainer .cellPointer.hidden { + display: none; +} + +.htMobileEditorContainer .cellPointer:before { + content: ""; + display: block; + position: absolute; + top: 2px; + height: 0; + width: 0; + left: -13pt; + border-left: 13pt solid transparent; + border-right: 13pt solid transparent; + border-bottom: 13pt solid #f8f8f8; +} + +.htMobileEditorContainer .moveHandle { + position: absolute; + top: 10pt; + left: 5px; + width: 30px; + bottom: 0; + cursor: move; + z-index: 9999; +} + +.htMobileEditorContainer .moveHandle:after { + content: "..\a..\a..\a.."; + white-space: pre; + line-height: 10px; + font-size: 20pt; + display: inline-block; + margin-top: -8px; + color: #ebebeb; +} + +.htMobileEditorContainer .positionControls { + width: 205pt; + position: absolute; + right: 5pt; + top: 0; + bottom: 0; +} + +.htMobileEditorContainer .positionControls > div { + width: 50pt; + height: 100%; + float: left; +} + +.htMobileEditorContainer .positionControls > div:after { + content: " "; + display: block; + width: 15pt; + height: 15pt; + text-align: center; + line-height: 50pt; +} + +.htMobileEditorContainer .downButton:after, .htMobileEditorContainer .leftButton:after, .htMobileEditorContainer .rightButton:after, .htMobileEditorContainer .upButton:after { + transform-origin: 5pt 5pt; + -webkit-transform-origin: 5pt 5pt; + margin: 21pt 0 0 21pt; +} + +.htMobileEditorContainer .leftButton:after { + border-top: 2px solid #288ffe; + border-left: 2px solid #288ffe; + -webkit-transform: rotate(-45deg); +} + +.htMobileEditorContainer .leftButton:active:after { + border-color: #cfcfcf; +} + +.htMobileEditorContainer .rightButton:after { + border-top: 2px solid #288ffe; + border-left: 2px solid #288ffe; + -webkit-transform: rotate(135deg); +} + +.htMobileEditorContainer .rightButton:active:after { + border-color: #cfcfcf; +} + +.htMobileEditorContainer .upButton:after { + border-top: 2px solid #288ffe; + border-left: 2px solid #288ffe; + -webkit-transform: rotate(45deg); +} + +.htMobileEditorContainer .upButton:active:after { + border-color: #cfcfcf; +} + +.htMobileEditorContainer .downButton:after { + border-top: 2px solid #288ffe; + border-left: 2px solid #288ffe; + -webkit-transform: rotate(225deg); +} + +.htMobileEditorContainer .downButton:active:after { + border-color: #cfcfcf; +} + +.handsontable.hide-tween { + -webkit-animation: opacity-hide 0.3s; + animation: opacity-hide 0.3s; + animation-fill-mode: forwards; + -webkit-animation-fill-mode: forwards; +} + +.handsontable.show-tween { + -webkit-animation: opacity-show 0.3s; + animation: opacity-show 0.3s; + animation-fill-mode: forwards; + -webkit-animation-fill-mode: forwards; +} + +/*! + * Pikaday + * Copyright © 2014 David Bushell | BSD & MIT license | https://dbushell.com/ + */ +.pika-single { + z-index: 9999; + display: block; + position: relative; + color: #333; + background: #fff; + border: 1px solid; + border-color: #ccc #ccc #bbb; + font-family: Helvetica Neue, Helvetica, Arial, sans-serif; +} + +.pika-single:after, .pika-single:before { + content: " "; + display: table; +} + +.pika-single:after { + clear: both; +} + +.pika-single { + *zoom: 1; +} + +.pika-single.is-hidden { + display: none; +} + +.pika-single.is-bound { + position: absolute; + box-shadow: 0 5px 15px -5px rgba(0, 0, 0, 0.5); +} + +.pika-lendar { + float: left; + width: 240px; + margin: 8px; +} + +.pika-title { + position: relative; + text-align: center; +} + +.pika-label { + display: inline-block; + *display: inline; + position: relative; + z-index: 9999; + overflow: hidden; + margin: 0; + padding: 5px 3px; + font-size: 14px; + line-height: 20px; + font-weight: 700; + background-color: #fff; +} + +.pika-title select { + cursor: pointer; + position: absolute; + z-index: 9998; + margin: 0; + left: 0; + top: 5px; + filter: alpha(opacity=0); + opacity: 0; +} + +.pika-next, .pika-prev { + display: block; + cursor: pointer; + position: relative; + outline: none; + border: 0; + padding: 0; + width: 20px; + height: 30px; + text-indent: 20px; + white-space: nowrap; + overflow: hidden; + background-color: transparent; + background-position: 50%; + background-repeat: no-repeat; + background-size: 75% 75%; + opacity: 0.5; + *position: absolute; + *top: 0; +} + +.pika-next:hover, .pika-prev:hover { + opacity: 1; +} + +.is-rtl .pika-next, .pika-prev { + float: left; + background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAeCAYAAAAsEj5rAAAAUklEQVR42u3VMQoAIBADQf8Pgj+OD9hG2CtONJB2ymQkKe0HbwAP0xucDiQWARITIDEBEnMgMQ8S8+AqBIl6kKgHiXqQqAeJepBo/z38J/U0uAHlaBkBl9I4GwAAAABJRU5ErkJggg=="); + *left: 0; +} + +.is-rtl .pika-prev, .pika-next { + float: right; + background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAeCAYAAAAsEj5rAAAAU0lEQVR42u3VOwoAMAgE0dwfAnNjU26bYkBCFGwfiL9VVWoO+BJ4Gf3gtsEKKoFBNTCoCAYVwaAiGNQGMUHMkjGbgjk2mIONuXo0nC8XnCf1JXgArVIZAQh5TKYAAAAASUVORK5CYII="); + *right: 0; +} + +.pika-next.is-disabled, .pika-prev.is-disabled { + cursor: default; + opacity: 0.2; +} + +.pika-select { + display: inline-block; + *display: inline; +} + +.pika-table { + width: 100%; + border-collapse: collapse; + border-spacing: 0; + border: 0; +} + +.pika-table td, .pika-table th { + width: 14.2857142857%; + padding: 0; +} + +.pika-table th { + color: #999; + font-size: 12px; + line-height: 25px; + font-weight: 700; + text-align: center; +} + +.pika-button { + cursor: pointer; + display: block; + box-sizing: border-box; + -moz-box-sizing: border-box; + outline: none; + border: 0; + margin: 0; + width: 100%; + padding: 5px; + color: #666; + font-size: 12px; + line-height: 15px; + text-align: right; + background: #f5f5f5; +} + +.pika-week { + font-size: 11px; + color: #999; +} + +.is-today .pika-button { + color: #3af; + font-weight: 700; +} + +.has-event .pika-button, .is-selected .pika-button { + color: #fff; + font-weight: 700; + background: #3af; + box-shadow: inset 0 1px 3px #178fe5; + border-radius: 3px; +} + +.has-event .pika-button { + background: #005da9; + box-shadow: inset 0 1px 3px #0076c9; +} + +.is-disabled .pika-button, .is-inrange .pika-button { + background: #d5e9f7; +} + +.is-startrange .pika-button { + color: #fff; + background: #6cb31d; + box-shadow: none; + border-radius: 3px; +} + +.is-endrange .pika-button { + color: #fff; + background: #3af; + box-shadow: none; + border-radius: 3px; +} + +.is-disabled .pika-button { + pointer-events: none; + cursor: default; + color: #999; + opacity: 0.3; +} + +.is-outside-current-month .pika-button { + color: #999; + opacity: 0.3; +} + +.is-selection-disabled { + pointer-events: none; + cursor: default; +} + +.pika-button:hover, .pika-row.pick-whole-week:hover .pika-button { + color: #fff; + background: #ff8000; + box-shadow: none; + border-radius: 3px; +} + +.pika-table abbr { + border-bottom: none; + cursor: help; +} + +.handsontable .htAutocompleteArrow { + float: right; + font-size: 10px; + color: #eee; + cursor: default; + width: 16px; + text-align: center; +} + +.handsontable td .htAutocompleteArrow:hover { + color: #777; +} + +.handsontable td.area .htAutocompleteArrow { + color: #d3d3d3; +} + +.handsontable .htCheckboxRendererInput { + display: inline-block; +} + +.handsontable .htCheckboxRendererInput.noValue { + opacity: 0.5; +} + +.handsontable .htCheckboxRendererLabel { + font-size: inherit; + vertical-align: middle; + cursor: pointer; + display: inline-block; + width: 100%; +} + +.htCommentCell { + position: relative; +} + +.htCommentCell:after { + content: ""; + position: absolute; + top: 0; + right: 0; + border-left: 6px solid transparent; + border-top: 6px solid #000; +} + +.htComments { + display: none; + z-index: 1059; + position: absolute; +} + +.htCommentTextArea { + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.117647), 0 1px 2px rgba(0, 0, 0, 0.239216); + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; + border: none; + border-left: 3px solid #ccc; + background-color: #fff; + width: 215px; + height: 90px; + font-size: 12px; + padding: 5px; + outline: 0 !important; + -webkit-appearance: none; +} + +.htCommentTextArea:focus { + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.117647), 0 1px 2px rgba(0, 0, 0, 0.239216), inset 0 0 0 1px #5292f7; + border-left: 3px solid #5292f7; +} + +/*! + * Handsontable ContextMenu + */ +.htContextMenu:not(.htGhostTable) { + display: none; + position: absolute; + z-index: 1060; +} + +.htContextMenu .ht_clone_corner, .htContextMenu .ht_clone_left, .htContextMenu .ht_clone_top { + display: none; +} + +.htContextMenu .ht_master table.htCore { + border-color: #ccc; + border-style: solid; + border-width: 1px 2px 2px 1px; +} + +.htContextMenu .wtBorder { + visibility: hidden; +} + +.htContextMenu table tbody tr td { + background: #fff; + border-width: 0; + padding: 4px 6px 0; + cursor: pointer; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; +} + +.htContextMenu table tbody tr td:first-child { + border: 0; +} + +.htContextMenu table tbody tr td.htDimmed { + font-style: normal; + color: #323232; +} + +.htContextMenu table tbody tr td.current, .htContextMenu table tbody tr td.zeroclipboard-is-hover { + background: #f3f3f3; +} + +.htContextMenu table tbody tr td.htSeparator { + border-top: 1px solid #e6e6e6; + height: 0; + padding: 0; + cursor: default; +} + +.htContextMenu table tbody tr td.htDisabled { + color: #999; + cursor: default; +} + +.htContextMenu table tbody tr td.htDisabled:hover { + background: #fff; + color: #999; + cursor: default; +} + +.htContextMenu table tbody tr.htHidden { + display: none; +} + +.htContextMenu table tbody tr td .htItemWrapper { + margin-left: 10px; + margin-right: 6px; +} + +.htContextMenu table tbody tr td div span.selected { + margin-top: -2px; + position: absolute; + left: 4px; +} + +.htContextMenu .ht_master .wtHolder { + overflow: hidden; +} + +textarea.HandsontableCopyPaste { + position: fixed !important; + top: 0 !important; + right: 100% !important; + overflow: hidden; + opacity: 0; + outline: 0 none !important; +} + +.htRowHeaders .ht_master.innerBorderLeft ~ .ht_clone_left td:first-of-type, .htRowHeaders .ht_master.innerBorderLeft ~ .ht_clone_top_left_corner th:nth-child(2) { + border-left: 0; +} + +.handsontable.ht__manualColumnMove.after-selection--columns thead th.ht__highlight { + cursor: move; + cursor: -moz-grab; + cursor: -webkit-grab; + cursor: grab; +} + +.handsontable.ht__manualColumnMove.on-moving--columns, .handsontable.ht__manualColumnMove.on-moving--columns thead th.ht__highlight { + cursor: move; + cursor: -moz-grabbing; + cursor: -webkit-grabbing; + cursor: grabbing; +} + +.handsontable.ht__manualColumnMove.on-moving--columns .manualColumnResizer { + display: none; +} + +.handsontable .ht__manualColumnMove--backlight, .handsontable .ht__manualColumnMove--guideline { + position: absolute; + height: 100%; + display: none; +} + +.handsontable .ht__manualColumnMove--guideline { + background: #757575; + width: 2px; + top: 0; + margin-left: -1px; + z-index: 205; +} + +.handsontable .ht__manualColumnMove--backlight { + background: #343434; + background: rgba(52, 52, 52, 0.25); + display: none; + z-index: 205; + pointer-events: none; +} + +.handsontable.on-moving--columns .ht__manualColumnMove--backlight, .handsontable.on-moving--columns.show-ui .ht__manualColumnMove--guideline { + display: block; +} + +.handsontable .wtHider { + position: relative; +} + +.handsontable.ht__manualRowMove.after-selection--rows tbody th.ht__highlight { + cursor: move; + cursor: -moz-grab; + cursor: -webkit-grab; + cursor: grab; +} + +.handsontable.ht__manualRowMove.on-moving--rows, .handsontable.ht__manualRowMove.on-moving--rows tbody th.ht__highlight { + cursor: move; + cursor: -moz-grabbing; + cursor: -webkit-grabbing; + cursor: grabbing; +} + +.handsontable.ht__manualRowMove.on-moving--rows .manualRowResizer { + display: none; +} + +.handsontable .ht__manualRowMove--backlight, .handsontable .ht__manualRowMove--guideline { + position: absolute; + width: 100%; + display: none; +} + +.handsontable .ht__manualRowMove--guideline { + background: #757575; + height: 2px; + left: 0; + margin-top: -1px; + z-index: 205; +} + +.handsontable .ht__manualRowMove--backlight { + background: #343434; + background: rgba(52, 52, 52, 0.25); + display: none; + z-index: 205; + pointer-events: none; +} + +.handsontable.on-moving--rows .ht__manualRowMove--backlight, .handsontable.on-moving--rows.show-ui .ht__manualRowMove--guideline { + display: block; +} + +.handsontable tbody td[rowspan][class*=area][class*=highlight]:not([class*=fullySelectedMergedCell]):before { + opacity: 0; +} + +.handsontable tbody td[rowspan][class*=area][class*=highlight][class*=fullySelectedMergedCell-0]:before, .handsontable tbody td[rowspan][class*=area][class*=highlight][class*=fullySelectedMergedCell-multiple]:before { + opacity: 0.1; +} + +.handsontable tbody td[rowspan][class*=area][class*=highlight][class*=fullySelectedMergedCell-1]:before { + opacity: 0.2; +} + +.handsontable tbody td[rowspan][class*=area][class*=highlight][class*=fullySelectedMergedCell-2]:before { + opacity: 0.27; +} + +.handsontable tbody td[rowspan][class*=area][class*=highlight][class*=fullySelectedMergedCell-3]:before { + opacity: 0.35; +} + +.handsontable tbody td[rowspan][class*=area][class*=highlight][class*=fullySelectedMergedCell-4]:before { + opacity: 0.41; +} + +.handsontable tbody td[rowspan][class*=area][class*=highlight][class*=fullySelectedMergedCell-5]:before { + opacity: 0.47; +} + +.handsontable tbody td[rowspan][class*=area][class*=highlight][class*=fullySelectedMergedCell-6]:before { + opacity: 0.54; +} + +.handsontable tbody td[rowspan][class*=area][class*=highlight][class*=fullySelectedMergedCell-7]:before { + opacity: 0.58; +} + +.handsontable span.colHeader.columnSorting:after { + top: 50%; + margin-top: -2px; + position: absolute; + right: -15px; + padding-left: 5px; + font-size: 8px; + height: 8px; + line-height: 1.1; + text-decoration: underline; + text-decoration: none; +} + +.handsontable span.colHeader.columnSorting[class*=" sort-"]:after, .handsontable span.colHeader.columnSorting[class^=sort-]:after { + content: "+"; +} + +.handsontable span.colHeader.columnSorting.sort-1:after { + content: "1"; +} + +.handsontable span.colHeader.columnSorting.sort-2:after { + content: "2"; +} + +.handsontable span.colHeader.columnSorting.sort-3:after { + content: "3"; +} + +.handsontable span.colHeader.columnSorting.sort-4:after { + content: "4"; +} + +.handsontable span.colHeader.columnSorting.sort-5:after { + content: "5"; +} + +.handsontable span.colHeader.columnSorting.sort-6:after { + content: "6"; +} + +.handsontable span.colHeader.columnSorting.sort-7:after { + content: "7"; +} + +.htGhostTable th div button.changeType + span.colHeader.columnSorting:not(.indicatorDisabled) { + padding-right: 5px; +} + +/*! + * Handsontable DropdownMenu + */ +.handsontable .changeType { + background: #eee; + border-radius: 2px; + border: 1px solid #bbb; + color: #bbb; + font-size: 9px; + line-height: 9px; + padding: 2px; + margin: 3px 1px 0 5px; + float: right; +} + +.handsontable .changeType:before { + content: "â–¼ "; +} + +.handsontable .changeType:hover { + border: 1px solid #777; + color: #777; + cursor: pointer; +} + +.htDropdownMenu:not(.htGhostTable) { + display: none; + position: absolute; + z-index: 1060; +} + +.htDropdownMenu .ht_clone_corner, .htDropdownMenu .ht_clone_left, .htDropdownMenu .ht_clone_top { + display: none; +} + +.htDropdownMenu table.htCore { + border-color: #bbb; + border-style: solid; + border-width: 1px 2px 2px 1px; +} + +.htDropdownMenu .wtBorder { + visibility: hidden; +} + +.htDropdownMenu table tbody tr td { + background: #fff; + border-width: 0; + padding: 4px 6px 0; + cursor: pointer; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; +} + +.htDropdownMenu table tbody tr td:first-child { + border: 0; +} + +.htDropdownMenu table tbody tr td.htDimmed { + font-style: normal; + color: #323232; +} + +.htDropdownMenu table tbody tr td.current, .htDropdownMenu table tbody tr td.zeroclipboard-is-hover { + background: #e9e9e9; +} + +.htDropdownMenu table tbody tr td.htSeparator { + border-top: 1px solid #e6e6e6; + height: 0; + padding: 0; + cursor: default; +} + +.htDropdownMenu table tbody tr td.htDisabled { + color: #999; +} + +.htDropdownMenu table tbody tr td.htDisabled:hover { + background: #fff; + color: #999; + cursor: default; +} + +.htDropdownMenu:not(.htGhostTable) table tbody tr.htHidden { + display: none; +} + +.htDropdownMenu table tbody tr td .htItemWrapper { + margin-left: 10px; + margin-right: 10px; +} + +.htDropdownMenu table tbody tr td div span.selected { + margin-top: -2px; + position: absolute; + left: 4px; +} + +.htDropdownMenu .ht_master .wtHolder { + overflow: hidden; +} + +/*! + * Handsontable Filters + */ +.htFiltersConditionsMenu:not(.htGhostTable) { + display: none; + position: absolute; + z-index: 1070; +} + +.htFiltersConditionsMenu .ht_clone_corner, .htFiltersConditionsMenu .ht_clone_left, .htFiltersConditionsMenu .ht_clone_top { + display: none; +} + +.htFiltersConditionsMenu table.htCore { + border-color: #bbb; + border-style: solid; + border-width: 1px 2px 2px 1px; +} + +.htFiltersConditionsMenu .wtBorder { + visibility: hidden; +} + +.htFiltersConditionsMenu table tbody tr td { + background: #fff; + border-width: 0; + padding: 4px 6px 0; + cursor: pointer; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; +} + +.htFiltersConditionsMenu table tbody tr td:first-child { + border: 0; +} + +.htFiltersConditionsMenu table tbody tr td.htDimmed { + font-style: normal; + color: #323232; +} + +.htFiltersConditionsMenu table tbody tr td.current, .htFiltersConditionsMenu table tbody tr td.zeroclipboard-is-hover { + background: #e9e9e9; +} + +.htFiltersConditionsMenu table tbody tr td.htSeparator { + border-top: 1px solid #e6e6e6; + height: 0; + padding: 0; +} + +.htFiltersConditionsMenu table tbody tr td.htDisabled { + color: #999; +} + +.htFiltersConditionsMenu table tbody tr td.htDisabled:hover { + background: #fff; + color: #999; + cursor: default; +} + +.htFiltersConditionsMenu table tbody tr td .htItemWrapper { + margin-left: 10px; + margin-right: 10px; +} + +.htFiltersConditionsMenu table tbody tr td div span.selected { + margin-top: -2px; + position: absolute; + left: 4px; +} + +.htFiltersConditionsMenu .ht_master .wtHolder { + overflow: hidden; +} + +.handsontable .htMenuFiltering { + border-bottom: 1px dotted #ccc; + height: 135px; + overflow: hidden; +} + +.handsontable .ht_master table td.htCustomMenuRenderer { + background-color: #fff; + cursor: auto; +} + +.handsontable .htFiltersMenuLabel { + font-size: 0.75em; +} + +.handsontable .htFiltersMenuActionBar { + text-align: center; + padding-top: 10px; + padding-bottom: 3px; +} + +.handsontable .htFiltersMenuCondition.border { + border-bottom: 1px dotted #ccc !important; +} + +.handsontable .htFiltersMenuCondition .htUIInput { + padding: 0 0 5px; +} + +.handsontable .htFiltersMenuValue { + border-bottom: 1px dotted #ccc !important; +} + +.handsontable .htFiltersMenuValue .htUIMultipleSelectSearch { + padding: 0; +} + +.handsontable .htFiltersMenuCondition .htUIInput input, .handsontable .htFiltersMenuValue .htUIMultipleSelectSearch input { + font-family: inherit; + font-size: 0.75em; + padding: 4px; + box-sizing: border-box; + width: 100%; +} + +.htUIMultipleSelect .ht_master .wtHolder { + overflow-y: scroll; +} + +.handsontable .htFiltersActive .changeType { + border: 1px solid #509272; + color: #18804e; + background-color: #d2e0d9; +} + +.handsontable .htUISelectAll { + margin-right: 10px; +} + +.handsontable .htUIClearAll, .handsontable .htUISelectAll { + display: inline-block; +} + +.handsontable .htUIClearAll a, .handsontable .htUISelectAll a { + color: #3283d8; + font-size: 0.75em; +} + +.handsontable .htUISelectionControls { + text-align: right; +} + +.handsontable .htCheckboxRendererInput { + margin: 0 5px 0 0; + vertical-align: middle; + height: 1em; +} + +.handsontable .htUIInput { + padding: 3px 0 7px; + position: relative; + text-align: center; +} + +.handsontable .htUIInput input { + border-radius: 2px; + border: 1px solid #d2d1d1; +} + +.handsontable .htUIInput input:focus { + outline: 0; +} + +.handsontable .htUIInputIcon { + position: absolute; +} + +.handsontable .htUIInput.htUIButton { + cursor: pointer; + display: inline-block; +} + +.handsontable .htUIInput.htUIButton input { + background-color: #eee; + color: #000; + cursor: pointer; + font-family: inherit; + font-size: 0.7em; + font-weight: 700; + height: 19px; + min-width: 64px; +} + +.handsontable .htUIInput.htUIButton input:hover { + border-color: #b9b9b9; +} + +.handsontable .htUIInput.htUIButtonOK { + margin-right: 10px; +} + +.handsontable .htUIInput.htUIButtonOK input { + background-color: #0f9d58; + border-color: #18804e; + color: #fff; +} + +.handsontable .htUIInput.htUIButtonOK input:hover { + border-color: #1a6f46; +} + +.handsontable .htUISelect { + cursor: pointer; + margin-bottom: 7px; + position: relative; +} + +.handsontable .htUISelectCaption { + background-color: #e8e8e8; + border-radius: 2px; + border: 1px solid #d2d1d1; + font-family: inherit; + font-size: 0.7em; + font-weight: 700; + padding: 3px 20px 3px 10px; + text-overflow: ellipsis; + white-space: nowrap; + overflow: hidden; +} + +.handsontable .htUISelectCaption:hover { + background-color: #e8e8e8; + border: 1px solid #b9b9b9; +} + +.handsontable .htUISelectDropdown:after { + content: "â–²"; + font-size: 7px; + position: absolute; + right: 10px; + top: 0; +} + +.handsontable .htUISelectDropdown:before { + content: "â–¼"; + font-size: 7px; + position: absolute; + right: 10px; + top: 8px; +} + +.handsontable .htUIMultipleSelect .handsontable .htCore { + border: none; +} + +.handsontable .htUIMultipleSelect .handsontable .htCore td:hover { + background-color: #f5f5f5; +} + +.handsontable .htUIMultipleSelectSearch input { + border-radius: 2px; + border: 1px solid #d2d1d1; + padding: 3px; +} + +.handsontable .htUIRadio { + display: inline-block; + margin-right: 5px; + height: 100%; +} + +.handsontable .htUIRadio:last-child { + margin-right: 0; +} + +.handsontable .htUIRadio > input[type=radio] { + margin-right: 0.5ex; +} + +.handsontable .htUIRadio label { + vertical-align: middle; +} + +.handsontable .htFiltersMenuOperators { + padding-bottom: 5px; +} + +.handsontable thead th.hiddenHeader:not(:first-of-type) { + display: none; +} + +.handsontable th.ht_nestingLevels { + text-align: left; + padding-left: 7px; +} + +.handsontable th div.ht_nestingLevels { + display: inline-block; + position: absolute; + left: 11px; +} + +.handsontable.innerBorderLeft th div.ht_nestingLevels, .handsontable.innerBorderLeft ~ .handsontable th div.ht_nestingLevels { + right: 10px; +} + +.handsontable th span.ht_nestingLevel { + display: inline-block; +} + +.handsontable th span.ht_nestingLevel_empty { + display: inline-block; + width: 10px; + height: 1px; + float: left; +} + +.handsontable th span.ht_nestingLevel:after { + content: "â”"; + font-size: 9px; + display: inline-block; + position: relative; + bottom: 3px; +} + +.handsontable th div.ht_nestingButton { + display: inline-block; + position: absolute; + right: -2px; + cursor: pointer; +} + +.handsontable th div.ht_nestingButton.ht_nestingExpand:after { + content: "+"; +} + +.handsontable th div.ht_nestingButton.ht_nestingCollapse:after { + content: "-"; +} + +.handsontable.innerBorderLeft th div.ht_nestingButton, .handsontable.innerBorderLeft ~ .handsontable th div.ht_nestingButton { + right: 0; +} + +.handsontable th.beforeHiddenColumn { + position: relative; +} + +.handsontable th.afterHiddenColumn:before, .handsontable th.beforeHiddenColumn:after { + color: #bbb; + position: absolute; + top: 50%; + font-size: 5pt; + transform: translateY(-50%); +} + +.handsontable th.afterHiddenColumn { + position: relative; +} + +.handsontable th.beforeHiddenColumn:after { + right: 1px; + content: "â—€"; +} + +.handsontable th.afterHiddenColumn:before { + left: 1px; + content: "â–¶"; +} + +/*! + * Handsontable HiddenRows + */ +.handsontable th.afterHiddenRow:after, .handsontable th.beforeHiddenRow:before { + color: #bbb; + font-size: 6pt; + line-height: 6pt; + position: absolute; + left: 2px; +} + +.handsontable th.afterHiddenRow, .handsontable th.beforeHiddenRow { + position: relative; +} + +.handsontable th.beforeHiddenRow:before { + content: "â–²"; + bottom: 2px; +} + +.handsontable th.afterHiddenRow:after { + content: "â–¼"; + top: 2px; +} + +.handsontable.ht__selection--rows tbody th.afterHiddenRow.ht__highlight:after, .handsontable.ht__selection--rows tbody th.beforeHiddenRow.ht__highlight:before { + color: #eee; +} + +.handsontable td.afterHiddenRow.firstVisibleRow, .handsontable th.afterHiddenRow.firstVisibleRow { + border-top: 1px solid #ccc; +} \ No newline at end of file diff --git a/fforte_data/.obsidian/plugins/obsidian-csv-table/main.js b/fforte_data/.obsidian/plugins/obsidian-csv-table/main.js new file mode 100644 index 0000000..518d400 --- /dev/null +++ b/fforte_data/.obsidian/plugins/obsidian-csv-table/main.js @@ -0,0 +1,3456 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ROLLUP +if you want to view the source visit the plugins github repository +*/ + +'use strict'; + +var obsidian = require('obsidian'); +var require$$0 = require('stream'); + +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } + +var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0); + +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __rest(s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +} + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +class ResizeableBuffer{ + constructor(size=100){ + this.size = size; + this.length = 0; + this.buf = Buffer.alloc(size); + } + prepend(val){ + if(Buffer.isBuffer(val)){ + const length = this.length + val.length; + if(length >= this.size){ + this.resize(); + if(length >= this.size){ + throw Error('INVALID_BUFFER_STATE') + } + } + const buf = this.buf; + this.buf = Buffer.alloc(this.size); + val.copy(this.buf, 0); + buf.copy(this.buf, val.length); + this.length += val.length; + }else { + const length = this.length++; + if(length === this.size){ + this.resize(); + } + const buf = this.clone(); + this.buf[0] = val; + buf.copy(this.buf,1, 0, length); + } + } + append(val){ + const length = this.length++; + if(length === this.size){ + this.resize(); + } + this.buf[length] = val; + } + clone(){ + return Buffer.from(this.buf.slice(0, this.length)) + } + resize(){ + const length = this.length; + this.size = this.size * 2; + const buf = Buffer.alloc(this.size); + this.buf.copy(buf,0, 0, length); + this.buf = buf; + } + toString(encoding){ + if(encoding){ + return this.buf.slice(0, this.length).toString(encoding) + }else { + return Uint8Array.prototype.slice.call(this.buf.slice(0, this.length)) + } + } + toJSON(){ + return this.toString('utf8') + } + reset(){ + this.length = 0; + } +} + +var ResizeableBuffer_1 = ResizeableBuffer; + +/* +CSV Parse + +Please look at the [project documentation](https://csv.js.org/parse/) for +additional information. +*/ + +const { Transform } = require$$0__default["default"]; + + +// white space characters +// https://en.wikipedia.org/wiki/Whitespace_character +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes#Types +// \f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff +const tab = 9; +const nl = 10; // \n, 0x0A in hexadecimal, 10 in decimal +const np = 12; +const cr = 13; // \r, 0x0D in hexadécimal, 13 in decimal +const space = 32; +const boms = { + // Note, the following are equals: + // Buffer.from("\ufeff") + // Buffer.from([239, 187, 191]) + // Buffer.from('EFBBBF', 'hex') + 'utf8': Buffer.from([239, 187, 191]), + // Note, the following are equals: + // Buffer.from "\ufeff", 'utf16le + // Buffer.from([255, 254]) + 'utf16le': Buffer.from([255, 254]) +}; + +class Parser extends Transform { + constructor(opts = {}){ + super({...{readableObjectMode: true}, ...opts, encoding: null}); + this.__originalOptions = opts; + this.__normalizeOptions(opts); + } + __normalizeOptions(opts){ + const options = {}; + // Merge with user options + for(let opt in opts){ + options[underscore(opt)] = opts[opt]; + } + // Normalize option `encoding` + // Note: defined first because other options depends on it + // to convert chars/strings into buffers. + if(options.encoding === undefined || options.encoding === true){ + options.encoding = 'utf8'; + }else if(options.encoding === null || options.encoding === false){ + options.encoding = null; + }else if(typeof options.encoding !== 'string' && options.encoding !== null){ + throw new CsvError('CSV_INVALID_OPTION_ENCODING', [ + 'Invalid option encoding:', + 'encoding must be a string or null to return a buffer,', + `got ${JSON.stringify(options.encoding)}` + ], options) + } + // Normalize option `bom` + if(options.bom === undefined || options.bom === null || options.bom === false){ + options.bom = false; + }else if(options.bom !== true){ + throw new CsvError('CSV_INVALID_OPTION_BOM', [ + 'Invalid option bom:', 'bom must be true,', + `got ${JSON.stringify(options.bom)}` + ], options) + } + // Normalize option `cast` + let fnCastField = null; + if(options.cast === undefined || options.cast === null || options.cast === false || options.cast === ''){ + options.cast = undefined; + }else if(typeof options.cast === 'function'){ + fnCastField = options.cast; + options.cast = true; + }else if(options.cast !== true){ + throw new CsvError('CSV_INVALID_OPTION_CAST', [ + 'Invalid option cast:', 'cast must be true or a function,', + `got ${JSON.stringify(options.cast)}` + ], options) + } + // Normalize option `cast_date` + if(options.cast_date === undefined || options.cast_date === null || options.cast_date === false || options.cast_date === ''){ + options.cast_date = false; + }else if(options.cast_date === true){ + options.cast_date = function(value){ + const date = Date.parse(value); + return !isNaN(date) ? new Date(date) : value + }; + }else { + throw new CsvError('CSV_INVALID_OPTION_CAST_DATE', [ + 'Invalid option cast_date:', 'cast_date must be true or a function,', + `got ${JSON.stringify(options.cast_date)}` + ], options) + } + // Normalize option `columns` + let fnFirstLineToHeaders = null; + if(options.columns === true){ + // Fields in the first line are converted as-is to columns + fnFirstLineToHeaders = undefined; + }else if(typeof options.columns === 'function'){ + fnFirstLineToHeaders = options.columns; + options.columns = true; + }else if(Array.isArray(options.columns)){ + options.columns = normalizeColumnsArray(options.columns); + }else if(options.columns === undefined || options.columns === null || options.columns === false){ + options.columns = false; + }else { + throw new CsvError('CSV_INVALID_OPTION_COLUMNS', [ + 'Invalid option columns:', + 'expect an array, a function or true,', + `got ${JSON.stringify(options.columns)}` + ], options) + } + // Normalize option `columns_duplicates_to_array` + if(options.columns_duplicates_to_array === undefined || options.columns_duplicates_to_array === null || options.columns_duplicates_to_array === false){ + options.columns_duplicates_to_array = false; + }else if(options.columns_duplicates_to_array !== true){ + throw new CsvError('CSV_INVALID_OPTION_COLUMNS_DUPLICATES_TO_ARRAY', [ + 'Invalid option columns_duplicates_to_array:', + 'expect an boolean,', + `got ${JSON.stringify(options.columns_duplicates_to_array)}` + ], options) + }else if(options.columns === false){ + throw new CsvError('CSV_INVALID_OPTION_COLUMNS_DUPLICATES_TO_ARRAY', [ + 'Invalid option columns_duplicates_to_array:', + 'the `columns` mode must be activated.' + ], options) + } + // Normalize option `comment` + if(options.comment === undefined || options.comment === null || options.comment === false || options.comment === ''){ + options.comment = null; + }else { + if(typeof options.comment === 'string'){ + options.comment = Buffer.from(options.comment, options.encoding); + } + if(!Buffer.isBuffer(options.comment)){ + throw new CsvError('CSV_INVALID_OPTION_COMMENT', [ + 'Invalid option comment:', + 'comment must be a buffer or a string,', + `got ${JSON.stringify(options.comment)}` + ], options) + } + } + // Normalize option `delimiter` + const delimiter_json = JSON.stringify(options.delimiter); + if(!Array.isArray(options.delimiter)) options.delimiter = [options.delimiter]; + if(options.delimiter.length === 0){ + throw new CsvError('CSV_INVALID_OPTION_DELIMITER', [ + 'Invalid option delimiter:', + 'delimiter must be a non empty string or buffer or array of string|buffer,', + `got ${delimiter_json}` + ], options) + } + options.delimiter = options.delimiter.map(function(delimiter){ + if(delimiter === undefined || delimiter === null || delimiter === false){ + return Buffer.from(',', options.encoding) + } + if(typeof delimiter === 'string'){ + delimiter = Buffer.from(delimiter, options.encoding); + } + if( !Buffer.isBuffer(delimiter) || delimiter.length === 0){ + throw new CsvError('CSV_INVALID_OPTION_DELIMITER', [ + 'Invalid option delimiter:', + 'delimiter must be a non empty string or buffer or array of string|buffer,', + `got ${delimiter_json}` + ], options) + } + return delimiter + }); + // Normalize option `escape` + if(options.escape === undefined || options.escape === true){ + options.escape = Buffer.from('"', options.encoding); + }else if(typeof options.escape === 'string'){ + options.escape = Buffer.from(options.escape, options.encoding); + }else if (options.escape === null || options.escape === false){ + options.escape = null; + } + if(options.escape !== null){ + if(!Buffer.isBuffer(options.escape)){ + throw new Error(`Invalid Option: escape must be a buffer, a string or a boolean, got ${JSON.stringify(options.escape)}`) + } + } + // Normalize option `from` + if(options.from === undefined || options.from === null){ + options.from = 1; + }else { + if(typeof options.from === 'string' && /\d+/.test(options.from)){ + options.from = parseInt(options.from); + } + if(Number.isInteger(options.from)){ + if(options.from < 0){ + throw new Error(`Invalid Option: from must be a positive integer, got ${JSON.stringify(opts.from)}`) + } + }else { + throw new Error(`Invalid Option: from must be an integer, got ${JSON.stringify(options.from)}`) + } + } + // Normalize option `from_line` + if(options.from_line === undefined || options.from_line === null){ + options.from_line = 1; + }else { + if(typeof options.from_line === 'string' && /\d+/.test(options.from_line)){ + options.from_line = parseInt(options.from_line); + } + if(Number.isInteger(options.from_line)){ + if(options.from_line <= 0){ + throw new Error(`Invalid Option: from_line must be a positive integer greater than 0, got ${JSON.stringify(opts.from_line)}`) + } + }else { + throw new Error(`Invalid Option: from_line must be an integer, got ${JSON.stringify(opts.from_line)}`) + } + } + // Normalize options `ignore_last_delimiters` + if(options.ignore_last_delimiters === undefined || options.ignore_last_delimiters === null){ + options.ignore_last_delimiters = false; + }else if(typeof options.ignore_last_delimiters === 'number'){ + options.ignore_last_delimiters = Math.floor(options.ignore_last_delimiters); + if(options.ignore_last_delimiters === 0){ + options.ignore_last_delimiters = false; + } + }else if(typeof options.ignore_last_delimiters !== 'boolean'){ + throw new CsvError('CSV_INVALID_OPTION_IGNORE_LAST_DELIMITERS', [ + 'Invalid option `ignore_last_delimiters`:', + 'the value must be a boolean value or an integer,', + `got ${JSON.stringify(options.ignore_last_delimiters)}` + ], options) + } + if(options.ignore_last_delimiters === true && options.columns === false){ + throw new CsvError('CSV_IGNORE_LAST_DELIMITERS_REQUIRES_COLUMNS', [ + 'The option `ignore_last_delimiters`', + 'requires the activation of the `columns` option' + ], options) + } + // Normalize option `info` + if(options.info === undefined || options.info === null || options.info === false){ + options.info = false; + }else if(options.info !== true){ + throw new Error(`Invalid Option: info must be true, got ${JSON.stringify(options.info)}`) + } + // Normalize option `max_record_size` + if(options.max_record_size === undefined || options.max_record_size === null || options.max_record_size === false){ + options.max_record_size = 0; + }else if(Number.isInteger(options.max_record_size) && options.max_record_size >= 0);else if(typeof options.max_record_size === 'string' && /\d+/.test(options.max_record_size)){ + options.max_record_size = parseInt(options.max_record_size); + }else { + throw new Error(`Invalid Option: max_record_size must be a positive integer, got ${JSON.stringify(options.max_record_size)}`) + } + // Normalize option `objname` + if(options.objname === undefined || options.objname === null || options.objname === false){ + options.objname = undefined; + }else if(Buffer.isBuffer(options.objname)){ + if(options.objname.length === 0){ + throw new Error(`Invalid Option: objname must be a non empty buffer`) + } + if(options.encoding === null);else { + options.objname = options.objname.toString(options.encoding); + } + }else if(typeof options.objname === 'string'){ + if(options.objname.length === 0){ + throw new Error(`Invalid Option: objname must be a non empty string`) + } + // Great, nothing to do + }else { + throw new Error(`Invalid Option: objname must be a string or a buffer, got ${options.objname}`) + } + // Normalize option `on_record` + if(options.on_record === undefined || options.on_record === null){ + options.on_record = undefined; + }else if(typeof options.on_record !== 'function'){ + throw new CsvError('CSV_INVALID_OPTION_ON_RECORD', [ + 'Invalid option `on_record`:', + 'expect a function,', + `got ${JSON.stringify(options.on_record)}` + ], options) + } + // Normalize option `quote` + if(options.quote === null || options.quote === false || options.quote === ''){ + options.quote = null; + }else { + if(options.quote === undefined || options.quote === true){ + options.quote = Buffer.from('"', options.encoding); + }else if(typeof options.quote === 'string'){ + options.quote = Buffer.from(options.quote, options.encoding); + } + if(!Buffer.isBuffer(options.quote)){ + throw new Error(`Invalid Option: quote must be a buffer or a string, got ${JSON.stringify(options.quote)}`) + } + } + // Normalize option `raw` + if(options.raw === undefined || options.raw === null || options.raw === false){ + options.raw = false; + }else if(options.raw !== true){ + throw new Error(`Invalid Option: raw must be true, got ${JSON.stringify(options.raw)}`) + } + // Normalize option `record_delimiter` + if(!options.record_delimiter){ + options.record_delimiter = []; + }else if(!Array.isArray(options.record_delimiter)){ + options.record_delimiter = [options.record_delimiter]; + } + options.record_delimiter = options.record_delimiter.map( function(rd){ + if(typeof rd === 'string'){ + rd = Buffer.from(rd, options.encoding); + } + return rd + }); + // Normalize option `relax` + if(typeof options.relax === 'boolean');else if(options.relax === undefined || options.relax === null){ + options.relax = false; + }else { + throw new Error(`Invalid Option: relax must be a boolean, got ${JSON.stringify(options.relax)}`) + } + // Normalize option `relax_column_count` + if(typeof options.relax_column_count === 'boolean');else if(options.relax_column_count === undefined || options.relax_column_count === null){ + options.relax_column_count = false; + }else { + throw new Error(`Invalid Option: relax_column_count must be a boolean, got ${JSON.stringify(options.relax_column_count)}`) + } + if(typeof options.relax_column_count_less === 'boolean');else if(options.relax_column_count_less === undefined || options.relax_column_count_less === null){ + options.relax_column_count_less = false; + }else { + throw new Error(`Invalid Option: relax_column_count_less must be a boolean, got ${JSON.stringify(options.relax_column_count_less)}`) + } + if(typeof options.relax_column_count_more === 'boolean');else if(options.relax_column_count_more === undefined || options.relax_column_count_more === null){ + options.relax_column_count_more = false; + }else { + throw new Error(`Invalid Option: relax_column_count_more must be a boolean, got ${JSON.stringify(options.relax_column_count_more)}`) + } + // Normalize option `skip_empty_lines` + if(typeof options.skip_empty_lines === 'boolean');else if(options.skip_empty_lines === undefined || options.skip_empty_lines === null){ + options.skip_empty_lines = false; + }else { + throw new Error(`Invalid Option: skip_empty_lines must be a boolean, got ${JSON.stringify(options.skip_empty_lines)}`) + } + // Normalize option `skip_lines_with_empty_values` + if(typeof options.skip_lines_with_empty_values === 'boolean');else if(options.skip_lines_with_empty_values === undefined || options.skip_lines_with_empty_values === null){ + options.skip_lines_with_empty_values = false; + }else { + throw new Error(`Invalid Option: skip_lines_with_empty_values must be a boolean, got ${JSON.stringify(options.skip_lines_with_empty_values)}`) + } + // Normalize option `skip_lines_with_error` + if(typeof options.skip_lines_with_error === 'boolean');else if(options.skip_lines_with_error === undefined || options.skip_lines_with_error === null){ + options.skip_lines_with_error = false; + }else { + throw new Error(`Invalid Option: skip_lines_with_error must be a boolean, got ${JSON.stringify(options.skip_lines_with_error)}`) + } + // Normalize option `rtrim` + if(options.rtrim === undefined || options.rtrim === null || options.rtrim === false){ + options.rtrim = false; + }else if(options.rtrim !== true){ + throw new Error(`Invalid Option: rtrim must be a boolean, got ${JSON.stringify(options.rtrim)}`) + } + // Normalize option `ltrim` + if(options.ltrim === undefined || options.ltrim === null || options.ltrim === false){ + options.ltrim = false; + }else if(options.ltrim !== true){ + throw new Error(`Invalid Option: ltrim must be a boolean, got ${JSON.stringify(options.ltrim)}`) + } + // Normalize option `trim` + if(options.trim === undefined || options.trim === null || options.trim === false){ + options.trim = false; + }else if(options.trim !== true){ + throw new Error(`Invalid Option: trim must be a boolean, got ${JSON.stringify(options.trim)}`) + } + // Normalize options `trim`, `ltrim` and `rtrim` + if(options.trim === true && opts.ltrim !== false){ + options.ltrim = true; + }else if(options.ltrim !== true){ + options.ltrim = false; + } + if(options.trim === true && opts.rtrim !== false){ + options.rtrim = true; + }else if(options.rtrim !== true){ + options.rtrim = false; + } + // Normalize option `to` + if(options.to === undefined || options.to === null){ + options.to = -1; + }else { + if(typeof options.to === 'string' && /\d+/.test(options.to)){ + options.to = parseInt(options.to); + } + if(Number.isInteger(options.to)){ + if(options.to <= 0){ + throw new Error(`Invalid Option: to must be a positive integer greater than 0, got ${JSON.stringify(opts.to)}`) + } + }else { + throw new Error(`Invalid Option: to must be an integer, got ${JSON.stringify(opts.to)}`) + } + } + // Normalize option `to_line` + if(options.to_line === undefined || options.to_line === null){ + options.to_line = -1; + }else { + if(typeof options.to_line === 'string' && /\d+/.test(options.to_line)){ + options.to_line = parseInt(options.to_line); + } + if(Number.isInteger(options.to_line)){ + if(options.to_line <= 0){ + throw new Error(`Invalid Option: to_line must be a positive integer greater than 0, got ${JSON.stringify(opts.to_line)}`) + } + }else { + throw new Error(`Invalid Option: to_line must be an integer, got ${JSON.stringify(opts.to_line)}`) + } + } + this.info = { + bytes: 0, + comment_lines: 0, + empty_lines: 0, + invalid_field_length: 0, + lines: 1, + records: 0 + }; + this.options = options; + this.state = { + bomSkipped: false, + bufBytesStart: 0, + castField: fnCastField, + commenting: false, + // Current error encountered by a record + error: undefined, + enabled: options.from_line === 1, + escaping: false, + // escapeIsQuote: options.escape === options.quote, + escapeIsQuote: Buffer.isBuffer(options.escape) && Buffer.isBuffer(options.quote) && Buffer.compare(options.escape, options.quote) === 0, + // columns can be `false`, `true`, `Array` + expectedRecordLength: Array.isArray(options.columns) ? options.columns.length : undefined, + field: new ResizeableBuffer_1(20), + firstLineToHeaders: fnFirstLineToHeaders, + needMoreDataSize: Math.max( + // Skip if the remaining buffer smaller than comment + options.comment !== null ? options.comment.length : 0, + // Skip if the remaining buffer can be delimiter + ...options.delimiter.map( (delimiter) => delimiter.length), + // Skip if the remaining buffer can be escape sequence + options.quote !== null ? options.quote.length : 0, + ), + previousBuf: undefined, + quoting: false, + stop: false, + rawBuffer: new ResizeableBuffer_1(100), + record: [], + recordHasError: false, + record_length: 0, + recordDelimiterMaxLength: options.record_delimiter.length === 0 ? 2 : Math.max(...options.record_delimiter.map( (v) => v.length)), + trimChars: [Buffer.from(' ', options.encoding)[0], Buffer.from('\t', options.encoding)[0]], + wasQuoting: false, + wasRowDelimiter: false + }; + } + // Implementation of `Transform._transform` + _transform(buf, encoding, callback){ + if(this.state.stop === true){ + return + } + const err = this.__parse(buf, false); + if(err !== undefined){ + this.state.stop = true; + } + callback(err); + } + // Implementation of `Transform._flush` + _flush(callback){ + if(this.state.stop === true){ + return + } + const err = this.__parse(undefined, true); + callback(err); + } + // Central parser implementation + __parse(nextBuf, end){ + const {bom, comment, escape, from_line, ltrim, max_record_size, quote, raw, relax, rtrim, skip_empty_lines, to, to_line} = this.options; + let {record_delimiter} = this.options; + const {bomSkipped, previousBuf, rawBuffer, escapeIsQuote} = this.state; + let buf; + if(previousBuf === undefined){ + if(nextBuf === undefined){ + // Handle empty string + this.push(null); + return + }else { + buf = nextBuf; + } + }else if(previousBuf !== undefined && nextBuf === undefined){ + buf = previousBuf; + }else { + buf = Buffer.concat([previousBuf, nextBuf]); + } + // Handle UTF BOM + if(bomSkipped === false){ + if(bom === false){ + this.state.bomSkipped = true; + }else if(buf.length < 3){ + // No enough data + if(end === false){ + // Wait for more data + this.state.previousBuf = buf; + return + } + }else { + for(let encoding in boms){ + if(boms[encoding].compare(buf, 0, boms[encoding].length) === 0){ + // Skip BOM + let bomLength = boms[encoding].length; + this.state.bufBytesStart += bomLength; + buf = buf.slice(bomLength); + // Renormalize original options with the new encoding + this.__normalizeOptions({...this.__originalOptions, encoding: encoding}); + break + } + } + this.state.bomSkipped = true; + } + } + const bufLen = buf.length; + let pos; + for(pos = 0; pos < bufLen; pos++){ + // Ensure we get enough space to look ahead + // There should be a way to move this out of the loop + if(this.__needMoreData(pos, bufLen, end)){ + break + } + if(this.state.wasRowDelimiter === true){ + this.info.lines++; + this.state.wasRowDelimiter = false; + } + if(to_line !== -1 && this.info.lines > to_line){ + this.state.stop = true; + this.push(null); + return + } + // Auto discovery of record_delimiter, unix, mac and windows supported + if(this.state.quoting === false && record_delimiter.length === 0){ + const record_delimiterCount = this.__autoDiscoverRecordDelimiter(buf, pos); + if(record_delimiterCount){ + record_delimiter = this.options.record_delimiter; + } + } + const chr = buf[pos]; + if(raw === true){ + rawBuffer.append(chr); + } + if((chr === cr || chr === nl) && this.state.wasRowDelimiter === false ){ + this.state.wasRowDelimiter = true; + } + // Previous char was a valid escape char + // treat the current char as a regular char + if(this.state.escaping === true){ + this.state.escaping = false; + }else { + // Escape is only active inside quoted fields + // We are quoting, the char is an escape chr and there is a chr to escape + // if(escape !== null && this.state.quoting === true && chr === escape && pos + 1 < bufLen){ + if(escape !== null && this.state.quoting === true && this.__isEscape(buf, pos, chr) && pos + escape.length < bufLen){ + if(escapeIsQuote){ + if(this.__isQuote(buf, pos+escape.length)){ + this.state.escaping = true; + pos += escape.length - 1; + continue + } + }else { + this.state.escaping = true; + pos += escape.length - 1; + continue + } + } + // Not currently escaping and chr is a quote + // TODO: need to compare bytes instead of single char + if(this.state.commenting === false && this.__isQuote(buf, pos)){ + if(this.state.quoting === true){ + const nextChr = buf[pos+quote.length]; + const isNextChrTrimable = rtrim && this.__isCharTrimable(nextChr); + const isNextChrComment = comment !== null && this.__compareBytes(comment, buf, pos+quote.length, nextChr); + const isNextChrDelimiter = this.__isDelimiter(buf, pos+quote.length, nextChr); + const isNextChrRecordDelimiter = record_delimiter.length === 0 ? this.__autoDiscoverRecordDelimiter(buf, pos+quote.length) : this.__isRecordDelimiter(nextChr, buf, pos+quote.length); + // Escape a quote + // Treat next char as a regular character + if(escape !== null && this.__isEscape(buf, pos, chr) && this.__isQuote(buf, pos + escape.length)){ + pos += escape.length - 1; + }else if(!nextChr || isNextChrDelimiter || isNextChrRecordDelimiter || isNextChrComment || isNextChrTrimable){ + this.state.quoting = false; + this.state.wasQuoting = true; + pos += quote.length - 1; + continue + }else if(relax === false){ + const err = this.__error( + new CsvError('CSV_INVALID_CLOSING_QUOTE', [ + 'Invalid Closing Quote:', + `got "${String.fromCharCode(nextChr)}"`, + `at line ${this.info.lines}`, + 'instead of delimiter, record delimiter, trimable character', + '(if activated) or comment', + ], this.options, this.__infoField()) + ); + if(err !== undefined) return err + }else { + this.state.quoting = false; + this.state.wasQuoting = true; + this.state.field.prepend(quote); + pos += quote.length - 1; + } + }else { + if(this.state.field.length !== 0){ + // In relax mode, treat opening quote preceded by chrs as regular + if( relax === false ){ + const err = this.__error( + new CsvError('INVALID_OPENING_QUOTE', [ + 'Invalid Opening Quote:', + `a quote is found inside a field at line ${this.info.lines}`, + ], this.options, this.__infoField(), { + field: this.state.field, + }) + ); + if(err !== undefined) return err + } + }else { + this.state.quoting = true; + pos += quote.length - 1; + continue + } + } + } + if(this.state.quoting === false){ + let recordDelimiterLength = this.__isRecordDelimiter(chr, buf, pos); + if(recordDelimiterLength !== 0){ + // Do not emit comments which take a full line + const skipCommentLine = this.state.commenting && (this.state.wasQuoting === false && this.state.record.length === 0 && this.state.field.length === 0); + if(skipCommentLine){ + this.info.comment_lines++; + // Skip full comment line + }else { + // Activate records emition if above from_line + if(this.state.enabled === false && this.info.lines + (this.state.wasRowDelimiter === true ? 1: 0) >= from_line){ + this.state.enabled = true; + this.__resetField(); + this.__resetRecord(); + pos += recordDelimiterLength - 1; + continue + } + // Skip if line is empty and skip_empty_lines activated + if(skip_empty_lines === true && this.state.wasQuoting === false && this.state.record.length === 0 && this.state.field.length === 0){ + this.info.empty_lines++; + pos += recordDelimiterLength - 1; + continue + } + this.info.bytes = this.state.bufBytesStart + pos; + const errField = this.__onField(); + if(errField !== undefined) return errField + this.info.bytes = this.state.bufBytesStart + pos + recordDelimiterLength; + const errRecord = this.__onRecord(); + if(errRecord !== undefined) return errRecord + if(to !== -1 && this.info.records >= to){ + this.state.stop = true; + this.push(null); + return + } + } + this.state.commenting = false; + pos += recordDelimiterLength - 1; + continue + } + if(this.state.commenting){ + continue + } + const commentCount = comment === null ? 0 : this.__compareBytes(comment, buf, pos, chr); + if(commentCount !== 0){ + this.state.commenting = true; + continue + } + let delimiterLength = this.__isDelimiter(buf, pos, chr); + if(delimiterLength !== 0){ + this.info.bytes = this.state.bufBytesStart + pos; + const errField = this.__onField(); + if(errField !== undefined) return errField + pos += delimiterLength - 1; + continue + } + } + } + if(this.state.commenting === false){ + if(max_record_size !== 0 && this.state.record_length + this.state.field.length > max_record_size){ + const err = this.__error( + new CsvError('CSV_MAX_RECORD_SIZE', [ + 'Max Record Size:', + 'record exceed the maximum number of tolerated bytes', + `of ${max_record_size}`, + `at line ${this.info.lines}`, + ], this.options, this.__infoField()) + ); + if(err !== undefined) return err + } + } + const lappend = ltrim === false || this.state.quoting === true || this.state.field.length !== 0 || !this.__isCharTrimable(chr); + // rtrim in non quoting is handle in __onField + const rappend = rtrim === false || this.state.wasQuoting === false; + if( lappend === true && rappend === true ){ + this.state.field.append(chr); + }else if(rtrim === true && !this.__isCharTrimable(chr)){ + const err = this.__error( + new CsvError('CSV_NON_TRIMABLE_CHAR_AFTER_CLOSING_QUOTE', [ + 'Invalid Closing Quote:', + 'found non trimable byte after quote', + `at line ${this.info.lines}`, + ], this.options, this.__infoField()) + ); + if(err !== undefined) return err + } + } + if(end === true){ + // Ensure we are not ending in a quoting state + if(this.state.quoting === true){ + const err = this.__error( + new CsvError('CSV_QUOTE_NOT_CLOSED', [ + 'Quote Not Closed:', + `the parsing is finished with an opening quote at line ${this.info.lines}`, + ], this.options, this.__infoField()) + ); + if(err !== undefined) return err + }else { + // Skip last line if it has no characters + if(this.state.wasQuoting === true || this.state.record.length !== 0 || this.state.field.length !== 0){ + this.info.bytes = this.state.bufBytesStart + pos; + const errField = this.__onField(); + if(errField !== undefined) return errField + const errRecord = this.__onRecord(); + if(errRecord !== undefined) return errRecord + }else if(this.state.wasRowDelimiter === true){ + this.info.empty_lines++; + }else if(this.state.commenting === true){ + this.info.comment_lines++; + } + } + }else { + this.state.bufBytesStart += pos; + this.state.previousBuf = buf.slice(pos); + } + if(this.state.wasRowDelimiter === true){ + this.info.lines++; + this.state.wasRowDelimiter = false; + } + } + __onRecord(){ + const {columns, columns_duplicates_to_array, encoding, info, from, relax_column_count, relax_column_count_less, relax_column_count_more, raw, skip_lines_with_empty_values} = this.options; + const {enabled, record} = this.state; + if(enabled === false){ + return this.__resetRecord() + } + // Convert the first line into column names + const recordLength = record.length; + if(columns === true){ + if(skip_lines_with_empty_values === true && isRecordEmpty(record)){ + this.__resetRecord(); + return + } + return this.__firstLineToColumns(record) + } + if(columns === false && this.info.records === 0){ + this.state.expectedRecordLength = recordLength; + } + if(recordLength !== this.state.expectedRecordLength){ + const err = columns === false ? + // Todo: rename CSV_INCONSISTENT_RECORD_LENGTH to + // CSV_RECORD_INCONSISTENT_FIELDS_LENGTH + new CsvError('CSV_INCONSISTENT_RECORD_LENGTH', [ + 'Invalid Record Length:', + `expect ${this.state.expectedRecordLength},`, + `got ${recordLength} on line ${this.info.lines}`, + ], this.options, this.__infoField(), { + record: record, + }) + : + // Todo: rename CSV_RECORD_DONT_MATCH_COLUMNS_LENGTH to + // CSV_RECORD_INCONSISTENT_COLUMNS + new CsvError('CSV_RECORD_DONT_MATCH_COLUMNS_LENGTH', [ + 'Invalid Record Length:', + `columns length is ${columns.length},`, // rename columns + `got ${recordLength} on line ${this.info.lines}`, + ], this.options, this.__infoField(), { + record: record, + }); + if(relax_column_count === true || + (relax_column_count_less === true && recordLength < this.state.expectedRecordLength) || + (relax_column_count_more === true && recordLength > this.state.expectedRecordLength) ){ + this.info.invalid_field_length++; + this.state.error = err; + // Error is undefined with skip_lines_with_error + }else { + const finalErr = this.__error(err); + if(finalErr) return finalErr + } + } + if(skip_lines_with_empty_values === true && isRecordEmpty(record)){ + this.__resetRecord(); + return + } + if(this.state.recordHasError === true){ + this.__resetRecord(); + this.state.recordHasError = false; + return + } + this.info.records++; + if(from === 1 || this.info.records >= from){ + // With columns, records are object + if(columns !== false){ + const obj = {}; + // Transform record array to an object + for(let i = 0, l = record.length; i < l; i++){ + if(columns[i] === undefined || columns[i].disabled) continue + // Turn duplicate columns into an array + if (columns_duplicates_to_array === true && obj[columns[i].name] !== undefined) { + if (Array.isArray(obj[columns[i].name])) { + obj[columns[i].name] = obj[columns[i].name].concat(record[i]); + } else { + obj[columns[i].name] = [obj[columns[i].name], record[i]]; + } + } else { + obj[columns[i].name] = record[i]; + } + } + const {objname} = this.options; + // Without objname (default) + if(objname === undefined){ + if(raw === true || info === true){ + const err = this.__push(Object.assign( + {record: obj}, + (raw === true ? {raw: this.state.rawBuffer.toString(encoding)}: {}), + (info === true ? {info: this.__infoRecord()}: {}) + )); + if(err){ + return err + } + }else { + const err = this.__push(obj); + if(err){ + return err + } + } + // With objname (default) + }else { + if(raw === true || info === true){ + const err = this.__push(Object.assign( + {record: [obj[objname], obj]}, + raw === true ? {raw: this.state.rawBuffer.toString(encoding)}: {}, + info === true ? {info: this.__infoRecord()}: {} + )); + if(err){ + return err + } + }else { + const err = this.__push([obj[objname], obj]); + if(err){ + return err + } + } + } + // Without columns, records are array + }else { + if(raw === true || info === true){ + const err = this.__push(Object.assign( + {record: record}, + raw === true ? {raw: this.state.rawBuffer.toString(encoding)}: {}, + info === true ? {info: this.__infoRecord()}: {} + )); + if(err){ + return err + } + }else { + const err = this.__push(record); + if(err){ + return err + } + } + } + } + this.__resetRecord(); + } + __firstLineToColumns(record){ + const {firstLineToHeaders} = this.state; + try{ + const headers = firstLineToHeaders === undefined ? record : firstLineToHeaders.call(null, record); + if(!Array.isArray(headers)){ + return this.__error( + new CsvError('CSV_INVALID_COLUMN_MAPPING', [ + 'Invalid Column Mapping:', + 'expect an array from column function,', + `got ${JSON.stringify(headers)}` + ], this.options, this.__infoField(), { + headers: headers, + }) + ) + } + const normalizedHeaders = normalizeColumnsArray(headers); + this.state.expectedRecordLength = normalizedHeaders.length; + this.options.columns = normalizedHeaders; + this.__resetRecord(); + return + }catch(err){ + return err + } + } + __resetRecord(){ + if(this.options.raw === true){ + this.state.rawBuffer.reset(); + } + this.state.error = undefined; + this.state.record = []; + this.state.record_length = 0; + } + __onField(){ + const {cast, encoding, rtrim, max_record_size} = this.options; + const {enabled, wasQuoting} = this.state; + // Short circuit for the from_line options + if(enabled === false){ + return this.__resetField() + } + let field = this.state.field.toString(encoding); + if(rtrim === true && wasQuoting === false){ + field = field.trimRight(); + } + if(cast === true){ + const [err, f] = this.__cast(field); + if(err !== undefined) return err + field = f; + } + this.state.record.push(field); + // Increment record length if record size must not exceed a limit + if(max_record_size !== 0 && typeof field === 'string'){ + this.state.record_length += field.length; + } + this.__resetField(); + } + __resetField(){ + this.state.field.reset(); + this.state.wasQuoting = false; + } + __push(record){ + const {on_record} = this.options; + if(on_record !== undefined){ + const info = this.__infoRecord(); + try{ + record = on_record.call(null, record, info); + }catch(err){ + return err + } + if(record === undefined || record === null){ return } + } + this.push(record); + } + // Return a tuple with the error and the casted value + __cast(field){ + const {columns, relax_column_count} = this.options; + const isColumns = Array.isArray(columns); + // Dont loose time calling cast + // because the final record is an object + // and this field can't be associated to a key present in columns + if( isColumns === true && relax_column_count && this.options.columns.length <= this.state.record.length ){ + return [undefined, undefined] + } + if(this.state.castField !== null){ + try{ + const info = this.__infoField(); + return [undefined, this.state.castField.call(null, field, info)] + }catch(err){ + return [err] + } + } + if(this.__isFloat(field)){ + return [undefined, parseFloat(field)] + }else if(this.options.cast_date !== false){ + const info = this.__infoField(); + return [undefined, this.options.cast_date.call(null, field, info)] + } + return [undefined, field] + } + // Helper to test if a character is a space or a line delimiter + __isCharTrimable(chr){ + return chr === space || chr === tab || chr === cr || chr === nl || chr === np + } + // Keep it in case we implement the `cast_int` option + // __isInt(value){ + // // return Number.isInteger(parseInt(value)) + // // return !isNaN( parseInt( obj ) ); + // return /^(\-|\+)?[1-9][0-9]*$/.test(value) + // } + __isFloat(value){ + return (value - parseFloat( value ) + 1) >= 0 // Borrowed from jquery + } + __compareBytes(sourceBuf, targetBuf, targetPos, firstByte){ + if(sourceBuf[0] !== firstByte) return 0 + const sourceLength = sourceBuf.length; + for(let i = 1; i < sourceLength; i++){ + if(sourceBuf[i] !== targetBuf[targetPos+i]) return 0 + } + return sourceLength + } + __needMoreData(i, bufLen, end){ + if(end) return false + const {quote} = this.options; + const {quoting, needMoreDataSize, recordDelimiterMaxLength} = this.state; + const numOfCharLeft = bufLen - i - 1; + const requiredLength = Math.max( + needMoreDataSize, + // Skip if the remaining buffer smaller than record delimiter + recordDelimiterMaxLength, + // Skip if the remaining buffer can be record delimiter following the closing quote + // 1 is for quote.length + quoting ? (quote.length + recordDelimiterMaxLength) : 0, + ); + return numOfCharLeft < requiredLength + } + __isDelimiter(buf, pos, chr){ + const {delimiter, ignore_last_delimiters} = this.options; + if(ignore_last_delimiters === true && this.state.record.length === this.options.columns.length - 1){ + return 0 + }else if(ignore_last_delimiters !== false && typeof ignore_last_delimiters === 'number' && this.state.record.length === ignore_last_delimiters - 1){ + return 0 + } + loop1: for(let i = 0; i < delimiter.length; i++){ + const del = delimiter[i]; + if(del[0] === chr){ + for(let j = 1; j < del.length; j++){ + if(del[j] !== buf[pos+j]) continue loop1 + } + return del.length + } + } + return 0 + } + __isRecordDelimiter(chr, buf, pos){ + const {record_delimiter} = this.options; + const recordDelimiterLength = record_delimiter.length; + loop1: for(let i = 0; i < recordDelimiterLength; i++){ + const rd = record_delimiter[i]; + const rdLength = rd.length; + if(rd[0] !== chr){ + continue + } + for(let j = 1; j < rdLength; j++){ + if(rd[j] !== buf[pos+j]){ + continue loop1 + } + } + return rd.length + } + return 0 + } + __isEscape(buf, pos, chr){ + const {escape} = this.options; + if(escape === null) return false + const l = escape.length; + if(escape[0] === chr){ + for(let i = 0; i < l; i++){ + if(escape[i] !== buf[pos+i]){ + return false + } + } + return true + } + return false + } + __isQuote(buf, pos){ + const {quote} = this.options; + if(quote === null) return false + const l = quote.length; + for(let i = 0; i < l; i++){ + if(quote[i] !== buf[pos+i]){ + return false + } + } + return true + } + __autoDiscoverRecordDelimiter(buf, pos){ + const {encoding} = this.options; + const chr = buf[pos]; + if(chr === cr){ + if(buf[pos+1] === nl){ + this.options.record_delimiter.push(Buffer.from('\r\n', encoding)); + this.state.recordDelimiterMaxLength = 2; + return 2 + }else { + this.options.record_delimiter.push(Buffer.from('\r', encoding)); + this.state.recordDelimiterMaxLength = 1; + return 1 + } + }else if(chr === nl){ + this.options.record_delimiter.push(Buffer.from('\n', encoding)); + this.state.recordDelimiterMaxLength = 1; + return 1 + } + return 0 + } + __error(msg){ + const {skip_lines_with_error} = this.options; + const err = typeof msg === 'string' ? new Error(msg) : msg; + if(skip_lines_with_error){ + this.state.recordHasError = true; + this.emit('skip', err); + return undefined + }else { + return err + } + } + __infoDataSet(){ + return { + ...this.info, + columns: this.options.columns + } + } + __infoRecord(){ + const {columns} = this.options; + return { + ...this.__infoDataSet(), + error: this.state.error, + header: columns === true, + index: this.state.record.length, + } + } + __infoField(){ + const {columns} = this.options; + const isColumns = Array.isArray(columns); + return { + ...this.__infoRecord(), + column: isColumns === true ? + ( columns.length > this.state.record.length ? + columns[this.state.record.length].name : + null + ) : + this.state.record.length, + quoting: this.state.wasQuoting, + } + } +} + +const parse = function(){ + let data, options, callback; + for(let i in arguments){ + const argument = arguments[i]; + const type = typeof argument; + if(data === undefined && (typeof argument === 'string' || Buffer.isBuffer(argument))){ + data = argument; + }else if(options === undefined && isObject(argument)){ + options = argument; + }else if(callback === undefined && type === 'function'){ + callback = argument; + }else { + throw new CsvError('CSV_INVALID_ARGUMENT', [ + 'Invalid argument:', + `got ${JSON.stringify(argument)} at index ${i}` + ], options || {}) + } + } + const parser = new Parser(options); + if(callback){ + const records = options === undefined || options.objname === undefined ? [] : {}; + parser.on('readable', function(){ + let record; + while((record = this.read()) !== null){ + if(options === undefined || options.objname === undefined){ + records.push(record); + }else { + records[record[0]] = record[1]; + } + } + }); + parser.on('error', function(err){ + callback(err, undefined, parser.__infoDataSet()); + }); + parser.on('end', function(){ + callback(undefined, records, parser.__infoDataSet()); + }); + } + if(data !== undefined){ + // Give a chance for events to be registered later + if(typeof setImmediate === 'function'){ + setImmediate(function(){ + parser.write(data); + parser.end(); + }); + }else { + parser.write(data); + parser.end(); + } + } + return parser +}; + +class CsvError extends Error { + constructor(code, message, options, ...contexts) { + if(Array.isArray(message)) message = message.join(' '); + super(message); + if(Error.captureStackTrace !== undefined){ + Error.captureStackTrace(this, CsvError); + } + this.code = code; + for(const context of contexts){ + for(const key in context){ + const value = context[key]; + this[key] = Buffer.isBuffer(value) ? value.toString(options.encoding) : value == null ? value : JSON.parse(JSON.stringify(value)); + } + } + } +} + +parse.Parser = Parser; + +parse.CsvError = CsvError; + +var lib = parse; + +const underscore = function(str){ + return str.replace(/([A-Z])/g, function(_, match){ + return '_' + match.toLowerCase() + }) +}; + +const isObject = function(obj){ + return (typeof obj === 'object' && obj !== null && !Array.isArray(obj)) +}; + +const isRecordEmpty = function(record){ + return record.every( (field) => field == null || field.toString && field.toString().trim() === '' ) +}; + +const normalizeColumnsArray = function(columns){ + const normalizedColumns = []; + for(let i = 0, l = columns.length; i < l; i++){ + const column = columns[i]; + if(column === undefined || column === null || column === false){ + normalizedColumns[i] = { disabled: true }; + }else if(typeof column === 'string'){ + normalizedColumns[i] = { name: column }; + }else if(isObject(column)){ + if(typeof column.name !== 'string'){ + throw new CsvError('CSV_OPTION_COLUMNS_MISSING_NAME', [ + 'Option columns missing name:', + `property "name" is required at position ${i}`, + 'when column is an object literal' + ]) + } + normalizedColumns[i] = column; + }else { + throw new CsvError('CSV_INVALID_COLUMN_DEFINITION', [ + 'Invalid column definition:', + 'expect a string or a literal object,', + `got ${JSON.stringify(column)} at position ${i}` + ]) + } + } + return normalizedColumns; +}; + +var sync = function(data, options={}){ + if(typeof data === 'string'){ + data = Buffer.from(data); + } + const records = options && options.objname ? {} : []; + const parser = new lib.Parser(options); + parser.push = function(record){ + if(record === null){ + return + } + if(options.objname === undefined) + records.push(record); + else { + records[record[0]] = record[1]; + } + }; + const err1 = parser.__parse(data, false); + if(err1 !== undefined) throw err1 + const err2 = parser.__parse(undefined, true); + if(err2 !== undefined) throw err2 + return records +}; + +/* Jison generated parser */ +var _parser = (function() { + var parser = { + trace: function trace() {}, + yy: {}, + symbols_: { + "error": 2, + "expressions": 3, + "e": 4, + "EOF": 5, + "+": 6, + "-": 7, + "*": 8, + "/": 9, + "%": 10, + "^": 11, + "and": 12, + "or": 13, + "not": 14, + "==": 15, + "!=": 16, + "~=": 17, + "<": 18, + "<=": 19, + ">": 20, + ">=": 21, + "?": 22, + ":": 23, + "(": 24, + ")": 25, + "array": 26, + ",": 27, + "NUMBER": 28, + "STRING": 29, + "SYMBOL": 30, + "of": 31, + "argsList": 32, + "in": 33, + "inSet": 34, + "$accept": 0, + "$end": 1 + }, + terminals_: { + 2: "error", + 5: "EOF", + 6: "+", + 7: "-", + 8: "*", + 9: "/", + 10: "%", + 11: "^", + 12: "and", + 13: "or", + 14: "not", + 15: "==", + 16: "!=", + 17: "~=", + 18: "<", + 19: "<=", + 20: ">", + 21: ">=", + 22: "?", + 23: ":", + 24: "(", + 25: ")", + 27: ",", + 28: "NUMBER", + 29: "STRING", + 30: "SYMBOL", + 31: "of", + 33: "in" + }, + productions_: [0, [3, 2], + [4, 3], + [4, 3], + [4, 3], + [4, 3], + [4, 3], + [4, 3], + [4, 2], + [4, 3], + [4, 3], + [4, 2], + [4, 3], + [4, 3], + [4, 3], + [4, 3], + [4, 3], + [4, 3], + [4, 3], + [4, 5], + [4, 3], + [4, 5], + [4, 1], + [4, 1], + [4, 1], + [4, 3], + [4, 3], + [4, 4], + [4, 3], + [4, 4], + [32, 1], + [32, 3], + [34, 1], + [34, 3], + [26, 1], + [26, 3] + ], + performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) { + + var $0 = $$.length - 1; + switch (yystate) { + case 1: + return $$[$0 - 1]; + case 2: + this.$ = ["(", $$[$0 - 2], "+", $$[$0], ")"]; + break; + case 3: + this.$ = ["(", $$[$0 - 2], "-", $$[$0], ")"]; + break; + case 4: + this.$ = ["(", $$[$0 - 2], "*", $$[$0], ")"]; + break; + case 5: + this.$ = ["(", $$[$0 - 2], "/", $$[$0], ")"]; + break; + case 6: + this.$ = ["(", $$[$0 - 2], "%", $$[$0], ")"]; + break; + case 7: + this.$ = ["(", "Math.pow(", $$[$0 - 2], ",", $$[$0], ")", ")"]; + break; + case 8: + this.$ = ["(", "-", $$[$0], ")"]; + break; + case 9: + this.$ = ["(", "Number(", $$[$0 - 2], "&&", $$[$0], ")", ")"]; + break; + case 10: + this.$ = ["(", "Number(", $$[$0 - 2], "||", $$[$0], ")", ")"]; + break; + case 11: + this.$ = ["(", "Number(!", $$[$0], ")", ")"]; + break; + case 12: + this.$ = ["(", "Number(", $$[$0 - 2], "==", $$[$0], ")", ")"]; + break; + case 13: + this.$ = ["(", "Number(", $$[$0 - 2], "!=", $$[$0], ")", ")"]; + break; + case 14: + this.$ = ["(", "Number(RegExp(", $$[$0], ").test(", $$[$0 - 2], "))", ")"]; + break; + case 15: + this.$ = ["(", "Number(", $$[$0 - 2], "<", $$[$0], ")", ")"]; + break; + case 16: + this.$ = ["(", "Number(", $$[$0 - 2], "<=", $$[$0], ")", ")"]; + break; + case 17: + this.$ = ["(", "Number(", $$[$0 - 2], "> ", $$[$0], ")", ")"]; + break; + case 18: + this.$ = ["(", "Number(", $$[$0 - 2], ">=", $$[$0], ")", ")"]; + break; + case 19: + this.$ = ["(", $$[$0 - 4], "?", $$[$0 - 2], ":", $$[$0], ")"]; + break; + case 20: + this.$ = ["(", $$[$0 - 1], ")"]; + break; + case 21: + this.$ = ["(", "[", $$[$0 - 3], ",", $$[$0 - 1], "]", ")"]; + break; + case 22: + this.$ = ["(", $$[$0], ")"]; + break; + case 23: + this.$ = ["(", $$[$0], ")"]; + break; + case 24: + this.$ = ["(", "prop(", $$[$0], ", data)", ")"]; + break; + case 25: + this.$ = ["(", "prop(", $$[$0 - 2], ",", $$[$0], ")", ")"]; + break; + case 26: + this.$ = ["(", "(std.isfn(fns, ", $$[$0 - 2], ") ? fns[", $$[$0 - 2], "]() : std.unknown(", $$[$0 - 2], "))", ")"]; + break; + case 27: + this.$ = ["(", "(std.isfn(fns, ", $$[$0 - 3], ") ? fns[", $$[$0 - 3], "](", $$[$0 - 1], ") : std.unknown(", $$[$0 - 3], "))", ")"]; + break; + case 28: + this.$ = ["(", "std.isSubset(", $$[$0 - 2], ", ", $$[$0], ")", ")"]; + break; + case 29: + this.$ = ["(", "+!std.isSubset(", $$[$0 - 3], ", ", $$[$0], ")", ")"]; + break; + case 30: + this.$ = [$$[$0]]; + break; + case 31: + this.$ = [$$[$0 - 2], ",", $$[$0]]; + break; + case 32: + this.$ = ["o ==", $$[$0]]; + break; + case 33: + this.$ = [$$[$0 - 2], "|| o ==", $$[$0]]; + break; + case 34: + this.$ = ["(", $$[$0], ")"]; + break; + case 35: + this.$ = [$$[$0 - 2], ",", $$[$0]]; + break; + } + }, + table: [{ + 3: 1, + 4: 2, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 1: [3] + }, { + 5: [1, 9], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [1, 16], + 13: [1, 17], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [1, 25], + 33: [1, 26] + }, { + 4: 28, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 29, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 30, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 26: 31, + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 5: [2, 22], + 6: [2, 22], + 7: [2, 22], + 8: [2, 22], + 9: [2, 22], + 10: [2, 22], + 11: [2, 22], + 12: [2, 22], + 13: [2, 22], + 14: [2, 22], + 15: [2, 22], + 16: [2, 22], + 17: [2, 22], + 18: [2, 22], + 19: [2, 22], + 20: [2, 22], + 21: [2, 22], + 22: [2, 22], + 23: [2, 22], + 25: [2, 22], + 27: [2, 22], + 33: [2, 22] + }, { + 5: [2, 23], + 6: [2, 23], + 7: [2, 23], + 8: [2, 23], + 9: [2, 23], + 10: [2, 23], + 11: [2, 23], + 12: [2, 23], + 13: [2, 23], + 14: [2, 23], + 15: [2, 23], + 16: [2, 23], + 17: [2, 23], + 18: [2, 23], + 19: [2, 23], + 20: [2, 23], + 21: [2, 23], + 22: [2, 23], + 23: [2, 23], + 25: [2, 23], + 27: [2, 23], + 33: [2, 23] + }, { + 5: [2, 24], + 6: [2, 24], + 7: [2, 24], + 8: [2, 24], + 9: [2, 24], + 10: [2, 24], + 11: [2, 24], + 12: [2, 24], + 13: [2, 24], + 14: [2, 24], + 15: [2, 24], + 16: [2, 24], + 17: [2, 24], + 18: [2, 24], + 19: [2, 24], + 20: [2, 24], + 21: [2, 24], + 22: [2, 24], + 23: [2, 24], + 24: [1, 33], + 25: [2, 24], + 27: [2, 24], + 31: [1, 32], + 33: [2, 24] + }, { + 1: [2, 1] + }, { + 4: 34, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 35, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 36, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 37, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 38, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 39, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 40, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 41, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 42, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 43, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 44, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 45, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 46, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 47, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 48, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 49, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 50, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 33: [1, 51] + }, { + 5: [2, 8], + 6: [2, 8], + 7: [2, 8], + 8: [2, 8], + 9: [2, 8], + 10: [2, 8], + 11: [2, 8], + 12: [2, 8], + 13: [2, 8], + 14: [2, 8], + 15: [2, 8], + 16: [2, 8], + 17: [2, 8], + 18: [2, 8], + 19: [2, 8], + 20: [2, 8], + 21: [2, 8], + 22: [2, 8], + 23: [2, 8], + 25: [2, 8], + 27: [2, 8], + 33: [2, 8] + }, { + 5: [2, 11], + 6: [2, 11], + 7: [2, 11], + 8: [2, 11], + 9: [2, 11], + 10: [2, 11], + 11: [2, 11], + 12: [2, 11], + 13: [2, 11], + 14: [2, 11], + 15: [2, 11], + 16: [2, 11], + 17: [2, 11], + 18: [2, 11], + 19: [2, 11], + 20: [2, 11], + 21: [2, 11], + 22: [2, 11], + 23: [2, 11], + 25: [2, 11], + 27: [2, 11], + 33: [2, 11] + }, { + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [1, 16], + 13: [1, 17], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [1, 25], + 25: [1, 52], + 27: [2, 34], + 33: [1, 26] + }, { + 27: [1, 53] + }, { + 4: 54, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 4: 57, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 25: [1, 55], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8], + 32: 56 + }, { + 5: [2, 2], + 6: [2, 2], + 7: [2, 2], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 2], + 13: [2, 2], + 14: [1, 27], + 15: [2, 2], + 16: [2, 2], + 17: [2, 2], + 18: [2, 2], + 19: [2, 2], + 20: [2, 2], + 21: [2, 2], + 22: [2, 2], + 23: [2, 2], + 25: [2, 2], + 27: [2, 2], + 33: [2, 2] + }, { + 5: [2, 3], + 6: [2, 3], + 7: [2, 3], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 3], + 13: [2, 3], + 14: [1, 27], + 15: [2, 3], + 16: [2, 3], + 17: [2, 3], + 18: [2, 3], + 19: [2, 3], + 20: [2, 3], + 21: [2, 3], + 22: [2, 3], + 23: [2, 3], + 25: [2, 3], + 27: [2, 3], + 33: [2, 3] + }, { + 5: [2, 4], + 6: [2, 4], + 7: [2, 4], + 8: [2, 4], + 9: [2, 4], + 10: [2, 4], + 11: [1, 15], + 12: [2, 4], + 13: [2, 4], + 14: [1, 27], + 15: [2, 4], + 16: [2, 4], + 17: [2, 4], + 18: [2, 4], + 19: [2, 4], + 20: [2, 4], + 21: [2, 4], + 22: [2, 4], + 23: [2, 4], + 25: [2, 4], + 27: [2, 4], + 33: [2, 4] + }, { + 5: [2, 5], + 6: [2, 5], + 7: [2, 5], + 8: [2, 5], + 9: [2, 5], + 10: [2, 5], + 11: [1, 15], + 12: [2, 5], + 13: [2, 5], + 14: [1, 27], + 15: [2, 5], + 16: [2, 5], + 17: [2, 5], + 18: [2, 5], + 19: [2, 5], + 20: [2, 5], + 21: [2, 5], + 22: [2, 5], + 23: [2, 5], + 25: [2, 5], + 27: [2, 5], + 33: [2, 5] + }, { + 5: [2, 6], + 6: [2, 6], + 7: [2, 6], + 8: [2, 6], + 9: [2, 6], + 10: [2, 6], + 11: [1, 15], + 12: [2, 6], + 13: [2, 6], + 14: [1, 27], + 15: [2, 6], + 16: [2, 6], + 17: [2, 6], + 18: [2, 6], + 19: [2, 6], + 20: [2, 6], + 21: [2, 6], + 22: [2, 6], + 23: [2, 6], + 25: [2, 6], + 27: [2, 6], + 33: [2, 6] + }, { + 5: [2, 7], + 6: [2, 7], + 7: [2, 7], + 8: [2, 7], + 9: [2, 7], + 10: [2, 7], + 11: [2, 7], + 12: [2, 7], + 13: [2, 7], + 14: [1, 27], + 15: [2, 7], + 16: [2, 7], + 17: [2, 7], + 18: [2, 7], + 19: [2, 7], + 20: [2, 7], + 21: [2, 7], + 22: [2, 7], + 23: [2, 7], + 25: [2, 7], + 27: [2, 7], + 33: [2, 7] + }, { + 5: [2, 9], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 9], + 13: [2, 9], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [2, 9], + 23: [2, 9], + 25: [2, 9], + 27: [2, 9], + 33: [1, 26] + }, { + 5: [2, 10], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [1, 16], + 13: [2, 10], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [2, 10], + 23: [2, 10], + 25: [2, 10], + 27: [2, 10], + 33: [1, 26] + }, { + 5: [2, 12], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 12], + 13: [2, 12], + 14: [1, 27], + 15: [2, 12], + 16: [2, 12], + 17: [2, 12], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [2, 12], + 23: [2, 12], + 25: [2, 12], + 27: [2, 12], + 33: [2, 12] + }, { + 5: [2, 13], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 13], + 13: [2, 13], + 14: [1, 27], + 15: [2, 13], + 16: [2, 13], + 17: [2, 13], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [2, 13], + 23: [2, 13], + 25: [2, 13], + 27: [2, 13], + 33: [2, 13] + }, { + 5: [2, 14], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 14], + 13: [2, 14], + 14: [1, 27], + 15: [2, 14], + 16: [2, 14], + 17: [2, 14], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [2, 14], + 23: [2, 14], + 25: [2, 14], + 27: [2, 14], + 33: [2, 14] + }, { + 5: [2, 15], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 15], + 13: [2, 15], + 14: [1, 27], + 15: [2, 15], + 16: [2, 15], + 17: [2, 15], + 18: [2, 15], + 19: [2, 15], + 20: [2, 15], + 21: [2, 15], + 22: [2, 15], + 23: [2, 15], + 25: [2, 15], + 27: [2, 15], + 33: [2, 15] + }, { + 5: [2, 16], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 16], + 13: [2, 16], + 14: [1, 27], + 15: [2, 16], + 16: [2, 16], + 17: [2, 16], + 18: [2, 16], + 19: [2, 16], + 20: [2, 16], + 21: [2, 16], + 22: [2, 16], + 23: [2, 16], + 25: [2, 16], + 27: [2, 16], + 33: [2, 16] + }, { + 5: [2, 17], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 17], + 13: [2, 17], + 14: [1, 27], + 15: [2, 17], + 16: [2, 17], + 17: [2, 17], + 18: [2, 17], + 19: [2, 17], + 20: [2, 17], + 21: [2, 17], + 22: [2, 17], + 23: [2, 17], + 25: [2, 17], + 27: [2, 17], + 33: [2, 17] + }, { + 5: [2, 18], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 18], + 13: [2, 18], + 14: [1, 27], + 15: [2, 18], + 16: [2, 18], + 17: [2, 18], + 18: [2, 18], + 19: [2, 18], + 20: [2, 18], + 21: [2, 18], + 22: [2, 18], + 23: [2, 18], + 25: [2, 18], + 27: [2, 18], + 33: [2, 18] + }, { + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [1, 16], + 13: [1, 17], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [1, 25], + 23: [1, 58], + 33: [1, 26] + }, { + 5: [2, 28], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [2, 28], + 13: [2, 28], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [2, 28], + 23: [2, 28], + 25: [2, 28], + 27: [2, 28], + 33: [2, 28] + }, { + 4: 59, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 5: [2, 20], + 6: [2, 20], + 7: [2, 20], + 8: [2, 20], + 9: [2, 20], + 10: [2, 20], + 11: [2, 20], + 12: [2, 20], + 13: [2, 20], + 14: [2, 20], + 15: [2, 20], + 16: [2, 20], + 17: [2, 20], + 18: [2, 20], + 19: [2, 20], + 20: [2, 20], + 21: [2, 20], + 22: [2, 20], + 23: [2, 20], + 25: [2, 20], + 27: [2, 20], + 33: [2, 20] + }, { + 4: 60, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 5: [2, 25], + 6: [2, 25], + 7: [2, 25], + 8: [2, 25], + 9: [2, 25], + 10: [2, 25], + 11: [2, 25], + 12: [2, 25], + 13: [2, 25], + 14: [2, 25], + 15: [2, 25], + 16: [2, 25], + 17: [2, 25], + 18: [2, 25], + 19: [2, 25], + 20: [2, 25], + 21: [2, 25], + 22: [2, 25], + 23: [2, 25], + 25: [2, 25], + 27: [2, 25], + 33: [2, 25] + }, { + 5: [2, 26], + 6: [2, 26], + 7: [2, 26], + 8: [2, 26], + 9: [2, 26], + 10: [2, 26], + 11: [2, 26], + 12: [2, 26], + 13: [2, 26], + 14: [2, 26], + 15: [2, 26], + 16: [2, 26], + 17: [2, 26], + 18: [2, 26], + 19: [2, 26], + 20: [2, 26], + 21: [2, 26], + 22: [2, 26], + 23: [2, 26], + 25: [2, 26], + 27: [2, 26], + 33: [2, 26] + }, { + 25: [1, 61], + 27: [1, 62] + }, { + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [1, 16], + 13: [1, 17], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [1, 25], + 25: [2, 30], + 27: [2, 30], + 33: [1, 26] + }, { + 4: 63, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 5: [2, 29], + 6: [2, 29], + 7: [2, 29], + 8: [2, 29], + 9: [2, 29], + 10: [2, 29], + 11: [2, 29], + 12: [2, 29], + 13: [2, 29], + 14: [2, 29], + 15: [2, 29], + 16: [2, 29], + 17: [2, 29], + 18: [2, 29], + 19: [2, 29], + 20: [2, 29], + 21: [2, 29], + 22: [2, 29], + 23: [2, 29], + 25: [2, 29], + 27: [2, 29], + 33: [2, 29] + }, { + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [1, 16], + 13: [1, 17], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [1, 25], + 25: [1, 64], + 27: [2, 35], + 33: [1, 26] + }, { + 5: [2, 27], + 6: [2, 27], + 7: [2, 27], + 8: [2, 27], + 9: [2, 27], + 10: [2, 27], + 11: [2, 27], + 12: [2, 27], + 13: [2, 27], + 14: [2, 27], + 15: [2, 27], + 16: [2, 27], + 17: [2, 27], + 18: [2, 27], + 19: [2, 27], + 20: [2, 27], + 21: [2, 27], + 22: [2, 27], + 23: [2, 27], + 25: [2, 27], + 27: [2, 27], + 33: [2, 27] + }, { + 4: 65, + 7: [1, 3], + 14: [1, 4], + 24: [1, 5], + 28: [1, 6], + 29: [1, 7], + 30: [1, 8] + }, { + 5: [2, 19], + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [1, 16], + 13: [1, 17], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [2, 19], + 23: [2, 19], + 25: [2, 19], + 27: [2, 19], + 33: [1, 26] + }, { + 5: [2, 21], + 6: [2, 21], + 7: [2, 21], + 8: [2, 21], + 9: [2, 21], + 10: [2, 21], + 11: [2, 21], + 12: [2, 21], + 13: [2, 21], + 14: [2, 21], + 15: [2, 21], + 16: [2, 21], + 17: [2, 21], + 18: [2, 21], + 19: [2, 21], + 20: [2, 21], + 21: [2, 21], + 22: [2, 21], + 23: [2, 21], + 25: [2, 21], + 27: [2, 21], + 33: [2, 21] + }, { + 6: [1, 10], + 7: [1, 11], + 8: [1, 12], + 9: [1, 13], + 10: [1, 14], + 11: [1, 15], + 12: [1, 16], + 13: [1, 17], + 14: [1, 27], + 15: [1, 18], + 16: [1, 19], + 17: [1, 20], + 18: [1, 21], + 19: [1, 22], + 20: [1, 23], + 21: [1, 24], + 22: [1, 25], + 25: [2, 31], + 27: [2, 31], + 33: [1, 26] + }], + defaultActions: { + 9: [2, 1] + }, + parseError: function parseError(str, hash) { + throw new Error(str); + }, + parse: function parse(input) { + var self = this, + stack = [0], + vstack = [null], // semantic value stack + lstack = [], // location stack + table = this.table, + yytext = '', + yylineno = 0, + yyleng = 0, + recovering = 0, + TERROR = 2, + EOF = 1; + + //this.reductionCount = this.shiftCount = 0; + + this.lexer.setInput(input); + this.lexer.yy = this.yy; + this.yy.lexer = this.lexer; + this.yy.parser = this; + if (typeof this.lexer.yylloc == 'undefined') + this.lexer.yylloc = {}; + var yyloc = this.lexer.yylloc; + lstack.push(yyloc); + + var ranges = this.lexer.options && this.lexer.options.ranges; + + if (typeof this.yy.parseError === 'function') + this.parseError = this.yy.parseError; + + function popStack(n) { + stack.length = stack.length - 2 * n; + vstack.length = vstack.length - n; + lstack.length = lstack.length - n; + } + + function lex() { + var token; + token = self.lexer.lex() || 1; // $end = 1 + // if token isn't its numeric value, convert + if (typeof token !== 'number') { + token = self.symbols_[token] || token; + } + return token; + } + + var symbol, preErrorSymbol, state, action, r, yyval = {}, + p, len, newState, expected; + while (true) { + // retreive state number from top of stack + state = stack[stack.length - 1]; + + // use default actions if available + if (this.defaultActions[state]) { + action = this.defaultActions[state]; + } else { + if (symbol === null || typeof symbol == 'undefined') { + symbol = lex(); + } + // read action for current state and first input + action = table[state] && table[state][symbol]; + } + + // handle parse error + if (typeof action === 'undefined' || !action.length || !action[0]) { + + var errStr = ''; + if (!recovering) { + // Report error + expected = []; + for (p in table[state]) + if (this.terminals_[p] && p > 2) { + expected.push("'" + this.terminals_[p] + "'"); + } + if (this.lexer.showPosition) { + errStr = 'Parse error on line ' + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(', ') + ", got '" + (this.terminals_[symbol] || symbol) + "'"; + } else { + errStr = 'Parse error on line ' + (yylineno + 1) + ": Unexpected " + + (symbol == 1 /*EOF*/ ? "end of input" : + ("'" + (this.terminals_[symbol] || symbol) + "'")); + } + this.parseError(errStr, { + text: this.lexer.match, + token: this.terminals_[symbol] || symbol, + line: this.lexer.yylineno, + loc: yyloc, + expected: expected + }); + } + + // just recovered from another error + if (recovering == 3) { + if (symbol == EOF) { + throw new Error(errStr || 'Parsing halted.'); + } + + // discard current lookahead and grab another + yyleng = this.lexer.yyleng; + yytext = this.lexer.yytext; + yylineno = this.lexer.yylineno; + yyloc = this.lexer.yylloc; + symbol = lex(); + } + + // try to recover from error + while (1) { + // check for error recovery rule in this state + if ((TERROR.toString()) in table[state]) { + break; + } + if (state === 0) { + throw new Error(errStr || 'Parsing halted.'); + } + popStack(1); + state = stack[stack.length - 1]; + } + + preErrorSymbol = symbol == 2 ? null : symbol; // save the lookahead token + symbol = TERROR; // insert generic error symbol as new lookahead + state = stack[stack.length - 1]; + action = table[state] && table[state][TERROR]; + recovering = 3; // allow 3 real symbols to be shifted before reporting a new error + } + + // this shouldn't happen, unless resolve defaults are off + if (action[0] instanceof Array && action.length > 1) { + throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol); + } + + switch (action[0]) { + + case 1: // shift + //this.shiftCount++; + + stack.push(symbol); + vstack.push(this.lexer.yytext); + lstack.push(this.lexer.yylloc); + stack.push(action[1]); // push state + symbol = null; + if (!preErrorSymbol) { // normal execution/no error + yyleng = this.lexer.yyleng; + yytext = this.lexer.yytext; + yylineno = this.lexer.yylineno; + yyloc = this.lexer.yylloc; + if (recovering > 0) + recovering--; + } else { // error just occurred, resume old lookahead f/ before error + symbol = preErrorSymbol; + preErrorSymbol = null; + } + break; + + case 2: // reduce + //this.reductionCount++; + + len = this.productions_[action[1]][1]; + + // perform semantic action + yyval.$ = vstack[vstack.length - len]; // default to $$ = $1 + // default location, uses first token for firsts, last for lasts + yyval._$ = { + first_line: lstack[lstack.length - (len || 1)].first_line, + last_line: lstack[lstack.length - 1].last_line, + first_column: lstack[lstack.length - (len || 1)].first_column, + last_column: lstack[lstack.length - 1].last_column + }; + if (ranges) { + yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]]; + } + r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack); + + if (typeof r !== 'undefined') { + return r; + } + + // pop off stack + if (len) { + stack = stack.slice(0, -1 * len * 2); + vstack = vstack.slice(0, -1 * len); + lstack = lstack.slice(0, -1 * len); + } + + stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce) + vstack.push(yyval.$); + lstack.push(yyval._$); + // goto new state = table[STATE][NONTERMINAL] + newState = table[stack[stack.length - 2]][stack[stack.length - 1]]; + stack.push(newState); + break; + + case 3: // accept + return true; + } + + } + + return true; + } + }; + var lexer = (function() { + var lexer = ({ + EOF: 1, + parseError: function parseError(str, hash) { + if (this.yy.parser) { + this.yy.parser.parseError(str, hash); + } else { + throw new Error(str); + } + }, + setInput: function(input) { + this._input = input; + this._more = this._less = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ''; + this.conditionStack = ['INITIAL']; + this.yylloc = { + first_line: 1, + first_column: 0, + last_line: 1, + last_column: 0 + }; + if (this.options.ranges) this.yylloc.range = [0, 0]; + this.offset = 0; + return this; + }, + input: function() { + var ch = this._input[0]; + this.yytext += ch; + this.yyleng++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + if (this.options.ranges) this.yylloc.range[1]++; + + this._input = this._input.slice(1); + return ch; + }, + unput: function(ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length - len - 1); + //this.yyleng -= len; + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length - 1); + this.matched = this.matched.substr(0, this.matched.length - 1); + + if (lines.length - 1) this.yylineno -= lines.length - 1; + var r = this.yylloc.range; + + this.yylloc = { + first_line: this.yylloc.first_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.first_column, + last_column: lines ? + (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len + }; + + if (this.options.ranges) { + this.yylloc.range = [r[0], r[0] + this.yyleng - len]; + } + return this; + }, + more: function() { + this._more = true; + return this; + }, + less: function(n) { + this.unput(this.match.slice(n)); + }, + pastInput: function() { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, ""); + }, + upcomingInput: function() { + var next = this.match; + if (next.length < 20) { + next += this._input.substr(0, 20 - next.length); + } + return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, ""); + }, + showPosition: function() { + var pre = this.pastInput(); + var c = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c + "^"; + }, + next: function() { + if (this.done) { + return this.EOF; + } + if (!this._input) this.done = true; + + var token, + match, + tempMatch, + index, + lines; + if (!this._more) { + this.yytext = ''; + this.match = ''; + } + var rules = this._currentRules(); + for (var i = 0; i < rules.length; i++) { + tempMatch = this._input.match(this.rules[rules[i]]); + if (tempMatch && (!match || tempMatch[0].length > match[0].length)) { + match = tempMatch; + index = i; + if (!this.options.flex) break; + } + } + if (match) { + lines = match[0].match(/(?:\r\n?|\n).*/g); + if (lines) this.yylineno += lines.length; + this.yylloc = { + first_line: this.yylloc.last_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.last_column, + last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length + }; + this.yytext += match[0]; + this.match += match[0]; + this.matches = match; + this.yyleng = this.yytext.length; + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + this._more = false; + this._input = this._input.slice(match[0].length); + this.matched += match[0]; + token = this.performAction.call(this, this.yy, this, rules[index], this.conditionStack[this.conditionStack.length - 1]); + if (this.done && this._input) this.done = false; + if (token) return token; + else return; + } + if (this._input === "") { + return this.EOF; + } else { + return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + }, + lex: function lex() { + var r = this.next(); + if (typeof r !== 'undefined') { + return r; + } else { + return this.lex(); + } + }, + begin: function begin(condition) { + this.conditionStack.push(condition); + }, + popState: function popState() { + return this.conditionStack.pop(); + }, + _currentRules: function _currentRules() { + return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; + }, + topState: function() { + return this.conditionStack[this.conditionStack.length - 2]; + }, + pushState: function begin(condition) { + this.begin(condition); + } + }); + lexer.options = {}; + lexer.performAction = function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) { + switch ($avoiding_name_collisions) { + case 0: + return "*"; + case 1: + return "/"; + case 2: + return "-"; + case 3: + return "+"; + case 4: + return "^"; + case 5: + return "%"; + case 6: + return "("; + case 7: + return ")"; + case 8: + return ","; + case 9: + return "=="; + case 10: + return "!="; + case 11: + return "~="; + case 12: + return ">="; + case 13: + return "<="; + case 14: + return "<"; + case 15: + return ">"; + case 16: + return "?"; + case 17: + return ":"; + case 18: + return "and"; + case 19: + return "or"; + case 20: + return "not"; + case 21: + return "in"; + case 22: + return "of"; + case 23: + break; + case 24: + return "NUMBER"; + case 25: + yy_.yytext = JSON.stringify(yy_.yytext); + return "SYMBOL"; + case 26: + yy_.yytext = yy.buildString("'", yy_.yytext); + return "SYMBOL"; + case 27: + yy_.yytext = yy.buildString('"', yy_.yytext); + return "STRING"; + case 28: + return "EOF"; + } + }; + lexer.rules = [/^(?:\*)/, /^(?:\/)/, /^(?:-)/, /^(?:\+)/, /^(?:\^)/, /^(?:\%)/, /^(?:\()/, /^(?:\))/, /^(?:\,)/, /^(?:==)/, /^(?:\!=)/, /^(?:\~=)/, /^(?:>=)/, /^(?:<=)/, /^(?:<)/, /^(?:>)/, /^(?:\?)/, /^(?:\:)/, /^(?:and[^\w])/, /^(?:or[^\w])/, /^(?:not[^\w])/, /^(?:in[^\w])/, /^(?:of[^\w])/, /^(?:\s+)/, /^(?:[0-9]+(?:\.[0-9]+)?\b)/, /^(?:[a-zA-Z$_][\.a-zA-Z0-9$_]*)/, /^(?:'(?:\\'|\\\\|[^'\\])*')/, /^(?:"(?:\\"|\\\\|[^"\\])*")/, /^(?:$)/]; + lexer.conditions = { + "INITIAL": { + "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], + "inclusive": true + } + }; + return lexer; + })(); + parser.lexer = lexer; + + function Parser() { + this.yy = {}; + } + Parser.prototype = parser; + parser.Parser = Parser; + return new Parser; +})(); +const parser = _parser; +_parser.Parser; + +// the parser is dynamically generated from generateParser.js at compile time + +// Shared utility functions +const std = +{ + + isfn: function(fns, funcName) { + return fns.hasOwnProperty(funcName) && typeof fns[funcName] === "function"; + }, + + unknown: function(funcName) { + throw ReferenceError('Unknown function: ' + funcName + '()'); + }, + + coerceArray: function(value) { + if (Array.isArray(value)) + return value; + else + return [value]; + }, + + coerceBoolean: function(value) { + if (typeof value === 'boolean') + return +value; + else + return value; + }, + + isSubset: function(a, b) { + const A = std.coerceArray(a); + const B = std.coerceArray(b); + return +A.every( val => B.includes(val) ); + }, + + buildString: function(quote, literal) + { + quote = String(quote)[0]; + literal = String(literal); + let built = ''; + + if (literal[0] !== quote || literal[literal.length-1] !== quote) + throw new Error(`Unexpected internal error: String literal doesn't begin/end with the right quotation mark.`); + + for (let i = 1; i < literal.length - 1; i++) + { + if (literal[i] === "\\") + { + i++; + if (i >= literal.length - 1) throw new Error(`Unexpected internal error: Unescaped backslash at the end of string literal.`); + + if (literal[i] === "\\") built += '\\'; + else if (literal[i] === quote) built += quote; + else throw new Error(`Unexpected internal error: Invalid escaped character in string literal: ${literal[i]}`); + } + else if (literal[i] === quote) + { + throw new Error(`Unexpected internal error: String literal contains unescaped quotation mark.`); + } + else + { + built += literal[i]; + } + } + + return JSON.stringify(built); + } +}; + +parser.yy = Object.create(std); + +/** + * Filtrex provides compileExpression() to compile user expressions to JavaScript. + * + * See https://github.com/joewalnes/filtrex for tutorial, reference and examples. + * MIT License. + * + * Includes Jison by Zachary Carter. See http://jison.org/ + * + * -Joe Walnes + */ +function compileExpression(expression, options) { + + // Check and coerce arguments + + if (arguments.length > 2) throw new TypeError('Too many arguments.'); + + options = typeof options === "object" ? options : {}; + let {extraFunctions, customProp} = options; + for (let key of Object.getOwnPropertyNames(options)) + { + if (key !== "extraFunctions" && key !== "customProp") throw new TypeError(`Unknown option: ${key}`); + } + + + + // Functions available to the expression + + let functions = { + abs: Math.abs, + ceil: Math.ceil, + floor: Math.floor, + log: Math.log, + max: Math.max, + min: Math.min, + random: Math.random, + round: Math.round, + sqrt: Math.sqrt, + }; + + if (extraFunctions) { + for (var name in extraFunctions) { + if (extraFunctions.hasOwnProperty(name)) { + functions[name] = extraFunctions[name]; + } + } + } + + + + // Compile the expression + + let tree = parser.parse(expression); + + let js = []; + js.push('return '); + function toJs(node) { + if (Array.isArray(node)) { + node.forEach(toJs); + } else { + js.push(node); + } + } + tree.forEach(toJs); + js.push(';'); + + + + // Metaprogramming functions + + function prop(name, obj) { + return Object.prototype.hasOwnProperty.call(obj||{}, name) ? obj[name] : undefined; + } + + function safeGetter(obj) { + return function get(name) { + return Object.prototype.hasOwnProperty.call(obj||{}, name) ? obj[name] : undefined; + } + } + + if (typeof customProp === 'function') { + prop = (name, obj) => std.coerceBoolean(customProp(name, safeGetter(obj), obj)); + } + + + + // Patch together and return + + let func = new Function('fns', 'std', 'prop', 'data', js.join('')); + + return function(data) { + try { + return func(functions, std, prop, data); + } + catch (e) + { + return e; + } + }; +} + +function applyRowFilters(filters, maxRows = Infinity, rows, columnVariables) { + const filteredRows = []; + const expressions = []; + for (const expression of filters) { + expressions.push(compileExpression(expression)); + } + let rowIndex = 1; + for (const row of rows) { + let passesTests = true; + if (rowIndex > maxRows) { + break; + } + for (const expression of expressions) { + if (!evaluateExpression(row, expression, columnVariables)) { + passesTests = false; + break; + } + } + if (passesTests) { + filteredRows.push(row); + } + rowIndex += 1; + } + return filteredRows; +} +function sortRows(sortExpressions, rows, columnVariables) { + const sortedRows = [...rows]; + const expressions = []; + for (const expression of sortExpressions) { + expressions.push(compileExpression(expression.expression)); + } + for (const expression of sortExpressions.reverse()) { + const sortExpression = compileExpression(expression.expression); + sortedRows.sort((a, b) => { + const aResult = evaluateExpression(a, sortExpression, columnVariables); + const bResult = evaluateExpression(b, sortExpression, columnVariables); + if (aResult < bResult) { + return expression.reversed ? 1 : -1; + } + else if (aResult > bResult) { + return expression.reversed ? -1 : 1; + } + else { + return 0; + } + }); + } + return sortedRows; +} +function evaluateExpression(row, expression, columnVariables) { + const extendedRow = Object.assign({}, row); + for (const columnVariable in columnVariables !== null && columnVariables !== void 0 ? columnVariables : {}) { + extendedRow[columnVariable] = row[columnVariables[columnVariable]]; + } + return expression(extendedRow); +} +function getCellDisplay(row, expression) { + if (typeof row[expression] === 'string') { + return row[expression]; + } + else { + return JSON.stringify(row[expression]); + } +} +function getColumnInfo(column) { + if (typeof column === 'string') { + return { + name: column, + expression: column + }; + } + else { + return column; + } +} +function getSortExpression(expression) { + if (typeof expression === 'string') { + return { + expression: expression, + reversed: false + }; + } + return expression; +} +function getArrayForArrayOrObject(value) { + if (value === null || value === undefined) { + return []; + } + if (Array.isArray(value)) { + return value; + } + return [value]; +} + +function getFilteredCsvData(csvSpec, csvData) { + var _a, _b, _c; + const _d = ((_a = csvSpec.csvOptions) !== null && _a !== void 0 ? _a : {}), { cast = true, cast_date = true, trim = true, columns = true, skip_empty_lines = true } = _d, extraOptions = __rest(_d, ["cast", "cast_date", "trim", "columns", "skip_empty_lines"]); + const csvOptions = Object.assign({ cast, trim, columns, skip_empty_lines }, extraOptions); + const parsedCsvData = sync(csvData, csvOptions); + const columnNames = []; + const rowColumns = Object.keys(parsedCsvData[0]); + try { + for (const column of (_b = csvSpec.columns) !== null && _b !== void 0 ? _b : rowColumns) { + const columnInfo = getColumnInfo(column); + // Do not attempt to compile/set the expression value + // if it already exists in our known row columns + if (rowColumns.indexOf(columnInfo.name) === -1) { + const expression = compileExpression(columnInfo.expression); + for (const row of parsedCsvData) { + row[columnInfo.name] = evaluateExpression(row, expression, csvSpec.columnVariables); + } + } + columnNames.push(columnInfo.name); + } + } + catch (e) { + throw new Error(`Error evaluating column expressions: ${e.message}.`); + } + let filteredSortedCsvData = []; + try { + filteredSortedCsvData = sortRows(getArrayForArrayOrObject(csvSpec.sortBy).map(getSortExpression), applyRowFilters(getArrayForArrayOrObject(csvSpec.filter), (_c = csvSpec.maxRows) !== null && _c !== void 0 ? _c : Infinity, parsedCsvData, csvSpec.columnVariables), csvSpec.columnVariables); + } + catch (e) { + throw new Error(`Error evaluating filter expressions: ${e.message}.`); + } + return { + columns: columnNames, + rows: filteredSortedCsvData + }; +} + +class TableRenderer extends obsidian.MarkdownRenderChild { + constructor(columns, rows, container) { + super(container); + this.columns = columns; + this.rows = rows; + this.container = container; + } + onload() { + return __awaiter(this, void 0, void 0, function* () { + yield this.render(); + }); + } + render() { + return __awaiter(this, void 0, void 0, function* () { + const tableEl = this.container.createEl('table'); + const theadEl = tableEl.createEl('thead'); + const headerEl = theadEl.createEl('tr'); + const tbodyEl = tableEl.createEl('tbody'); + const columnNames = []; + for (const column of this.columns) { + const columnInfo = getColumnInfo(column); + headerEl.createEl('th', { text: columnInfo.name }); + columnNames.push(columnInfo.name); + } + for (const row of this.rows) { + const trEl = tbodyEl.createEl('tr'); + for (const columnName of columnNames) { + trEl.createEl('td', { text: getCellDisplay(row, columnName) }); + } + } + }); + } +} +function renderErrorPre(container, error) { + let pre = container.createEl('pre', { cls: ["csv-table", "csv-error"] }); + pre.appendText(error); + return pre; +} + +class CsvTablePlugin extends obsidian.Plugin { + onload() { + return __awaiter(this, void 0, void 0, function* () { + this.registerMarkdownCodeBlockProcessor("csvtable", (csvSpecString, el, ctx) => __awaiter(this, void 0, void 0, function* () { + try { + let tableSpec = { + source: "", // Assert that this has a proper value below + }; + try { + tableSpec = obsidian.parseYaml(csvSpecString); + } + catch (e) { + throw new Error(`Could not parse CSV table spec: ${e.message}`); + } + if (!tableSpec.source) { + throw new Error("Parameter 'source' is required."); + } + const file = this.app.vault.getAbstractFileByPath(tableSpec.source); + if (!(file instanceof obsidian.TFile)) { + throw new Error(`CSV file '${tableSpec.source}' could not be found.`); + } + const csvData = yield this.app.vault.cachedRead(file); + console.log("Cached read success"); + const filteredCsvData = getFilteredCsvData(tableSpec, csvData); + ctx.addChild(new TableRenderer(filteredCsvData.columns, filteredCsvData.rows, el)); + } + catch (e) { + renderErrorPre(el, e.message); + return; + } + })); + }); + } +} + +module.exports = CsvTablePlugin; + + +/* nosourcemap */ \ No newline at end of file diff --git a/fforte_data/.obsidian/plugins/obsidian-csv-table/manifest.json b/fforte_data/.obsidian/plugins/obsidian-csv-table/manifest.json new file mode 100644 index 0000000..8a9a3d2 --- /dev/null +++ b/fforte_data/.obsidian/plugins/obsidian-csv-table/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-csv-table", + "name": "CSV Table", + "version": "1.2.0", + "minAppVersion": "0.11.10", + "description": "Render CSV data as a table within your notes.", + "author": "Adam Coddington ", + "authorUrl": "https://coddingtonbear.net/", + "isDesktopOnly": false +} diff --git a/fforte_data/.obsidian/plugins/obsidian-csv-table/styles.css b/fforte_data/.obsidian/plugins/obsidian-csv-table/styles.css new file mode 100644 index 0000000..bd94931 --- /dev/null +++ b/fforte_data/.obsidian/plugins/obsidian-csv-table/styles.css @@ -0,0 +1,8 @@ +.csv-table { + width: 100%; +} +.csv-error { + font-weight: 700; + padding: 10em; + border: 1px solid #f00; +} diff --git a/fforte_data/.obsidian/workspace.json b/fforte_data/.obsidian/workspace.json index 17c5eba..707900b 100644 --- a/fforte_data/.obsidian/workspace.json +++ b/fforte_data/.obsidian/workspace.json @@ -4,19 +4,17 @@ "type": "split", "children": [ { - "id": "cd5982f6654b4889", + "id": "02f726eda2793346", "type": "tabs", "children": [ { - "id": "a82c999e8a304258", + "id": "b96c0f812d470abc", "type": "leaf", "state": { - "type": "markdown", - "state": { - "file": "infos.md", - "mode": "source", - "source": false - } + "type": "empty", + "state": {}, + "icon": "lucide-file", + "title": "New tab" } } ] @@ -39,7 +37,9 @@ "type": "file-explorer", "state": { "sortOrder": "alphabetical" - } + }, + "icon": "lucide-folder-closed", + "title": "Files" } }, { @@ -54,7 +54,9 @@ "collapseAll": false, "extraContext": false, "sortOrder": "alphabetical" - } + }, + "icon": "lucide-search", + "title": "Search" } }, { @@ -62,7 +64,9 @@ "type": "leaf", "state": { "type": "bookmarks", - "state": {} + "state": {}, + "icon": "lucide-bookmark", + "title": "Bookmarks" } } ] @@ -93,7 +97,9 @@ "searchQuery": "", "backlinkCollapsed": false, "unlinkedCollapsed": true - } + }, + "icon": "links-coming-in", + "title": "Backlinks for infos" } }, { @@ -105,7 +111,9 @@ "file": "infos.md", "linksCollapsed": false, "unlinkedCollapsed": true - } + }, + "icon": "links-going-out", + "title": "Outgoing links from infos" } }, { @@ -116,7 +124,9 @@ "state": { "sortOrder": "frequency", "useHierarchy": true - } + }, + "icon": "lucide-tags", + "title": "Tags" } }, { @@ -126,7 +136,9 @@ "type": "outline", "state": { "file": "infos.md" - } + }, + "icon": "lucide-list", + "title": "Outline of infos" } } ] @@ -146,8 +158,11 @@ "command-palette:Open command palette": false } }, - "active": "a82c999e8a304258", + "active": "b96c0f812d470abc", "lastOpenFiles": [ + "exkursion_2024_11_15.csv", + "Lupus - Tabelle exkursion -.pdf", + "infos.md", "lu6758336o.tmp", "Unbenannt-1.jpg" ] diff --git a/fforte_data/Lupus - Tabelle exkursion -.pdf b/fforte_data/Lupus - Tabelle exkursion -.pdf new file mode 100644 index 0000000000000000000000000000000000000000..f325ec91d0d95a77022bfea32c506c84e466c3c6 GIT binary patch literal 207307 zcmV)~KzhF=P((&8F)lX>CAICY`wB5RI3O?}Z(?c+JUk#TOl59obZ8(kIXNIOAW{k- zARsSBX>4?5av(28Y+-a|L}g=dWMv9IJ_>Vma%Ev{3V59DeQ9$fx0T@c{1xdB8&TXH zmJ?@YDrP4_@+FOJ`H;Nc7|9{ok=k{|w%?rSxPBcw z+x7$giNo5BL+g9|lM?;8y(*Fb^0GC3SetPa#8wfe_X*DVo@6aq#=JO^m>gZQBI1cEKX#$11mi zME+C|qZB7FGT5|CiP_Jho=yb+^Z!hG1Z5|swQ+1cDHpJVCF4btG}jt8g89g1?N9${ zJJbIBUGoRDmFc1yYCIU}JsF9#Jh9SoVWybhdLNYuHM~@txH1_x zF_Nn*Q=R`{ofob}bMqW$`(Q1a8OUb?N%^!7z^ahwViL!*|knkpVP5prk?} z6`F)0b)=txlq?!(NW+D8DYs~sNL1S0soZ9db}P+7_N-VyW{I+5Nj{LbTaVtDzHjG0 za!Y@o;;7;8);`+ahj#uWllrmiw~z@c@+E(U-&lO;1xz&I57dTUfj|YP-%U|Z`77`m z?Z{-HvH})_I2yN%)FdhDCD0py&!%DwL^>lBp7RQ3F-C5K4t=&COVE z5L*XJNW&f?!I3dJT)M79@6(W(5$NP5j)j*|ARE=qB+QNCXB>jXJqT_f4ClCM2V2BU zJNR`hVx}D;mM_H#4Bpo$q%J53_AH^Mpv@jgjR66TGO4aSiWkby)2RlE<}H~p#n0Z( zI*UVq_RUgXzX+dU(!PoL#)Iiz(R8f(iS3RH<3Zy$w_coeA#JMhx$cEocmH6(_f_{$ z^GkJ)tDcDyM^N2+qzl#Kgz^7CBi&hYHJc@qH9%w&8Gw9-U06$Ke z!HU4aKrd>bxq_>HWYH{7OO1R*kQ6m!i2iQnp|5C7X25ftz63%t1H*m znMsQk3*;rQ2773`p_f7f0kJNWpA(UFU?NQyl|h%L3%XpJGT`^rNU(}f1Vy94xk!f9I)2b3Y#r!ZFh-;kq6%}dr-D(|wwi`{7m~VMUa3N@Q)-7g z%-)Q#8=!0358j#dBShb)0ZZ=V&XjMlnq=jlE!oHw|FVG|)T2IFai0|nW$>6Ir;(~} z)({S5RX%pKGbq*K7zHe}BMGv06eEH#MHRGG1!!lYFjR539)>=vG-WD@Dy-UJOrae~ z!@LVgmTaPmMeUGh0@|v-bTG_0_~pSb|5f}FiduF|bs_aRbr6xqVfVn45~dL}*_YRI zr$i1ee{lH^@Yx2A2gBvSeYFRyvVMT zXeJU4&9hx~y#SKwE?eQ8s3)iyFfv3@U7R; zN~>d`@UVn&Q2%7hI$jC*lc;*@WI9((#C9`d-o8}jXcix5IbY`>>)lF`a@S{vd_N# z#1?od&1}26E(3|>4aEoZe&~A4)oH*-}8Xv=n}ySjrDmOQn8ZWhp<@mh!{YQhu0O$`7@r64A<1g-Xgbjlxoo z-DsTcuz#nqqW1PkDwQm<6>{>HWM{f+*=^QF9O}WL9{elRgVHWLdKj9-=39B|Zb{y!OnyJF7v~F9 z4mIIW6aJNILZq$B+Sh*e-sOY89{lwcB6nvCKYhl2=7YN)-1R-WtIQyGeElMCadxf> zu(a=19Z@$lt0OWd`i|!q=~tdOb3BQ1Sxoeq$^4>VbgIzW$^4@AlljG15D|>Si-&lx zbF@+SIm2(={WJxL0&CbplRbxGG zXy@~WiHyz}!nX1v)MT$TMFat8TU2yYjG}C{x{S*YIgUimNFPB@kyQ;V%hA%>qb!~Z zoL80^Q?4vaA`wQ2X4n*~%D_(%D2Usp2tTGRMJ^`taz8<|rf3I%TdeN1 zl>mgHW+2PU5xmd|V4A#@Ku{9VnPvt}v5SBdkRet;ZcXilgSS4@TYJ^+bN4PEeCyy_rEitmeeN#hgKr&ttMaW0gU{cS zeDJV?hb=`f8H$o;*)bks*uleI#>03^u?sx39ef?Xrmyhs%}~?yyhZsz^k#`Cw0L^w z;q;a=2u(+0@Bv<#v*A91yHXQ18^aoIp7eajr%nd%p;_daO&(9Ej>5i))qMoJC@!S0 zH5vHBgEhIBVM22taUV`|DMLM53EmG5R_u8#=e#&V)RUEhDJCm>oviHZ$;#+FPq)Zq zrC{=8rC@a4(Z#j#Ax~CD*UMo7NfKN+Q5pO?hL{P$Zz(Rsy#KL5FmHYYNT(*5NQPZ8 zO(`rC)0D!d5@Ru@qMt6RquA3L;rzt@4eBvYCod=0T8mA1W9z|&uV_Qo|GgW~=SEz( z#2QYe0Y(|c|HK*=Jiji-^_Lk*HR1d z{Ts(?i(uEYvIz9^ON&s7Y!T|+R~Eq}Y7v66MUWs{gubaoVBxp0Na~iW1^iH3#1ExK zP>#wXNUF355GyTGh+eJ-6&88y2Jx)#{Tsw3-E%jHA1qf5QlbkSm~yJ}9eId`g3&=( zDhDru*D;!^LzAF7GQ^SyLHy0dp*olyQHKn#NQbr}l3`bj)3Q2rm0#FYVl2i~^ksEa zD?FmPXKwgD_};?(n_rBI;J^1F=|7WVv|bcJ%oXj5&paPak~xJ^FOkz1`KC z=OnS%yWzfyeCYagWvsb6mtEO3)=cNUaxeinqxc?n5{`|2tM;V56FAWRq2YxRs6 z!>5bNnQneIaA`BDbn+yzUAXBP$N)LL?b*h~$uCZJSyo%QB_mgA+CZZ0HU}X$Hl*aHw=4o4m6=J&xL453?Rz)=#rs{e0 z2I*`7<~ti;+JEN7!rlF6k-g|ctCfl#Gh?i^Sbuvnu0z#}&U7B%oE#iw$x)`txSXZh zmaRc`&ZaDf0=cS3l8|~7N|F>iCP2_~$ArMmX{E4y#0GXu2u9iyrm0|Govz8s$*qyt zR9mjS-#B+CTAN=y* zmoMd)r6r!bugjE*G0?_)`PJHEYqQkX%cE&_e01eMtZMK%3u(3 zB!fkp6IgN#CeRcJEkrTG29r=WD>*YwGpXq;pZNB+SO4GG(8q>AEZU3Hh4AXY>@9E`7rRJ~NKk(h`9R@pyj`LsH z1wZ?`>60#TniGClZ`Pqp{{iQz641}DFPop99e2l|)UVH))n8AJzW!_Ti?7M10XnVY zUYkOUhO6R%iDANmO%&=d$QL@~^TkPs#(V$|Y_XlESgQgwY? zJ^h%J^z4cn)4#D3X_hPMH><17#nsWVGj`R!d$YN2zdX6ze9|8MgzCm*w)8& z62|O2wc}tKy|0Z zp6j6#lj!<+)ic^g{`TUw{Y|QU8)z!)N|`I*-y3gwiVP|mE`%4NSrv`ac93d^Xs)=$ z-CNI{&>`&UgnFC8S1h^^Ub`WL@!AccZb^nEA~GiTj+6ve)n3{Mem;@4d{AR^w6;e9B5X_jn;fY9-2+BmLi= z%0PL?A zVHmnG#dNatc-Fwi5IcH0FH`@R<#fE2L@!1N!SZDY`V3|96?)$=(S^%O^UMY9@`j4( zJr=HO;YBJNhIX8^@p~a|qLb6I&`f9st8efzubHrLyeyPJzNf?nPJ&>pvM zE;cvq#m#N{0k}>3#m`fo^x?aU+uIGG+AqKO+2>!k-@4wX+&6#QTpTqCeR{sRzWPZy z?uK0no~{x%v_WlO*Pqg+{(g_@PYK8AW<*z>gV)y=W2zjqskF<{K^mU}X#d{K6y@#9Rcpo^z1^#F!8PrjdGszl+&;lJ#t&E52sx z{Ws+wt;VG(2VIlS;RWP+3GV&|B2e`JdHk-X9An$_n{u1F@K~6e7gp58wryttY(9+} z2AnRiINfdcP2|GDWi+g`;71(qlY;;hjiag^I{8AqJ%xKbPl1p)h<;@2Dj`_#mLkwW zw0QIoV0-K$c?baXiHH<1W@HGRBtyiV5^}L=OA&Eeu@d=gqAdofnzc=UD zMK9~==y8<8g+*7&3`S zqhu|F;ZwZm6z-GDDLk$cGlix=sBsh%_&FFR!F*07LF>$_CjK=jR`rmY?nC zeOMbqy|X=j{^ggyXj8h?xJD>%tQO!JY`t4!kDagCBd52LR9y`rj|9jB1I>C zNsJx}=Q0=}OmKc>vK9k3K+i?wC?s^fbWEa?LZ1ci5NR-+Qxcg-K1NzL9%%)gU)^&5ZzA_ndM;g2U zA~iH688{K=L}7B*Hd8?(C`nHjKg{xzFAZa7#@Nn(Wbv1ov-QgV{Sr(SQAp6qX}XGO zKhRMg5n)b%tHU1c@3CNQfk$Z~DR|M0TFg8_r2!*XO-=cl3ayZts6Z(^Sp~~xyhnnm z&lM7=7uGyiK6$=C;K6QKvNpG0)*D-xPd(O0PhZ4U3MXY16^s8bRi8>NF3a))DicYU z1bH!+deDXG!TYsGr3~v}aH!xTPB}&cb2QXfig=!<#6SZXG}pGNP;guo67{$WR$^d% z3|ci<;X*G>#gDzqX_~g=h_apC(^^GiGiDf76zL1_wc=A<6% z?K{o;)P|%`{-U9^z~w}hW(GOyJmqph4;dq-uQa2io~)T=Lq9;Ash1YwsNc?*pL=rU zw-a$5V4NwVI}DxmD*oV$DEOE-`asW`y7+Wk;tN*Fsgifd_L9mB_sI5Qe)ym+zmghx zn*ZssoGI*&<;#hxI>AYD@awy(1pA078$b#inZN5QsSO12;Tg3kkG1rK>m6`K< z=jr!s&^C^D&Y0Qh;-8<~-d#>l7Oy@jujR0ju3E8a(4vO`swuwNj3_REVU9>OuBUtX z1(RxAYB*v3S1AmpwFz8w(`k?Ewxs7*m_|KV=`mK)#R0i`$iZ%kNA3!@ zqwETw)ycdoyfdj@!-|@HfxY3bALw|JM+J3@Vc?t9*PH9>i`#eC7bzM*#HqtU%Z%V< z0Bg`nzxVD0PUXhQ$)Z@^Dlp(&xp7_FhkF9be&>JO0mWnjD9?2=Ht*;rSHbW>#V%vu z45FmKi`NKlzy)MUR+4z5L^39or!>7~np`TucsiRo^D+_!1hqtj0hM6_q*y?*tpX64 ztF0zszLg%!HBki}!Jla7Gdb3nh?2Qrff*Ms9=y?-^5TAonF|&ht$%xW^Zm))=DPiS zbMa&8wd%e|KgKF{DW3q(#Q%f!Ej;S z8^fzEBiuCQ;Odxxmrp$07g}IavlntMTr9~b%WEtHCND8O+T;T-fC;$%qG_78#_G)u}xw)S8(7svK2Ww?0;dv6%#`|_zNsl||{k4XB*n;GmsG=MTsCLeFsJXoN?)?qe4n}&Ak@A3Tz*m>x2;z`xmwU=+4W9HW>t%7t z!*Bld`#*ive!KeBufIKNk6SoxQC#nUS33aC$n6evvjg7oP~7go7dyZm4?p?IPwLS4 z>=XL%Oy{_30w~4f*H^YnJ3mFefmf0F?_wWWKhVL^v0MB3Z2ry61DEpR+|xPsh#gA?6$m^*BT2 zJ)|9)s_$AlW$7Orb|7a8c3|M%(&Wv2lBjLlbum4Z3QTf2i`SsjisbI;8A^(Kx1j_F zm%#YRR89Z9yDedpt})9(BK7Xn8%mYP;mU~VU@pnw zbQFjL6P)-cdTL>@`N(4Kq3Jl!1)x#ytsESl{aP@a&rYTTo zawROh#~E_PaYdzZT4g8|4RCfH~V>N;M+GR-)%0II|XIpL^!e9+w>oG4?e?l*V_|5i?_I@R9qZJ-DlewzMN~| zk*;*F$uJhfKhE1fc*>FT(pmB3!gj~q4qu&|p5JV)UZS@J^XvnkSDcoZwfmc-n(wbS z7dJbX+~7PPoo_IsEO+jiXvegv)B#I1OV@evEyej%r0u9R6TL&LQRp3x=V9E1GzODC ze5%*7?}oj4|JAoH#_R3H(Xn6E7ir|%%(D3PlJ2hC%yx+HyNUSsE#Erh>(fld8t$KP zefARny*WCLus(Yn-3m_eA@U0UeS=H48~oksQZIe=>1!h&{OVKu@O}E%@T%|y;@=hI zHvIbqR)Sp`9d#6DW=FODeB}Do=Jse<-A*qM8wWf-iC5r@Z7s|krxsi z3@TGV7Ytng;_%gD!8n|Sq!h4R!El4Im&S>j#Pg$K`}Pwn-D6{@Lb7p`W3ET zKiKK9c6#viK4p}fO}8Cwd&=OkZiZ=UsZcRnycXC@q;zcq@XF+_lO zsu<&f=M=d7$6$jn&$UX5*eeae4CD|(GY(AC>34oQMOot{Tg1Ryp@PAC7&(Otwt)4) zH^OAzwmA`TuQXY>sX}nYVWy*8$S#ODS4Mo)d7)+BTo|kDXTS8s%zqr0Se^Un`6U0Ny4eL| z%Vt#N@q@x+as2SHo$Y&lX6m<39H=~`qD>ULEZ55^k%iwS)=T-?0|zYQx=-T*xRKHs ziXhMq4|ww;-Dm_DxNo<_q@j!JH5U$81ZCEPq`gloZ5FlQBFe z+0!-9uD|y+YSZJzzpnQ@I)~?nV0BC|@VX8RJK%*yddyT{d~=+k2A)U6nP$m8&|-wp zXE5dHdm1=uf&3&KazUGseQJLojX4f@TpxA={!RPC-9L`T)w}EYo#*g~jxXz^k1!3Cb??)NfgWrp;WLa+Jrk58 zjb>-nY5}TzpTmoM3czlj9&@a$A79-+dsxZ!o3`(x4Y^Pl$Z zX(LtK>)`)58j>Hkw*BtnrgiA-COLcEkQWp(Bdz|jSX9zk}0~MP%vA>#4%&w5Qn4~yuzuy?s_?dAxTWHL^5U!E)(VJ)wNiH=_CmAW^^l6 zQWW+rB$IKRf{7L|GeVfm+cqZ>_Jyd3H&F?l2$`x$mM5KwWV=KFHqAWzp+?B)@W2J^ zda|V>7PscS#AP|KBXvhfh0FhN*Z%VETj%=PH-~@^P<{~S#C;d0(7NwJWrr>P>PD{^ z_*+_+;nF!Zi8^PA0Y6fr>}OhR;he%-cFu%J0X{ot(%e{jd;zm_5~gxaNhHoGM8!EL zDnaL*sY#u47}$8JyFhP>KI%bu%AY(Z?DNt1Z{Y>J)Z4JLtintGn7SM%Z|c2Ysgp19 z2wk+pSG(@n{{@3@U%FP`S6WP70hdgTHoI0oRJLKbaxF=cU8}&LYY90w$S3<^mC=TS*e(TnLI}wK8brG||u5vaYA$;63aBJ6P&*mXa=#kA`gp zZ4*?9ho5+YtWX)_`)-`uGA)z#xBB(EJ=>KGT*ypD(Bm|p$6X3Sx7*;X?n?i z*$UwF+^}SJa&25DCz$h^#-lbZ0U|>Qd5pxZUTBO>J@y>sj*5 zI)$nklek3ZCegag|A>urm7SgvttU#|(a2IU`-0tA8tbz3ge8F$Wi__Bqk| zUgwII5~TjMTbsvB&Oy$5yVs_BK)_Dpo9-#y>zr@-Gy**LwY!h%J1^N`){FqHF`8NH zM<$nROhx12JEP}}O^+Y!XT6X-vyRbf&ZHas+D^OIW&VddQ*EcG95a|Gbva;jG5g}3 zD~)wodcu;xig9xlJRxAu+-_Q@?iFC-ZCQXEuxBjK9rAom=i$+(=5ZnVs1~0Su=jb) z)K#B$$l%_pG}YwO1NQwYV`-lguWE1ub((g4PLpUq+*)- ze;gg#&ULHb!~WHGKODu?=IZvyjH}}#>sOy%-EJFeF?yY{%%)tB^}=D2Cq z(V6wwr~e|XI(8xb7x~i4zujGbw|R4M_4e-S$gSSyb;dA+e)ab5c5#gnPVH9rE=~6k z%1RgBETOA%bSHzX*}0h4^IXJx^E2G%^}nX|zAqR5d{0}3gpe;5{`^p``T1(S4|he# zx}6Zoa9-%c@{2V-;Z6v-*tDgH)#4tCd{(O~=$ztvp634O760t5hs83d_jGahLe0Fq zxJ|Y3cC%ex=DfFl$YLAa-69Kvba#s^8zxAX6j>1&?(-6)m`OjfhLw;n)*i`BQoOI0 z9MMd&bSP%Za9(Q^GbzMo5<+OELd0r)v8*4euh**}AG_wCy>+ozVckt zjTP#Ltgqg;wn~PQWiv9AEUJN_WWh}grEs4Y=+sd1Q4A%7e6cd;hhkCAR||3;_mk4v znvhUXSK`=63NT|r1eiwZjhd*Eb+ShKdUfNY)%deFI^r{4c*%tCt?cZbUU2!V%^BVh ze(#fV1MZXFy~z)j0Q=~BU~ZVOX5n>=&T9V4)}|KPn@rKdZMwi|9Puc&!oBX@BTQ0O zl52$fGlfLYz9@zCa%nG|$?6A_Q-~Nup(zkrib~3S2npr0mIQb4&7?akaP))|NNm^M zM#TX8@H}6)wtcTqmX=@(r-+-Jx%Y*f9vL3jsSizG`0X>!R=`ZQDNtOlWLK_gzH9kJ zmNSlvsY*X?-{y~6E6?7)=|(w1=zHG38E5+iU~mLgGga=vj2;54!~baPMB53raKY)- z+f942O@pS@c5~gndH4O@Wg4knY_4xNS1po(p<5bU;n=Ed5iQ-?<0D;R&B6YjT}PJp zg+!Uu@X;!?)iV`>Nq_M-ZUw>LUiY2=$j2JC3gIpjA<_pXV)ZvYs7Bja`2KEqQLX1~ zGMvHooP-G$un=KPR0assWOjw9h%ynK9%h@W<7`>C@Bg~cgJtfqjP5FuclKgv>5iaB zJek+YR-##Bn`dc;mzbt0+x3CpikyWBxgB`>x6RcJRQ0gpqYKH~#(p$-%Xw#E{$-%Z zae4C3b^Gbn4=3l__J_Nhb^CU624Up<`pBh0C0s=HbqXFwezjSS7XA2yXwi?QPcl^a zBxA_c#_W?rSNY`Fl|DIkwNH*F`y~G^e3CGgPf7;yI3ZZT6Q3NqnNJG4>gZ$blMGir zsp>de*6k}si-TpBEu+x_o-cq2r$J6H?>z(raSZlXq|`8uNn`VVKnMmO2I&MmFp}Y3 zP7^9-r1MyseKhPIM4Q1=j6rzrP!n`CS49*AZmL2giLk*WkVWMkbyA9QHc^J#IYM~( zgPlK8l|KKLLtf&ISRZzDByaEutD->)9Wii^BL`S;?u6F>*V>Mx_Fy93#VYbG#qe+6S|NTPRqh|k^vzzcz#3L@M&3rr;$607u>w6m;Y#W z`s@iUXoete?{njCR(O{9;;MRH*t!Uh(_ybrt5lbNP{nH6thK4 z>~k7;0gzG*cq=f04Z=JX%_-y|=WT%*>H1-&2{6*+QW?gh<;0n!NHpN7<2dF#u*utI zk^(9hh{$|xC5bT3^i-}|6*TQR(avYjKDFLctaIqZW`~nJV0Hozwd0J(^8CaY>CU%D z%}=CE4&|gFDnZ34m@zcCjdUHlL-hc?;YHpNT>>_arH{?3D7#*~9#&A>xk zC0M{hM25x6fDVG0TOC-lAQQo>F|aD*Y+19fI6HB$%aUEDa}z0!Om!YumAOwWRT8eUnnI)^n?t2{n{f*r}1}(qfSbn$9PsZ}cKJ`vwusz*R z1FN2%)-1R~@SArxcUN#XlUscxEes8v(G>Gz z(LiFbNt3Qy%FhMZZXql7d1J(fA_DXz*RD71@X+Na%nH4zR5&yopw)hUsN+QrwVM>P zmP;z%HF|S$)UWW$!>cxR?%%?)^yOwd*|{6I8o-;~Vc*uo&||GOc)@=P-Q>V@Aj;5) z-HiB~zt9defh`Pg7;4Zy+x*dWeAyopf`>$;2uBZ+Q0Yz{KY+Jj0zFz1=?jxk5OWb= zJ3eGf0uW>#ZsGQMx7tpIm=fBZ zQ+>VKYz5p(3yp?zGF_26&(hBmsvX zRQ(_U#}EAOmDc}(AB@TYf-o9CQU}`iIpX+Hrl>hV7?lDcV2-qmII&}bgM5}-H-#%s zQA8ZcBfLKORjW}NU(6Gd;YZzn6Cd#Nnjw<= z;up#&gU*Y2k4u#$avw1aI~%Moj>78d44kL^;qJQq3|`sU&}FaZS9}greCY3~OBRv` zVZ~@kR{B@`hs%f8s_;ZkupISLy#_BJUfZAk)24pm&)+qF*c&U;Pq#l-etvRt{WsXq zJo9x4m9S}aY3TGCp)$e@Ob(O?7GV-$4S61~OII+gLsNvvK5$+JBQ8lRDVQhKau6tD zBfw1=8Y#8JIH9F*;Or7Oxo8cO!m37El%o>53W%(Rmkft{JmU%B@B{dW#vIa3j!NVs zIcoWJC}NuDyZ;4dFHr=$Nrodoe8%K@dNHZfuOY|3hTtOnQEColLQ25Ec{wz4!4e6D zQ;no3M=5j}^j^qA%3*QOcRVh62u~cgKW%@V;@hP<#pJ#d53g6j_%*^C$TS19G=(@x z2M$z@VpH&i8)yPgb`nxZhqMD8pMZk;DR^*?4!aBB6xN}lgK;Q8I%4xR}kfsgIa7a z`{Ofjaz!p+a66`CN`j6q(-cr%mnKAJY@3q^>q1aOtJQ(+^Gro&wU!6!+r7?as)M~A zZ?ES+UT9MH5d+D-dj6Y>&D#ylf%?^Uv#`?UXc<4-4i86Gwo4e;lO*yb5Kcp@`~+8~ z(ZHnE)5(^Vc3BuR75ufSBBLjYFNdv6_hAjNlMLz6~@%C zu+2 zZ|=5qO-;2^!HjrYPv!<@GD-|=t&MBjD*`~c`$|M+xU^SJBKFD{Qm)eEeY{$z+ADLW z@1NlIhunz)*!fISKrt5~N^5Bn=3EJ~WD{lJrq!8(c%I16`$?}_xenHPw6&gn78u%D zy3})D8+Y^W>gM($jqYZHx&XeGx_Ya z@+!uxz44i#qxBRml3*O{316Hf4b^;1qoj-hRZ=D*nqjFpj3K_ZIRUe+1X--9DsZqj zQx7ac=w$4?>lo-2sU%wpE*^brItlyL?|<>d&p!XfAIqs&c?-A?jvq$e*>U7&Z~Gwk z)W|cuf{}N6`w;Ni=nVI5e#N)x;iYJN_?NTuYPQg4Fu&rP6VMaAOrR+cSb#!Yykr;l zYW|Cte6vVr6Q$Vot33<;F{n4U9%BkIA++-!Rny_tk$fC}m?1ef-A4v2cZH9K*)G<{ z$7EVkUmp2>bwYEFZ%%GE7sp@19?a__)&2%y5HsfTNluiMAjjm_B5he3zJ(N-#xNW{s0<5d&(` zOi5>yf@l_?1Xsjl&bB#`FfTMkxQRk2z)qF){F9?Taf~NN_jpkI!`<7>JJ`tb=4x}> zmU~!eTOa>1bi)$=VW+XchaX~~QZooM2QHY@y^C(LPUUHxs%$#AQbi~W*0xdsQTiXT zc&7H~*xJ<{T%&${Wcw97y$rx9^h>@!at3-!wp&#`54RZNej(&L(y?6Q>)83aU5y@J zHwa$hYU=xBc$;82CK&{gno-)lLKz^$S*n=EC#tj=n*Y@o zM6`WsF%i6J25ZHWD%evM1WE%o(n;A|CGxfaY!o6bpc@|Gq|lTS!i%POEG_wnnUEg1 zcBgiBfLjz2-v+L|g&G32#>tq;NvOhK2KL2JNpMt)?KTv4J4&Vd)dl^zf4Kzb>CbTmaY_G|iug4_f1*EsB;;2|4T4_~_&fUe<&(!> z5w2B5JDDy;+j)@w^5iJ4{&Dg4EK@hh}gnu+)jw`LmQJu9hR zL{n;feviV-A4EHt=U(%CwQr;f&mB{PVXTvAHyx?|`@grv75qLg$=cb9-jNlSOPG)N1)NANJ+%Vw8hCFjnDIz4C! z3F=EwG6YCMeY&^L8vPS@-0In|q$(g}v+oMzn-Y7j5cAZxOBhXJ1LEok%$52FQ83UF zW$aD4tkCMD^MO34`vD07VfD9Z`ldo^*hV?^0zvHU8+b{Uh*>E%<9d%DCqM9#yIaiq zBpfQDDN6y`@O8Xd#lEXtisS?}HV!%MSeHg{xM;?EkH$qc82x9?TKc0fL=wU*laIaW zC-RQI%=ZTF``nxaF&>~b<>lTJ7=(X`VCwopo}i_Lm(8?}ALmUx(_8d=I#a1n)cin- zV-TjICU2GEC#ZeEgyFK_#G}S=+5}BO4Do&?I9hw3K_c4=+7@{tZYjdG&fz1IpsU&g z=XBQ>Z&2}L-1(-81JgkJv$Y;(NI!ToDF1Y=B;a5nxU$-5@uU4)hwYXzqt3`4&3fL@ zQcaEBd7_fYjL4v2yrDHlfLmisX~HDiJHu6Xh;nlrb8Sy#;MP!bQoKs;C*1>Fo$p7hKBh#r5!8Wv1uHq6w}-C=yg0FlH!dt>M&Ao z*M2ithUYU0&Tiq+!DUDgc`b!JZxw9cs~9A_tfatzchE;B@sMVPFiy$dZA(9D11x%o z?A{u>E&Qa{H~KE~0Lx+U25%RH(cGtp+@_%1Z-x*LP-+7M^uS~v%fQtJkgiGvX|d_R zr>S`Rs=t%-%#-~1URyJQryVMm?in>wm_97=&I2Avx!@q;C1Ek%$W(B)2XtuB6cK9W zT)ViQ=+K(%V{*Ij6vDnl%!LE8Fgc7iD?2l74{)J}U^FEhwkM~l*K3vn2|u-b=6eG1 z(mH~=VIAw`Q>8m{Uvx|J_|V50V5+oZ?p73=MakVzXoLXl!oK5O2Wxyccd7x655lhc zWh%*yF=7yNw=EyHyE-1|EfU@$cS}FJXNx@#SGvQknB_TUL!alh!Q=aR-4!dVk&>k` zEV82Q*`c3b#_-a8x=fJ?yZIFz%cB+XSqgSaW5p*91P!jcw>WAHKi=@_Qf{oU7hYIT zW2*U#X#p`z4Mn!bFM9NR3e$6b4*M0}M!{M$B5fBb^YWy$+ZgR5$~S7MM|G$!jknd< zw0Po#)IDO{@?X0n-J~w;?P$&Ztf5c3(K%7X(T-kpbWF9${#H9jUP}!7W-}A~H~c|x zLk;(%mwRz)j%F0!RC6QqR4WgMZ!hP|!;d~^9GR2}@{NX;t^Ic zxpPORI)$@3j#Kq>Y-~+z=>hif=X?jZWB&0f@(c`et!@r4O7gK}%`eKZIR1;+MiguM zY)B*9h!FBCvNs50Bi7z)S1tJ!vq!2S2XqJR=(Hsx}Ri)~a~?$f5V0T6{8U09!dt zyi8D}(a=x^>~Id7tkGR6>5Y~|P0lzy@}4g@j{&5P#^Ldq;HOBf3r6Fz^Zm(zen=|B+hhyjj?XYK)489&6M-C$AIdSGZi&C8c35 ze)>ZnH4(c%pofmFdyP+5&&X6qW#E5SMs6WpH*iLE)T)UWfEX2qymbiSCF2k_p^CSU zK#*%I_y|5CiGCSMO-w*wuBv7nLu)}2qP=XhRcqFeXQu_W-v})~dBTS?r3QaB2yJzE zh+ruOmV;(9Bsnb_thXywMMopKb2E_#d-UtQyw5FtnNL7|vUafEMF} zJWjv&kDD~#Z_=HT^v6xw)0?NX{Be`+^yX>T{57)|{1sPL zy84cGDLXT5d?2X5_kc?BnTFNrO#x$dUG39bvie$p!dc9;rwx8>eO)~(d`6nn7PqO9 zsfDDOx+dT)JlfX!n%Yk+)a_0m377zCYnhpTFRg`dW%2CnRgd+pEXA}fxJ`}COii=_ zgT{Qh;8vHisGAse<3_VEJ{P2y9+V6*t6vPcfk;GB8ST78%3g3p-=PZ(4uVAavu&Hv z!mY{~qu3*B<~w&>M&=HV(v7paNlP53z>6U$->xtyZhwZZc7eulo%6|_e}c%{N#FM2 z5GwD9IDA1%K6Yd6A!sK@ggOfcCM=vAzFTbqoCJJ}*GCN=-{yR5@DfCtPmmto4;oPp zebWhR>`-v19|-2Tzj@dru~?YBbX#t$&J~<*y7_ssu4SXAIV^&o-n}-c`h^(#ck})Q ze&2eFU=V!Td3+}!NwN(FgSOt=DH1F6;S|>M_}=8zXcq4)rH7MQj90RQnD<>kua%hM z;w*bl5=z>eG9-k9jo#@p$t&M!F|V^xb)aPWo>6fE8%cTEgc@1&3tyF3dLLGsb&BCI zyPBL;wzwd+PKR*D=7`?23Yq%r@mor z$H0xjGIm&J46k}|h_20Gtc2E5)Gy*fAKtEGsh90NR&rlOF(gdKhB~Hw4sYV2xIe+R zWVd~0$@1i$lcxyBb9I^t9~(Gx1ZbSj64D($lm~7#+BDoe_mE$E^E|kR8es~|A+~Eh6Bl`>XwE8(4HX~0L=3m za++$Gkcn!a!9c)bK|rr!$afllFofn0elUIq`k(l5E@yrN`Zu8eA%OlqC$9qZl@s_> zzyFH>eF{T~OFHWR3h3`NUIFOu=D?o-eQpl?2J~-0|3d)%eNJ8lXduupnV6?$_`eCz zXIA;&($L>&yaLeQy^B8q`rMTN4d~y1{)Ye>=o>FKa93?7;iA`2J7)tofP5yR9Y_|f6*)S_bo0_1hNj=;)qPh z{VFHldaIdj|4c-bNm_LKtuhK zzWRk8<*xzwSxDf|`ujfu97sBVB{UZR4z$!SapXJ;@EhR20sfB!IM9>)8Q@n==U?by z{u+Rvg$Vv8z%TeL7XZ%u-8=c&reXetS%T~0$j@o6-zNJ1CKLU1hW@ZeFPZ2-;9t~N z%>M$9^OA{v3d+B0qMuUvXA_ckXMRu2TAwruv1x=5*C1IX8CWe{r|w~v%diC)46$t);?W7{4=y!exZMP zT@(4T);SKb(+fV(0kvd1a84Uf{{>V7z9&GO-EeLb04;@6+Hv3(KrtK z4%N+6M986K1foZXl>AmcZy`(AZj>|%Nd(_|qda}L)4;Oy;X5isc(427{5t_q)0CZy zgh%oG4`092_f(fq(+gO@e2N~~%?+6d!&6tQ(syP1bZS*t9_ z;44yAz6wA12E9zf2aF8 z&+K2o6pI-PzQ{{xpYxlAMOf)J_n3sZEu!OFRQxS9b!+y^wC2smwAZlRgZTq1uTlzT z5AC;LK2;%A%B02(X`}PG-gzyYPNtCj;$Kz+3{t{X{+q$0K74r0W7xH(srKf z#CpL7M7;$3eQE(@F3!X-rR-Ys{lb})_{+9PKF8&*>GL57@y=Ud@FoE4gQKP&b zQ>{6UX%<9`5m_>KUQS1&4OzW^u16bPNwLuj*f7>N$*giW(mbUR<7KzeYO!3l6eRyK z7`PW*$rXM*3(#8yV1|L2`rNNS-9_{#3*lP5*k1&i%W~u_5^;rz;16~W6a<3iO3$9< zf=5Kde9n`rj#;PuzZ|m;VC&!6eDaHUa@k1uEl7R~lIs^FK;QUhK>}3D7ql-O^|kuU zzX&v!1<6_5vGgGF*i=M{qFO5u8D^L)2FehZS{uFd~e*M{zV zVerou3DD)aWRd(E;sKWh$yrS2?^+~4;sH$g!?mG1EkyAri{x5!J@m9^OAvm;Zd zj#{_b9j`^3@0j)tu{rL!dhZ}r<{Vda6V+9p;P1#Zx!G>_EeG_veexX>f-9C)fFnZ@ zL^LX3M68~Ja8q-u>{Ae@NxdmvIJ|;T$E1Vr3;$HkyfPp8ZSd%1@B?}4yH!p34_I)l z=Lj+l+j7Ze`0C#&nbc2j+dFyd3V%o}Rc`e&4_6S%3<((}sX)tdp^Gz6K->`S?)i{B zo>8iu;`G!|o1hGJJQ-^Qf%je~=9D}=GK?{F@6*_+H!=!BE*s2MG5{L@)FUT zP9m$imLA<*c4ZdN_oPW;!$jc9mYp{(`M1m3IwRI<_R$N4n&)JUY)%$tmcJz^(D|=< zt9puOs6@p^W3Q|=6f>eVRgJtLL?3pe%)uHH&=qYb4QtqbT50aL*PA-7bSEsNAjrs` zDAQiq=vH=aCfKmsu^N4NQ?#@}|90%|tv2*2*{#WA-J^0DmKNer8{ z<0Y(>$J1)wwhXq*yR2D<<>uxQ!{acJ59g8?8fo!fSPy3KA%{;(Y#-=mbmPH4Nu-(T z)uYG$%9a(|-`izQh$LQ_Kg#G*L6uj?ze(+)Qc-p?dgt41(HO*P!fDPIV{3wqT^BUvOpMKfT7kAOy^_p(7I`Fq;h!$z6bv}$Y3Er}&P0yR3U=5|h6k7D~?bNfz zeG;^|rCOIWzo_+fK%dcH@R4Y}TNOiQ0EE{3r3@054bKgFR7YonV%xlS1Pc1U`5;g>MHfxqL5HS^H85LXCZ-<<*{^ zJoZyuUQU6_Y({P=_MGia5U3QR!D?%t)}z%<^eEka810YC*5)Zrve1+|r`(v|LYL{d zuXq$ciuaPJdy#Ic*NXM_t-}?sgAxm8Pl91pOTGsce@;D;o-aNTUgkYhXAzRXBZAy(D(BLhb*lG6JkjXSBUDXoWC-=*1;mlV; z?}t(UN`lB!Gx zR9`M)8#TGLkv6Swl&3fWk)oL>SI>vH&x8bib>VsY`32hhKM z+QOp_m77bNy~T&De^e@$E@e3WT|_mMC=^MM;w~-nJXnZTmbc6t99Bjg)HPRQ3+2ai zZo;SzZ4POMoRUtGpmd^`tHw@7$y)(Ae88APzBOBgO;ItklO}Aq#>LqjJp;#Em-G1e zfz3O-cW*tl0hbl9s|>Sdk*VGRkn~we~iY6QWSX z$Mmh6@)_0gE%LIh6X6ISd0MCWT8w%^QGp^?M?t2h$HL(V)R+wQB~KzvU5*|-GJ>%_ zXm!7_LYqluS+7Q+Fhx_6t>dw4x;{XU_(fM^tsg%06^f9TSJ9v-T1F7CCh=`t+CD(6 z9@uw4ttSvdIBYg}UeuF6WR$RA#!Mg(s_d}=+2!4y^>)Z zfXd=RWnvtV3YRjJA?y?OGna>~VKfBaFhIbkCdtrN-v%?RuYWI0{S`OA_1%~lMd6%E z3%R!_71A6z-q_a-Rj0@A9pX1azhq%fjaNT=yjJA`#xUN%{pYYW-DxQ-pufYyM1LNG zJ*`spCqv~d5qwP^&#y96E?aMBq4bN^+e!`SO%M=}k8!)A#t2MtfIolyOmu*d-MA`H zO?STf4nR8HIg{wFTDe1aRx|7$?kfL|Fa3@${o?r2`P!GC-9q4+uZwQsS!un0IA|^j zma{^ES5$IA{ZH|wQ#yh2_K!gIRaro~vyy`UaGv}YB)QJVO&AUO-IUvzcOYRmm+iv(zn{Uk`P60TUT6s*==frNrZjV53x_Nl&@gzR}C~yN`=j23m09S-e!C|kDqp0I(lr$s9etdPZ z78+{k$xhY5nn>*1Z^thN6q5)DGfH$!Gn07;cT^(sE4v~TZj0#@Xphha^}ByCV*H?D z*p>#-lb;|5Sb7>1NiBx@Tqnk|GM^TXB*U0jnxUp4=>IQ`)ngLQ_lLV#kS-1N}n#&VdqD)fzR6PrA3zz_14xwhiOs~O=KZMqN}TQ#rGaL^=hk%`*%iY1VFbW zvs4~5%&+j!Mzgf)SlSWhC^0&`6(B+xj%BjSkt}%1XIKnbug3E5cw&A4kQ!s7j6xUE z6;?@_(w}4w6Ig5DfIh;^);JQzL?|CqzkG&ArdI=R%v7lI@+OS*W71lTZ}zIF~3d*RX^( zkr&4?A-*I41myiPzH}UVDMUAA?3kSt*gq3zZF-_qLqZ+95L78{QnFY@WvI9=egdJOGRxl(|VJnXl+ow~b%O3aU;j6Zxr%Ay=^&iU} zkXq6M^789VufXoO?;uU6j#B{IkO(dsrSr&L+>ZB4AnVgKkWzmMV;Y+sR= z5}zlPf4kFJ+1kH3Yn;`&x^r*@8YEpkzEpgtXt-swzg5Mmc1_}D<|{gK-e(7Hkv=Z~ z8yuWuO$*sxjp7DL@8)%z^sHr*C4GCOLAPL;-V8@xkUzDa%{!H56z?csnQ>%5ub9Oc zB$?4`^eufQ2Jl(Y;n$s70~gvr`+B&Pqm)!Wj2KH9fVJ z6vnuSBlvOV;F31$OPXy6bDB&1EYbowg$WYkU2Pn-pXN50+7#U5@N-&vt*3D!#CTF9 zMjq1sHd8Q3W73f0P@5AeAoH+}D9>E`Hr4K+p1ibIBUPdGjs$dgq7h}sOh^l^HiCqM zx%%ubv%lA&Rj!W1XMmzQ-u|pZUsVw%oYW<(k|t$Ah4jkAv+qbHMMn}HkQ~JQo;)<- zE73IXL5}c!>)xejbk2d@!h1c*>cfZ@6cr)gYGiV52jBbYI9ZS}j zGShbqH5hOxxP^+?lyP$a8rj~pNhqp%e15w$%KDj6(N|={WbLA~h|$F}O&-SV64tHX zFBSRBgrPn{Kb#z$H*ZizO1gVlSSKPmos2OuL5@6`HzO^yM!T4tip;mypok_M29#G` z1zl2Gj6&|VoF+w$HfJ8mTW}3}mGaN&e3C4A zcW?E04Sw6#-Z&_Ss5PoHQzZ_iA zJ%^q<@-M0SW+so8?aB_yMprl{sPBxX($s`~8NIWzF>72o=(G%)hb53 z+^+lbbM>qF^$L5+lUFA(mgsO?jZw23@390n9~UK!EX+$=DLJ`K+pei?J3Oh(f^W1L z(xQzPspeK6!;8k8gyZeRCkwE?rHt38DP0LZy&m;K5;Rn3-Z#WPqgxW7TJXI}5DGK( z0>d5iBn;_?apYG&ZtO>fY-shmf83dW)F|Y2Psz6fF3E!TO}gv1c_(Sq7PD_qDUMs& zR|%5~OC}i@&jE6FxYeHk@^9NBcZT!7y&(PcgsvY#<3gPO^eC!7@#I>UXZ)g&YW+?8I&OZx{(-ZxE78-Qd zS|0Eh@#MGA_$@T9QD~gb`5*YWBs73Y^-DtIT8q>CB7j^H8fPbWUUFLgLL!jvLZOoj zmd5G9pMMe>|Ati-zlFwcp>dr;11KDRwlsil%O#=lZ}8tQ3yuFz+uTkM0=~l102cPR z#FJ}XQSnpwhlb(oIN4v2^czw@b)76m``m`D+vL}5bfb=16&$>5)~Mqu8^>f$R=)k{#KDgT12AfLSf_4A%#y zjZ;md!O2P8i|~9z7CRB4Lr)tthx1W$3o+;E$Z6#=`!NP25`2^?f?Dtv>_HR5vhijt zZyPfqNf(20P#FgF!5Y%Y;XVou9%!sIsuFuh8q$pBuQDsKm@4;4cbB69RRHy2OJ{xw z{%vv>{+G@@79JY=@9bsh+G*@>7ZrRFD3kl7kC$li$uywP;ud8Iexsk_uutX4SdYgJ4+SPl9#IraCE2Vcx| z<>x7p54y263CBBHoA;J4eOvw>N9Rj%uI@h?EHhMAjtYSbpFtRW(U(-zFtx|UTpmdl z6BXH3A!17Hh#5em5P<9XLS;T%KPDE{vZB-MLwRAST%Tqjid%j}GoJL4>^NKHq~61D zVH$;}gwvh5{rk?+Ik>Zu>DZ{u{hKQ$nk4DgVyuQr<44&3&QEn;VOHvNt0vZTR4g^f zFLFtSV93qTq}DN1O3_8`j!xRLMs~zfE40lQEZPoKnno18$*xD+#2%@GK^jY2Mek^*pRIprs!k6O=cpO4e0OVz17&1I$pMK zuR=neH^LY?4cTXVu;(s=dOvZS8K?S#g^`AKsN4%k^c9yqmr*do+`4A`zF~ws5Dz)m z$K+gh(c=)|#JnMi>%dSoKwW{?egB{vws;fR(Fu=(~I}?2D(A#5>rit|3Rc2 zo)LLifOcl?T(!8L!p!nK8F_7kg|QlBNNIA|&4S)lc3~Y$S_RCan7M)`?wnEDfc)(G zkO@L`BJy0pBC58-RkMfDZS$g-S#w*1Ru7lQn5ugO;mDsm_#~~)zRCzNE#ZVpRP7$T z&zCd!wO?<2dPgzQK5AStR6*0Ovcb>`T|G{A-%6ir4z^YG@R=fw4L>P0t{yPJCb|63rq7u<@`$6YTtBBt&7|X zVc(NVcg*gCpT89+c7`66Wy9B5ScP8&0g>I1Uspq&+-P-zb&JR{KgC z_R`Pmz&S#$>2CG5nd;5ZN@#XB;wCl&+K~2@`Dc}`okIOvhl5t6X{(>!5ZeyiBv<^t zWvrKnwkRb@;I=>C%nXAuRfuqECqJ{6VpcA?f=ENxCUjD6K2AW|20;GGKFn@N7#5U+ zJ)p>_4=5^B2nbE8Kdj^8hi&mq;GwpEy%km~L5zQ}=Mgf^5}H+SXIn$$`&^A0^Wy?< zJ14#`$Man?!wj_0tXZovxxVR*&G-0w)DbXX9S-ccq0h>qB4x-Z{QS(zM#)>uqo5OS zBdN)kL<)!S7O88iQxx6^3p&+3S)m~CuPs<*WIA&Dlc>}bZ=NiVd&bqBqQWF>m-!fuJkK;)XJq1yfFD`L5HmsS-57UTdAmOqbYUa}0X zHE{W>EQ8DD(tqApb_*I%&;0afT?ZfW%5)Ijg~%1%d9<63{)!_>=;*JtWb7FsKk5UV zHU8UX6U}9J6F@rXl~kWn^21>K<7_!vATKV?3i@k}O#K?7zvnW~&T2m!xS!(t|1}$c z)k6U+fAUnBaIl0V7(^U%S?v1j-fD7uSde`dJ+MK%CehhKyM9RpAkTw=qu#+?60 z#~!HCE)q>k2b2bvi2fHSx(j1}I&gng-!lLO-9=Cw~$5z{!4*4Rj1ZO>l_~XY%CxH(f(X!T-^*2dcD-MAM%8JQs;( z{1+&?i(`Lgp8U13Kc($w)knt&)C8B<@Go$8{vy#pm3C?DuXJn~{{@Qf!q}e<++UUX zr?mZf?17r#(%4_CyF*KTy0Z%C;Qx|C5}tjgLHK}wgG-$1kaGU{YVG!T^XthkR`#6#4937j6hxaeNr)=$CJ+E376P;tt#{{vQy&8<5RW^m{@6B zn3)=>TWRB4Sv=D|z4=(*%2G_*g4@*C%+y5N#0vlH9E%^J1I9DU=MuWqxS$2Jw~DOds-DyJxvn`hgv7*jnFr8fSI>bHR3J=AE1kAPvs`oM&dydcE4`~TyV0} zcC+55JG>v0R1~E54pmvv;iN7;a+E!!#tkvpRFI4Ywpf>R(dv(4c5mXB9*Sx2$LpTd ze9+!jP6a0w1w4S2f&yeAPF!v@4;{aa|H{mLLf|c!#M1vfG`oBs)P#yZ{VTKBZKam- zJ9u}!F^GFD(9<(_?|o*C>*a#L0F4hV;LTR+U_kC|oKrPKy+eDi=&vJrr(!r4nS`RWqj> znRZ;y{nD6RvWxs6b1(2CEbhc$s=0eS2G)~7eslL2#&nU%9ysAU-C|u(q4e^$Qg(9; zY7y=Wkc7w;NhO%DuOJ-4|xMbr=&?&6|_61 zVPuIbxM+KFMl#2{>BWOZNRSUM!>L!z#0zE(9m^lppcsLA{?b(Z7dW$*=G}i8wqOJr zESIG^P}W}}`d?tiT$Ji(#^+yT!&Qb29n)1&Tc+!EW@#8NiS-}N|90f|@-mqf1yL*LYi!xg{){A4rd9v zpwjaXVH{mcwuU5bM7x?#i?V9ErmW0<&34e@$DA5zCvUZ7MY+$L@*ZhU_X3hZZ)uIg@C{c z9UY2hB_XUJuyfzR-woXJ5sw}0W2a2A>GUxOSQlObyUKXyBNL5g_|jM8O3{2nFQaos z$mf}*W)-4Sn;h8+Sm~CC8H5*HVJjS!J&KT7xUn@mk;D-|@T}>n*NWUn7LrN}c-Yo7 z2IGYzkC(jmo)73nVhU66EV&ebS6h|OoKjxKD6f~2!u9VeT zziS+20HGBU9J3qKY0)5A!ivBf%idiC&h}&@m4xL*6|-v>Q3yw7ry_oY4)U9pu<9cbV}emqQ@UcU(yY%^(eJ%8Bw)tY#7f+LKYd~_y^^Xm z{DthH@NFYn&f3t43G~9|HWnBo(rnC?iF?EEpVzF-Wd@HW@fu}+IgT}4r(9)SrdD4~ zi8cO0PlW$&`aRO^srDD6UkjGG*c9qv-jZs>F0D&r$L!R)Nj9~X5wrIu+Bw;Vs=nc9y z2CSR6HlgYW@irlLfl@sZ7&JSdO$`+uXOd3hA8w-6bO#jC-Rtw(cwspYUWZg(SQ3Zxy3d$GZ~I zAX_B5YEz1s%S&0%(mvW5C1i+hmLd*yww+Ej_@K7K0C{%_IiZ?rLQ3oYO_mH;**3YZa}@ln4B(t zkfN`+v+qkhuM>{a0McF(*!X()CTu(O^R17Coa)u=?u{$!=HyM`=H>apZYcLagt3F~ zKT;nimprVtX#PyU_T# z1}54ElPP6XrF-*2a=50g>tr;O)el9Yo?t?Ky5n=-$}TFf!B+brl#a*Za+D_r1j(Cm zVI-5@boXK1){dqC5Vi?*^jisa+`TW`OF*Maf#$B&M-u{P&cN* zUNx7|wGeC*QGO|TsBINWrv?{R=d)jhj^ygaV&tpGVyyU_ZvGaDwlCa}JBi}U=u+iz zB+R2E6v>Z)waILRyj?5e6U)4>U$)-PY(UUK9)l3XD$p4E)FLTAgdoB#vtuM+ozAS@ z+Id19I)=(Z^7+{lIbMmdt#GHurCKBL`OqrVGR5Ysfl=s)OXljZnW*1#j6f=Rq~6)x zYP8;p=SrS{8Vw{Egg3_?&O5@>P?R@%zqjc{yF8AVNIMN=KwLDE5%=&G$CHngbOGs0nwO9m#53!Qy zO=0!u2A!lB`2)Y&Sa+&-;vr*(TKGLq@n+qEOfL^X2(+D9)#%#9ZiD&6r|ya;LO42m z!=SM>W{Z)EAp=#EC_|tGaf{}G#stYSW?S4 z4eLj~(2>pQ5w;L*ez{DDluxN}c$w9S4eJJO!7cY@W`#TYuw&mw3%I>lAHcD-c=)oV zx;L@LaW1-p_4y_fCQ9}W&4ej(;p~hN7A%TLZIMOvtJhgyne95>E8mv;*z3AzrZ_Je zK1X%;9dj=~VQs%Eu05EFgJL~)N#BetV?|fZ*1LyGN*axGMrjBkoUtZUhbfJmqKCE6 zy)f%v@ANdkH@0gkeymSh9BP(l|Fj$_(zRo>9tIrM1&bCT%+l|Um;k3NmQ5%U4{sd1 zmZ|l2Kc`AZa(cZbG z@+{tiP{b2+qZ}ecl;OFX5DHZft%sy3(aq1FiuD|f6w?tRP3JCVozz`dnuJuT*{AWJ zH$NMYC^28hNV%dsbiwtM0@cYb5x#>cPE_vKj=ITR(yYs3E zQYcy9rD97ovOywaVBCdZ=G%U;fVLm!Nq;P^e#U^Mu2bg$-OFh9>9B%%1&l$Xc*qk& zlZH78iZ)$^Oy3V|JPS%&`dkI()_YZqu~6mcn|-i>-Xd609MhznPR*#$gPO}dFgUwh zW0v^>-LadI-k&!#NuS1GMHa?P6FKtXiZk1fSSkh$+048pCYr-!wRP^9K&~D{fqWJ_)Z9cZw`yR;|~-b z;T&n@VpEb(H#zGT7iXJrE~aH!ujuKYr;glolrQdMG-fxTT)lv)EMAh$zKq5WjPIL?<^|SRYMa?v?>zBqW;> zgks*l4u4UX?_dIDciIq6hRd8$@@nAdz@aW&wGr=-+={ucqS4D#1C+$(73|zvLN?Ac z@RV2%ztZeTXSHwqNyA3F%h0BJ?0I-u+JbEjYnbERHwP(Si#=CByx>v|bxV2*(~+CZ@bDhiX07go%2U z((J7T{AEsAgV-!BM;$gI^hq6W+QW<$u<(lPuggI2OTzz3}OEua_91Gny zkp||v2x`3Vp%6V5cG?5w?v#2{cMI%ASWdNeC?*n`-)$j(r>c@tG|Uct0xFl*#x*L9 zg>+xuER8(#(gaFRQ#$&#k2Yf_I1T8fqil|)Y8>1lQthS;a6MUk0fC!k!4@%7N8UGVstCgDj? zKu=r{7yecw5g95tMDDFPYhva*D;<4-Mfh*rxoPBgY2>P!3HRU$Rt)(5p}N~6K*tvr0qtiJn{z81YPR(oM8d3b&-b%;2; z7L~Ba1iUdeFO`B+D4ixs$JV4}heR?6POO+6LRf$~jTAc^UCJltkKIAHsV!+C!g?pW z^OYfW1lecP1cHg4zZ6YHd@aMZz?&KYL6;OGLH}A@%b8NNP%U&rUrve_zkom1HVWJw z1rPdR`~t}hw8v%`M}y6}_kPwq-kHh7?;eTtg+#4_C|-T*$y4AQ9w83iLf z%{6EHq}^^tz4?A}V866?1184f-dcPV9)Fx#Ohed4E;D%?jt3Ret*!UoBHn&#_gU=a z?VH{c`7$5E#TbTKQAe8tZa2{cC-Q;ukr<58qNnpkgePj16m)<=rIBokLn10MHfU0i zuHdZuPv;nuo`4EgRk5l_--Xpw0+FWV+lMqT=Xon0Csd25B;$48ESWb+m(OKIs}^xPzTM_a6>{cn`oJLWLM`$A7tml(lLA?;Nn#AtUW0E= zqD1I|sJZY%y`gS`1j1`NvPs=6Z5;G_TRDpEBjzH)D6i@*mCs!&x@g1&22ux?odml$a}^EG5itbZn`>O=b*pM#MPi=)G) zu26%rr6ro^PX>wLw6~|U?w034i1xMJ7{A%mlJ^BgbyU*L9-3JM!K6}UPbn773DMMBD$(xJhgI(@(nR4leUJr&dKbG0MtLK21SKo>Ufx$b z>Cp-bo(V40TB#spCtx6eT#$I(QDPlBBGRla^QMV&Q?R&WOWKZ8QF*W|NR<`(NJFf& zusexkq33{0Fa-g3aiA;!nFJ>Yx$7=T76nQZO0z+1PkZ!^z@zFH$eoqk6+$2@Lj*}G zaqmxPPrxASKnkxin1JyyfQ>;*&2nxq(J=uN;}-*GOlN`M@Ak;QJpXq}$689#m%B*i*_sOnE=Joj^tqZg84vC%4?G8# zFUR!_Ok8rol`o$Q_=45TkZvf20a;Folx0ZxCfg+8*)0B|#RHjcXzd5e@J>8m1l71e zaiOWA@gcHJI(0As5$f@?G!2HhWr^HGzgZx5$7)xH;4?= zDE46=ZZ?7~!K!S(Y?0yEynW8L$5$imi4%r@#oSg?|bDk9Eipg z$Zwl7l6i%VeI$P#t@cLk%d{{eGYtJJy)jKxI6i+Q+Z%J70Z&{!%-seO#MD0tRLm2; zo%;m;{KW@BL~9=u+?_68OQ_5l_4{~BnMPQ7My^a4^U>bn=6%~mQPx~bkD70~$}TJ= ztD2SEs8PV~pYXn4V~-t59ST85)b?r25@xr}%K5W9S6QkQz8IgM=a4NcOq(E4^}~B2 zsg1H+OJhd49x#5`>T$t+PyKT}@|=~4-|iCjK(V-kzi~fM@w;W2$z8^dtpPWU9?mZ8 zpYI{y6%{>2mHaGc?%2aj7$!sv_%BdVFNj3AfXdBGJ;>5+dx>bE2VT*3vCAXmqld@A zcxo6$t4en`8_Pfja(%`Jl_ckY&mdZFAN#%^K3+s?WU>%@l|p=L4K197_x-KcGVYOx zCi`vl_qtxb!zrDePuu9-fWHC4W_i`D1

utfdDWY5!x^(lG%u4HsuE^R+IPpg-F* z2b2ytMH!z*<7|y2{JB9^6ehAuze_?shL)R8_6fPCD{ZM5 zg04X*7IrFv0~WqE(QFGK3F*O1$ujc_TXk6us&R{?C$X7xm7HoU(AFHmWo4Bd*aY55ESFy&z#5nrV;0 z=uWukVGo_Lwpch6(-9A!5+hbUxFaukE%>>;L5%^k7sQw)uk&tVmp1KgIj<<_#VeD1 z^(y8X&Vf`=vmHC$=+9AoPT5cwgwo~gG(OKV?>HZ|`yT(RDsqr%)l*K%q4|UN!`2JF zkf*4qG8m5BE3*xQhg7sG= zt0Nms-4DxAV-+s2aRpNev}R{B3KIi?bR8^k8PUHBIzDm3F+@C8sR-ooI27p(%!6*T zn5d(+6z;fxaf9Z$^!-G1n2ZpwufrtYUo^S?tQI|&1O$|#!q5oHkH-crmk?Y`P`|8HL*$k8Fvd z`DN-uhs+uk#r4qWlqmJB){joQdx@&#@4$7bxoSa~#ct%4+}4FaDttH6v&;Tc?dyTu z#2fQs>9vf+$~TW}7LDhX**KYRyP1Fx1U7-N2oXcf@KlqDKhY;|T%XDwv~6eKos-vm z9c3r-!mmi_ITi+q+@h<)NcH+VC^$kDx9Gd5V4Lz`H%Z(RWgp=!+25FDL{oU^ta*=W zH4SP$BiBf+nKlTr!i@kG%won@dpnmO!|{VlnTU($Mmr^WrE@#~faa$V~2y-FUhN&YIsU58Yz+YwFaGS?Z{E(oim;-E#JQHk|4^wWbqL}zMtsr zvv5*MrsZ%_k$1z(fy$Y~ajntTM9cD43W4aIl6-u4$Qu1RT49|O8Y%vtVBiXxcU|y| z7(DufdGVAg+@4M9Yp3zg+KNdI@*IKGTv;R6cc`N2fbs0f~AyN z-&k%`6kHOs5hb51|)28=5^Lot>n4U!5}98|4}TNDq(=>YFVjEG%_);q4{3(*8&5*XvE#1i~tN!GYj0VFl6_Nu5s%U%cxP z#h@^nCxzQ2UV!(ii-Nyfe&=YX5L1cRNZ|GD^|T*O%Y@t=y*%*Xj}hkjRM{YoELST| zpf?I&<{wTfEd%iOC01Umllm7~`QK2Sr}N<_!}(ls`m#>{N5v_OQ|NKb4MhuO`OS#N zsPqx4|L~^)C4fm zjMyH?|KaT&gJfZsbkVkLcdxc>+qP}2wr$(CZQHhcwQajspEa}Zw`aZ+`^G&Hv+s$j zsEDelAN6MDn|PkgEWN!SpO0bUWUuB#&)ut>it58ZKqD#5mHVqIfRci9^#Q2^hdGLP zV@vg_*$6pg)SYk^_D7j7w=D-Rq6de~WJEZlm@!la9Al{C7VBQgTr5wz+#IeGU9CGN7a4{FCfBndz+%E;*Sr4QTw=TW{0)Xoi3=hc zfGI{>DyNMfNzHRv2hwxtko43}COD7B)mthV%WMVXM^lVq4IXzT&-JR-M??`!`2;B~ z&+?%i-H)zYW#nC!1?c5uc{>N{NZ;^yH4S;oW?(E?jN%8dlu`!U(+&(PDyY*Of)!`- zSnq;ucV&x1m`}><@FrREi`x^Nd>8a=rE$=O0#qI#jpsuQR~6|NHl|OF)ZHM}|)-yqZ!o^CdOEMf%-{m1UTW}GxyM3m;^5w&_2YFd!$QjuZHDzI6 zGm%Z9m+{-hbv<)@EET_m1rQY}Ew3g_I@;{*Gffb5jx%JyN~cumhhari)$z>-lmcjr650beRt!3y3Ctg7c5tD;Zc9CHEO-5B#COhrIfSGdufJ6OwR$YuD2#86_JkD_? z#OUV5YBSETVUS*4;63vzJ#4wCNyNv17hv;48Z-9$&luM*n_X7OoMPl=zk11ilJ0p> zB~hTCGrv!WtCrV~L_&4(!u|;zYgMnmPqKz7_=6zVWg}jZ-Q(!-ZU$WbXJY;^GTX@g zevYMm57y)dSv8YJ9hJtPuZh*FtHDP)^@D$=TEd!P>|72kSe-}*@f`cS@w;47KA)=e zw-62B$^BwH|CLL#H+HXuJ{3gedPx{BmvRN3DkcpkRwtGYJtXMa`jdBLdvkq*@Vlue4x!sr8OkHL!6U-}y-VkN;@9)T&)({APJ_OX%^)=N^V>UF zPuQbMqb{=*E1rvL47*tY^(x>VoezVI$bzNFtkqs{+1cK*fI z{v&oW{j=s|{|m4Bo5TONw$uLI;WPdJQgeQM`{wn(?2PUH+05eWQwW$gvGW=w09Z&V zrV>+uqry>5(-_RdTif}F>?+F;v za1H_3JTe)8mprn-Pobr8*4^2{%Em&cgTT9LbF`)NiuXKSqujh0;G(t8M<~r8MVfvu0#uq?DwjrInSE9H0F@$ZKk9 zs#HRfhlh~RV1Y=aYL)u@+FF{&`|j@U=i7r?jrRJ=N{WXEJ5ERuIvSdbvvY9{UbH9` zB_$fQ`fcspk9#hc%QRl^_Z%M2{X4gavpLmTT^(g*kV#uxTRDbbCl53_9ZfYgKc_QT zHd}2&g^Lp40C$=!l!%e))v1}xW>7$Wm^i6ZWYx#L7&O1`O^wga!h--QG!GlrS4!I2 z*yyy`<*#1IaJx7;9UdLoYdDN>U6!~bvO)Dv)OF10fxpAAToFZKZ{dZ(+-8h z4PZih-Z)z<<-vou{)`tE>aDGXr`?%9k&uiX-j5F}Fh5+KF?r+Ss*Lr~Rn>$-^{MLU z=xu$0hx64LKfQ)|Cywc~-x59Toiki!cR?E6;`}u4mwJ=qeVXyS>1p-#olh7}sW;lA z6Txs%KHD8_dS$?A-F>weNdq0EenlNXLi=n}y_1kMlZcti=|?DCTx%jY&0}Jxq@&n= z8qyx+aaAw<bTC$<5=?|0lNB@~aDh|RKZAi2wJln-UN;FB!Mr=tpCwuiJ(4k2 z`Ud*zw@km>~=5cOt zfW1+t)-eH$O^S=6o8Bbi^VLZ4IZ#nHCMl7||0GJ={h9iu?Lwz%WjZZkVeu@*WHLXb zK=SC*!*ystNCz#_>Dvig(96`cmb?#tUYwY7O9Ze#)RZveRsh=j3ADnOOPc(K-w4xEmKinRLe7IGTwX7_Dq9nP>+as z7N_&v39!*uS36u_ey%IkV?i?10xK>zDfXrQvK9rt`zG&igGeNh}{Yx9iS9QCXfxb~YUanv-Vu z4`N9&jIccFz`KD>Ti?*Qn`TCFr@2j!vqE5Wcx4x5l{dbxBKJF_`La}sz(+Hy(0X9| zvJ`V>UiSOt{Y}MVg6Nuy+6z<>lPi*8?m3HYaZKY3Sq!chZ-DvdWSd}x_?=u^^atPi_2_f0xyMsW=Q?GHbR#`18LV_H6 z8+p~9bKi|-Xh!FH<#A8HN(=QzC-3cmn_QiRF3aRUOPY|%(ff08n~#^fUf9?=ZF{4o z%wDZVZiD87cJR^0Cs-eSR{M2SRJL`UQUTlRQ>e z0Eev-iYJa?3@Z@%$`->jvp}ayPIo$`VMB$G9$J~>{TSzF6|i+L9vg|H4MDm|b2&R0 zl+15w;x{I^-&PF9WA_rDyKt8#O3!0WQjvmzl)&e?p?RZ9D(^b6DwVb;A~vf-vQkX? zxu3j9TDj`TTHi~s@zw0`Dt5$(3lp4?qX!3SyLi!cWJ~@i$F~O=h<$oS8lGRPtmwh1 z(tDVmznA~J5$|q9f<80OU|$0Xgbs|3D2l~Zt2+KV$If#!kB@$BlV{Fn+jsZiox_nm zdqu=T2dwL;SuOcXS3^Sx$pz-_OxX}Drx;1{k1x;yv&!|T{5lS2ji_RX#}RUbDUN7K zC+8C3Ad|J*VodL}D1c>lPjFs<-C>|kO&N(Vg3XE+j(*d;o+)3cn!<|MJ>4;_t7jgY zA=Tr`0;}U!AvD$~L}W1+o+z|LubB%2{Vl^T9$p{E5@#qqRfxzeF8?up`rZ5tEfO$2 z@voxxf2V%f{@eaa_P@~ezs2o;V5xs1{J(`~<@j4;{y*ORkI{htZKI05AJE755FrEr zz}_pO$-k1oUv$BL1j zFt9cy`MN0A0()>yekA8{X}VMlu_L5aPw7|J#-uIWtTz;xFgOp#^j%H zc)&1@*y4akLjhesU^$}K7f_L$W=Wu29rgUm2dbtl=dUb*)LS3W^HXsP66^PfRZ+T^F1lQ{ts$A4A6vIPI=xe>K+aC9R0$B^2;>R$Tqr(j~Fm#5#2 zIF2|10)VUmZ2wnw{g(p&L$CkzHcT9Ug}MKxS7!SE?|Al)AI?C)#K_LT__t+cSKaRV zIK#<&x+>n%v)=d_@ytwkIxFH>xJ;bX8cYc!Z@ly^)a!WE>j`uqDgAzcjV?%i!gY}T z)TI8Pi3ms#arM?w)X;B~r!3$*b+`&!?&hwra-S3y`5w z>3<{7LbvWR-+XTPo(lF<>k3AAhOyRIjg*G(iJW_;+vR>K*uDx3P>CXPN(R0M2ctW~ z-*P&Ih0PK}MEV^AQC$TVE|1C1j)w{vdy2+!cMRE5SplONxFWb_Fy?HU>eo{w1_Jpm zMtUvfdN4R}6OVkP?|R;0r&chNN{=C4i1%TK;dspoZ)WQPffda=gNf@SBP_)HbKdYr z^v}R~a@GzR51z{#muTrMnN#zPqXl+$tw{TQ7)C-O**sa}%vY4NcmWAtd%vDOFnAn# zERFrhpc#DxY@2O8j(SJqedz&7yqqnLkbtWRp9|*2Kk8 zaCV~mp}{yR9C$TVXJ|ME=ISzb)dPoR<<*ttm657^^*UOV%KlJUoLf5Tg-*kqw{E=D zHw!NwpSPpFc`}hZ^njMSqTT)BE%+O+%hjkA^O2#=Egv5)#yrgd^KLof#uR5DVLY2`P@|x|SzVOcU1yqS&GDMZ<#&avv7u5(o@oUu`b-1( zLviUsF{l!Jn!lPKw~JM!t|L?u15W)@+LWLfg^lTm6idG4Qp zg#E$Bj9ySb)v+rm71%Gi)MsA@=?5rfu%a!2%EKGt!xukvIGj-*%a)ge^HF2ds+`?Q za$Cq&^{XB}u23VT>@6s4;1~rQ^JF+zaMHOfwVa~N9;3`GRdgkjTvt4dbQ{x|N4l8x zq>F5$Y|3Zr)2N*}(5icAv+_FYM)Fo;cZd9CVQ(Rck$%fY(~XMYPeaPfP8fh5u9*XJ z^chn#k;EqG$KKrh8AF<^L#~sDC5bz7T#FuDSqkz?u3}-iQ(}oHCc-}~uP92lZ`(}0 zeY=|i+}K!Hh$wjVTTt(;G3l!*lpe_m7F;jvvs$B!z*2DHB(H4O$hg;4P@sm&QjpKl40R_dr z&{WiUKSj2p?WW>wJY%pPZ7x{6)@|%EyBgrVkj`Xd!zy3n@!gc88Wbqcd*V*r)Yf)e z(w0XkZ!=kBmwQ7m#O9y!nz`YpEC zQ}IZ0nYDP-wKc90RmBO!D%m!iGc1g;044&lN4*y$@QFb|rBCOe&<-3ej-Tf>FjAOv z*CNhDpaSt@cV-+2p=ezSX+ySY*vNm6oGDRPIZcA@!Ej)$JT=YkX#uQ3OH^Up8s+JI zRNZ|fd={CbiBNO^48yZEehwX*&V^|kn(7n1X6AUB9-)Xr7Mx~`RiC$T*gRDe9K{l# z6E|{numw!NQGYDMfY@qG^T4?4@Q@duh3l7;nd|4|<@~(KOU?VbL4(nrGfDB{30pSL z0GaEQ-u*^n1GQC_Tdr6i^c#89Xk%MH=1<0S`90})c(=Myqi7b_3s#R z!r8J2Tk$Sxrr>#XT{KpO;yAg+40dSmB*%H=8BzTG`!nP$%0c#;E^4B|hF2o5eRjix zgz$Q$B#D3{X*bl2$!-P5&UVj@*jI2jnS5|zMcLy1C@c}T8-Yep7C|n4b=;=)3v*Ar z%vb1JI8^=?*$wtsvQSo=K){p3*HZdGJr(B^CG@r8WxyEIPCq9DN$ml~;fT#d48c2r48g z2!cvbii9ytCvwh)nvwCM)Nb)3CUz3^Vm_(fkO#iCw$^eA`{$|p(2Ux$sx!NbK&!}$ z4qGz+&)pEv2ex3TNntwLQCaKZ#tfuzq1D>&r^a?#*EOF3^(r>4F z*4uqq1ldWzK>)A;e0kk1x_hW*5SIROBP4+Wk!u7-5eRaNIrM@B+^&q>C6EB&$W$JJ zia@*tLDdZ7;yYtaOgznenZqzYlAM8J!ijEfBnT5b0WnPNU5Y?xLK8dx(ihM;&fGcy zCXqIu3_GSX%6YCdo?zGrC+|H4jW)~T@q7e0d^5;Nds3El^Rb%gbYT8f(F}1Eh2y;& zG>C3N3WyK9ArSO?+7Sxwkla!3VbYK0V@_#%920)=qO-VQltitxahfS5(jsS#s$oqx zQ+3-KXfh_$LWnD+ktoUL4tuwWT)KSZ;15GCakU%_0$rw?kB_wC&j^oS?YMYoh zT2-d9{Fyn!@dfpeaHo_Qt5YUSYghj==_`Kh<`AYc)pIdkOQ^>A6j#fHvdY-^t z6C)l!&XC;WWHIy`mN}CUN@j?zhvjNY#nbR;F1C(ZU;3!_ioV;#;;u5L*}+ni6o@h|cfxZ#Gdmvgi`NsncjJX$mg)tz)2y%jseya4dXh{ZCJVRDcBP40;>YL4(DR!j7;7pqQahHHp|3(rT}hGny>f~zx2Yy?TvHk$G_nXbn?&(Fuu(D1dr&w2~gvm z5Fdo4B1r0#jl~6JoaA4C$1A749>!2Vf1o&It*L@&p<>aMJ7)5=Rm&z+31Og_c%9E_ z>53dkh#H=)rq@4dLO=Z>@+V)MMSe$_{RFUkV!z<-kt=n<1AZTOq|a{7_c#0|)dGGb zSk6nemMI{1v@>UV)JN-M7#k2p4%vn_w1VY(4!w(n-@|FxkL%0jpvwAe$n6!v1UBS3 zU4U}1N-26g1a}6dm9eU?WKo|2f73>kFdZlJZ}xpAsCEZsESE@JuO#i}t^A8k*uvJZ51sH!?j(tKpq>NSj8)C&8KCHPW!~=Z!agVz}>LHd9y4 ztz~qmG0jn)n}}VHU)nR^0Bs0?1B&ZSo>E2-6f9>tq^5yFO=f*%=?K`*@`|o(#=xQ_ zXq2M_KQ`*tqJ=lzEp%Z06ZXR1=t-TgOB=L(nvmO3y1iB72f&s)K&&$E*YR}xSBucB zCs3>tj47;20tRGA{L+(+O&$CeAf98(alGpmvu;$N?;}zy}?ul zUemfo$x#=>8Q-Ds9~xiR8XqOrZUjstIrMwhvlyXG9ZiVk+Zz+;^;18YGubL>Fk3)r zznHb&*jN<$7nwzH*)hTcGx92(34}~0+DFSkI9bc#NNLoMf!;U+S9s0{5nV7YW8CjB zSEom|$fahwczHQFZ@{TmzRHZ>8l&oegZaN!xL@7OSiZ~S8NdR9$I=cC#ZAq-0iEaclEc6YOZVX%b<=Eh)YEb&=CXGU*FN$j>$`G(yarVe?*(<$<@A7Q~EM@Q=l^sAKnaR4zVMxwwD zL#hhgRc3DCsv^)$8S45&pCXu!B}mona>*l+P7y`Wvm%68@JR?541r-BLJyL*1-ACx<>z0i(909W+;PA4GcD+0=$Ad7I{pKIPTv#>l153%FAV+!6Q zacXxf;{}=Hc5SOSX(H>t0KxEpQa2?4hU5bgA=ftM<3J1*B%YqBk7$fXd0CD$L?^Uy zjxb9#VkBq4$n=03b~3Np!S<9$W|s9M#*S;VvB8@y&y9eM{+2B}H$wJR$*XTys%~w^ z5?U_JqqaqxxR>>^m&a2wi7ijXzoLFvKvWjZSA~0sV00{t>Mw4fsXw=jj%a13JXA#( z=>L=C=K0lA>=ZLZrZu zE!UqEGgIs%11C|scccJH`iJo_AQ<4;zhgM6tqi4CGD15WpyQfGcyfyhVAY!}s_TEH>7x!j` z5*7JsZbOg4@i7o}D+BErm;a%L^So`Wa83+=Mb}Q{Hkx}V9IacNxi02<>Wmt1v0Cl( zTnqYeRglPNY^7`^X@F+&{ zRaTr|v?0;Wx~0A?bi=HAV)orvh~}+kUPo|SNyIFOqYvMJGSnvi+$7%63oMY-|J zh{v0Hl&LNvWQc8i{VLjQoa!ZR2!H(em|PX9Ax{0MebU2rIAV9$TEt!a6&)kmdTQ4R zA4G+-XE$uJhds!qYPSc~8Yt$@25#@7)DF-+11emboE}sm*k!EvK zQK{&r+d@!DDr?rD#&AQMFZ`bLCRs^ds71k~ifLZxXG%gDm|BKaBAhHu!b|s5lb+?Q zi;C(=(-3m+;$hRoPv_ z4gGngdWsBljLHfxe^21uc)l1h=HtdDA{M~7!!*7q-8tq0Zen33ZsNl>dE_L&2!fCE z=`46+QC{8E)b8aiJI2SRQCDrb+Tw~Y7engg_*^Z0tyx#)Bs3Ufg>|0s{F+hHZC*QO zFXO1WHGf*g+PY#y*>$kbBStAG$I?Xm=fmp-E}7q%u2XNSBF@UkHzVQjZ8vvnd4^k= z!#mB0Qd@%5rmkCka+A;?RDr~4=wg}=O%{t%T?NtZbZNlJ8|Tc^UKoknk!K`I(+f#H zyxD0PtaqvJKPmO(h;3l+lwipclH75lIaGRrIUx1eG-{AbNu<%1Fp5fIRBfvo0gB3* z7MViFBd};3iUayB9K26q3t4O7C|gW9b1uD-Rk|v!AYTtNx1jVr%WEKxed2Tw8?+4T zj3b1&CDw~1p6pk~xQVz%{mD%Oxp@01L+?x4SPe?)1zPeYKDyYYj>~Cf7hKNNJwF15 ztE+q0JKj?pA7k9y?~W_9p1-DdZ$5T8|5lb}~cdCYS_6q*~ z^JnF!q$g@+XUAV55-6x|vNPS{PynwJpOTB;);^%$Y!6f`-~FEvrx<+s(slYt;JfD} z4EXML3k$`kmD^T^XjBh^sPuFwi}Iusm{WiH z|DTpHZe54&@vh7^22<|pUn%IXOd7=;nAydTX%>=P)4qQi4 z(%6wNtdJk5Gm}9a;m41e6etHtPy2zwh>22Mld%9bOA;TK=+sptLMa7hd3ga)8!|G$ z)su~VhZs1e_|9VOI0I)0;{vP?I=w{ zhsf^jj?$R?w)NApJ9*ShCeMwLBds8`jOAn#_PMZj`KK!&vg=D}0Xm5-qOf}0{hEO| zlnub&(jn0NXwAz{n=Xvd+kKwc+izvJ z5_mmMUdxXvr38QEKKnE#-`yat@qnPggq~yaI2R#HAp#aUSfY(LZ3MU)1`v(kQvBK5 z_y!j@1CmlrI6NGS|Nd%Z3VxO0mia-orpfVIe>nzO=!^>g1G)#>LH z0d8V~u>Dp^FCo>AqDk?r)dCYb=X8Y`@oFWKV(p7NYJ1wxJYJ*6i)9Nlp2nxAso-L>mY&~+Hz+rW6W&t=@?mpH^@LH9k)UE1etC(> zlu@e7!IiJJ{u-p&uK3E% zgZIW!#OUpUp81=A>>FWFeTna==yX4QJFEy;Sd|Byhl-R$*^`nv6^;%hG&_^V6p;st zv<7+8>Dkpo5t172ig@ij&P7a~%ZWBN+K_*9mbl9o* zAyfQm>dtlIk4@%ar3sp>CN!vQ@p`m4&d%6F3Gb1V+_KNNnscVFz;h;VPJ>h(bOuLi zL{Hk0qtx=5YerP~lyWqo^uUf$%>8-!A)%c@1@5pS1*0O9fj0(H0v2zDV7+u;N{(Um zu_^8lz$H`C{Iy3m=bRAxg;cwZsyCB)z`V*Nblf<08FwdsqE5lJhpFHQ%wu@a>VC^* z5W5a-b=6OTuCzVY1MHg~&+7zttrcBYsrSNwgo#NuJa?{jR0_KD zvMlWNhTm77J>FVE-Y9&{NB$ivoO?x$>|O_;nb(oxpkm?mF7=yc;&gQ#vkj3E z4$=p;o)M9&;}{8aKrrQ_oeg$@kZyXj(3}E+^#uO%9~Xtz75t$ZqvT)qU;x|~@B;hF zQ)7^r;pFro2+HB)5TZh8rbQ^ccZ|VNMt5z7N5@HVYIiryS!f^jcz4*7cQ{@oJ=#)M z^esF3HAYZL&$+@!FED5m#kQ-+7*zz|PvQ%B1Rl7hiQ*;K#^E($Von_b=2h!q@e2FO zsFNmMSvZLffAG)ZthjV;L{eF@OXUej7<4G>d*QaVxGSRi6=EU@e&Pl>9@>v3SFMqe zn)j)}SOH6IEFp=xs=Y(iI9HA3Lf;QqYMUOt*Jc{N3asv zRYnqu@xm+;WB4B8^eCmQYp2F8OkM+brF!c8g{NO+#=V`FD3DCB6@mHFKw#uT+A~h@ zA)J=N)v7mxvh(HkR*sJ*ZAmEiB7*)XD`NJAb0H_tRCcX(g1wN{qnQ%;y$Yv^tX3aR z=;y9+Qg2rSM++(&HXT$?!(okf!#HNQKzl5@3J4_Cc!&fc7wByPC zW&h5HFWKvO$)@fJ-hy+SsP{WbD(8zLm)nzVRf2BcbY$%Nd=M&Iwz}F#OEz-3fTZV$`LR&5|IWd||y*4*hCa$=JT)LvZr{;{L9#9gy^Ve=P90mlG2zVTlB|T;kg)|j8En$6GbxjL@4qsZ+ zmjaq4U@>i|mBYTy856qp+^TOsWmTuuZ~3nGb3&`VeGVDd8ZVNsmzb3yBCXV4t8u?U z$7wb+*k10ta+)vf`s0DwYkjXwQ-9$!`r=q;rRXK#$$Ve6w4%{)&mQ#ec({E!SS?*T z0Alx*nbrScs3d5BHeovDKeQk)@&D`stC$Q&+qa`8eSjWDWC9R7MI0Q5j70&a9vG!B zjs5`{j>Z7cOhVYGK4ooeOCNxP+Eg);on@!0QoG`>oCs1L?{$BOx_F8u;?3RP0se$p zQl`sZUSn!tnyBFRXJ?o~*bpfOdr>rO9`!FMT!Ku3`QPd?TF!ZZUS|bsHYd$AzJeK!tr*8%XdOAiLCQ?!*t9#_wNC- z{`h)eK1&3+c*fmBm7m3n<@@|H^4TkfYVx1x8hg%(7P>Nn4+#tH1sQYVN=rLG&J!eG zkMIoMCCE+-3d%$<==l=Zbt9Sep+5be63||==WmLUQ&Q7RfmrZ3SWGb!t2>9d0nge5 zm7!uSoD=FYN4tQ{3zx$?S=51@hJaQO$(|DkxwD%J-P^LK4rqnc?7DquYWj>$KR=1 zdI|FJKz|YM55okW`k$LIRR}8Ijrq%Nc#9=Prq}Gwl5_!(@93*sS`Y8?Cf?E;NgAKV z6A_LAQi~9dDy`FI8WGM4UXzRU7UxMz40;?1zXl=6ivb2A9s1>cG5LS97-qK#cIh69 ztiWRR#OU?w%|28GqUFJHr%vs2+Or|X^Pg(f3a2^-`CaDoATqO`gP6Miigpt&!~{~* z-k(C6o1Q`CXUSJHZzVnhVT}R+MV!DDa$QJcobm!sMyFri$*cH{74>GeczVR_0l5=? zQ?!IG>!UH!J9M}<5dQM2I(NtNipl!SNjP#AW7p=-jA7+yH2fgm`7oRZ z4By*Xk$)FbOk z%;b`Ae`%iLTsD=ei8;kJOiP9t0nvy_!jIS!q*ZL&PuAF!L3vd?_YM%2ElGL#l42!&g;*fyYUE2S)IoD)<-+kH zT?-I2!V!w?ATm_j0Q-oSi!B1xO0DSbh@ix&l>Tuk1mn)3RC?@8C;XXk$?0%^L5dg~y$mvlW3QM()c3cq=)#iUIIg9wR@a}u zeZ94ORyE!JEC#J zG$_g%>kC->!O`XN@iOfD&g-3v{zC@uV0IEyan2I}?vR}I+D(=C@sL}|<&cLZLxoFy zwBz@@>`VbhU#SZ4tJ6Mh1`<0qTXf}tsy(^`7ke}aZjz9;R~pK#NQZ}FWv0-vIhPX{ z(Mq5)ArKwrqi#~Ks#Om4cZKJc}la4XbI)Tke=-AU|K)(FPk zx*|E^OfE4M@7?I#_77Gcguej@j%2(X6 zfcx9r#x7^o?lBHcnJ(2^68382I#ci>pV#CkC|eVpN=x!IKE0cjGS&#u2?VJG6uRlf zh}4l>zO(*GP1fLjYT3+u9KC|ASykHC^n)KE*fuKejkjJ}gto!%-5Q*&HP(`^_+V*u zO^hVgPbP*x^ky;AB+=7ISLwY>egz=Ol>;F)EyL5WO2byp3@Ode>6$WFbV&o$Sr~*{ zV1?_Xrd`J?rz9_}>!0m=sVq!JUR9KWw1hUE6$z)U`Qwp_T>unAoJhgQXVB~FGY!I? zJA@SMOUD(+=q~2fGZyu!74vx>f9f=figEd@^F2=>t9iSQ_fBQBmS3gh#(|#kmEu!S zN~A)5J8O8kzrQ{D;&|J;e7#-+-AvwRbotz~{fxfFce;Y+)XN!m!rNniK&08#t!`VN zv+bO)OP67m78_&D_5eaMj1||>%A=AUw>M}wJpAjFZU z$_17HzFM(36#P*U%LO%Q#%?*uMg2s$jLjwqAsBf# zs*g(Q?c!+IRo7~F0>qoNRP*1%pxLd=OEmVGm8#6G)_2ucSHp{<_=7dD-kI8}j_o%_ za$0kG4d(p;FSftuGog>C>0n>Aw(#4faAi}eOaJi2l>p!v{IcC?B&F5`p;k|Kw3kWD zE;<7RLZT}2m?{D$MZj7bJMNk~cW(jIWl^HOJz_@S`I8{YztRzvWhFE==%6V}AFx4_ zxxYOkLg39jQ@q0`tjk$|S1~MQ9_%age=VhV^1d)eKT|o|GMGYAC9z0FE{QOYnHdjE zoEj<+qmVYHf5wNW9{uT4UD3j9JWOF|+?HIm*g6jtt#m|tmR9%6b`QAJB|{dKCC$mI z5O=5`950U`=16mtbecf1B)=c~;o+ry;kTg}Nz0%=Ey&tQ0DQp_Gi1pq3c0$#@T zT0clFT8SV4$uL1bsarsSrz>*Zpe*sVkCIi#flMO>xTVUz6%@u)AalFkK4`*h>{pJp z@vc;&Eb#VrB;~1JF~0s5(l2^Qnu*0RZTh40Oz*z{g=fo-;8_d-Xme%o#Z4hINqSM@ zSH!i5_l)2iqnz3MtSfTKay04@O~+`)O;bzSkb`RN$?S4V)qdsn?6$UHiJfi%=5l`^ zUjt#b>Vc?7q01H$I`JhovTR!fU)S;BSR+~fg3SjN4E6kJp6+R4x7_688f%;R0kyO2 zpS^eq7kXv~_aiv8URj*1|0$)TfRLgwhhXm_Dd28vxScpvWb3E{N~c{rXqO=X5?Y*X z1<`z6l`WeX{Kwb^o34xrKC-uIDAA~s8-T7qG(1)O(Q?EtG?-CyqJ7GQgTWCpc!Pzs zuRso8r-hE?Ixts6X|U?*Fl_~`&fz>;Z~OIIYzaEb&n)|X@T=9-qhOvq=?%A#@4%SWG{ z1iD27;VvW$_8tcXbZm%_jiO^sek70NHLn;PK@ldRPiM#LZ?#T}c}YLL9_rJiybAut z3X{8+-~ny(L(;IVq5?QyfS}b_o|{v{_=>N>Fgj;X5(uZ;3*1;9g@YYSUMw60Zu00q z3k45Q(ncdtL4V=QPlLfpfRcCx}(QhZQe{jdEu0_t_Q;+4X?IccYZ#| zL29GH-qqRq{X3;4W}^U|Dg`w)*@pL~EBfv2`ol#>#W!d4BF8h(!N)O#bd zFp+iNU$zkGBVh-!sS3Ft2$=;;p^yb{Ank+$c2pv46{BQVb#RD{W*`{PK#vbnA0@7i zSd0n59V$sc0yS1>-y2L2Kqdl_ynn zOpq!pIuwkN#rS~Ffx4<{d*H`8bJ!l16>J)sm)p+T>+s z?m?&t77aM=HL`5JATzKlLyVlcV{qJNLgEDsOOmo!rP&mXMRd#bDJd1Tl#mqkyP!Ad zWNjRAH!AMtq>UP)%Qhz4|YL;xCw692%WhWu9{b>a0O_4IoK)T3M_ z10fy0d{uR8Qti&6hDYN>T8R{AvGK};R zmN_-G5H^@>nf!$o-@&ct%zCSH z?d!~Cv6PRNhE^BthP_QdT>8}JdL(phYVW6!6j zvkm!**I~#q*91_^0@A9}H?CL(p$I(V`U{jMwfS2qKi`dh7D9e*e8ovv-~og=UwzKO zkMT%uGKe5qs$H5b*|{JbawmT>_JyS-Wn_zjM1lB>EC@T}=+JA|Mv44isCXRI6W}Eu z#)xA~By@|$4DZNIdc2d(Sv(VJi6jTegRi1q2e+>vN9zn-8g=&YjZZ4}s!E-9$|!dV z1^yKX(2(+Ko<*eVC>DZ<%Wm_L1M`6V!>^|RYqW^VE()Kr0aufuZ^cdr(w?JYFNz*r z!0aZ%ZkXz>N!`O#I4B}Cr6;0wC<3o)aUy->192?lQRx8<1JYArmz@S|s7~if+7{Rw$#HP>lLxoL3It<^ zk4V9eNEhN{tm3dS>4r-l$@t#=pW&!~&2;+?Mo`Ui|G4NOjZ1|-<E?-GI}MVy2=ZYrkc<=+*51g+dn9KNYGfg3)x8%`W|7;nC@X#v>8{cRVy|u>lC)Ny$_jk z^6G~`A1{@swMF^Zv}scbYhP1z1G_IL+)MyE>}$JMUIr3^a$}9M(>qTQwtP>ATzrt2h{wy z1czT7jhPpzK{8bt+r^iMAc*rEq;Z9ouW#w@n9Hs&3-c}HuzPJLb6S!(KWj7(W{f_m zpf!Lc@!lFhWg=NlxUjtTVV<@7=Bt;($Lq+!*0LadHz$iOuuQ_LjkMQTYWQ0jS~vN} zxRjC9)~|WImyy$C-uf&b&}rkE!qFhD%G$^k_KfT|8QB_~{#WzkCXppm_G~-MC}%vq zA|y4@c%i2ExYM#jC`28R3b%J%l@jij6?BhCr$@thtUGlldt94iipdXa-T?$mC#X;J@3FOBy^HOJ#lr}pVLXga8n`yB7{=Uh(i9MI_cnSy|`LK~(`pO$xY-_Pw8 zPxymYJ-J?*`xl9g4)N*dhwI)CJ-TjMb}lx$BsE31D^NY&{#9SD8H@J`%c?&$l|F;sV`DV4aU9B_WS zU$=Q82hj;2CTRLha>|Es1R7)p?e&Z2%-Hqwc^DtLq+U}SW(b30$5_!-%!TuW#`d>~ z=jiwW99bQNsY>oCju4cyQ0b`c6KuXqH7M^u4I1z`TGOw|(DROP;V|z0R1oS-a0Cd?(6f#g1fsVSb#a&mmcSNfiI zgT4)ARI}3L(W!f=x;RkB!+e9{jpxa&P~XgUiXl;Dv{KYb)D3uvC~jU|W89&EfFj-W zf+WvdM9^n3O`8%#87u?IcJ^n);OJs8RW+{89FjAM%=`Cv84@uhRB!on4qQ@?C+&lO=-RoipF63TlVY0Ek7afit z7Z<8E9<_9CKPo)N#JNN}h!qTC1FQ9`>EI!__QARfJv7f3ekiVx#7}+!YWubL@{yMi z8&TnBVKp*hb!l+{Rlh>fHt{#H-%_pimw2M^qI;^?rq={tQF1lFNf@fWzwWad`tiuBJv3dJVpw%-ZxBSzJ?# z2YMFxAwk&1a;4QsZ=%$U?4m3fD@Mv_P3WaIXX<+u3~%I*$ztt`o~~ zO#lAwxOr=oBA|WqtgnXTrlEn}^~mZty~dpF(auBB&Q7sMj>Ktg0qFFor{_k{2Umt+ zjX>Z(H5it^nH!p(Hlav~kv)Y#LiwmpWH#-(*EB0Mbtg|n6YdM8*FDH0g6m4jLrlEu z$X{*&Ojz{LjGy|dh+X~VSHl9weI94u`NN)fb@EA=e+r%#LH7>mYaGf6;>8XlKrYHk zfD)=$_h*Q3EU(gfD+EWdv{X`3!^8+>@rcE@?<4tzBgpku19|R@V#qlxB^X*pK4lP!Is>C%L>~Pqzp=+X?--Mi9LUAe@!BQ}8JMJBFPY!Q)59?6>yyn0 zymas0l&F;6FVVa4s!cX=EiBwMELpwOk}>6+?GnHon_7i>Julm3z=@bod2u|7--kI6 z%$1$!1QqabeY2aZSgLe!KSEhc>#*5)>_b?65xBqEFR&qsNs`z*Y%yJ~LHCNh^NhD* ze)b;67t>Tu9{1Z)Krh;}VvH=Zjor?z33I^K0?N*UH(5W1uNJk2Nl)|h7PCA|LGgg>Cm~~{9tQ5y z&RncJGk$ljkx#O&vn7T(O@W@}i*T;t%RHW2gJ?fow+4?Mc^cN9x059v4qZfByz*<^ zdIx)xmml>2l!oz1649Acm4#^c6a%s|<6%RBlp5B<2g0OhIBGsM9HtI+_uMeCd5Ol; zSc%3nsFOE_4dBqz^pkO7=PVEo{s%Sf;c#DemnpBt}`{^Npz7#_@2_=E0W9|8=kLRxQiCM5TAz9 zYaiW=!dBP82)3j@h-R%3vHFd$fH~63Wu_d|`*oM={RKlrRc1&nO&dH42c zE2?f21)P4I3MI^%AFrjFaL-iGWiRv)DYnkNt!$QkV0L4PA4)~(=dyg5L3%dfh}y8} z$XM7OJTyG>0V!YFqiC~l?8}#OwGM&VUaL>fEuYqcH1hJ?z74;{=qsFHu7OoR(iluN{jMbR#tsEd=krM|A?nYC~ZB^VSIpC zY=CHpjg0`tP(>Vy$rfB#(Zi^V6@jTylR4fvRSLYl;d|jkQpoiH0-PHi&YisEW8;h{ zKNB3IReBSBbs{B$*jc5)lwb>E_krSob+laqgMKGYrJ(9lg%8eVwW27Sr-$*O;~Ds% z%txel84>{Nnm`q@o`|B138PtsA-#TK%di^$0=Fg@9>WeH;`6;Tw9~K4locBJ&4hL< z=1u35dF+E@<630X%cz$<(K^BHz^#ls&f`+aBRBF(darD^2UCn4^wNM_*_Ty+LVF~# zVo}3FLiqv>;U<0EhxbZD;hx`oC+K2BensNck#b=z!ZX|8XI66fGKJ#Hp<-njnTU|N zWkUz(>SV@>%F)OP2!5yrrzq7u)8F#3%{JzdL*%U0y<3XH2#`n41}|at%snEhcRjDz z@=84Mx>3oHxO+y)2z~a_Kx5Lehb;(*c|_(NY6H6z#vu9Fnzot_y4BOpiShkvATfW? zgzcrpPL_PH=FQ$0*3kY5>jKPM`b!~u5?AQ9aNaRZ&?n9S&)_}gBA&=*=!yaEiP6Jf zZF`=VjEfP-IXW*5pFGfZX^M0(VB*bBjSWbt&hl>Eg)q*{TWhLwFhNJ~C`^ zxS~E0YQbFHf!E#}+tj}~5?vE>%52-^eUA*M{2W7*AUYwmH(&zxL`?00n4W1WIYiR= zjE_sJy@lf%+lrEz@o267;I$di;r#((`ksult1enT`X{;WRm4vcu#U71=V{27=B#G~ zZ{&kX_sjv0J)BOpxym4Gh%tQ8HOS{oFO7}0h)JA1?k(^^FTCc^mY5P>w;aaext}HA zy2pXqykAcQPcq|9tx=!g+x)zcrh};N){^f z$R>*^)z)OrAEg(zF=c{l6!5QCJM)#Y*#oQ)4`~SqnoWCsXRrN{JhIwXXZV}63paUt zvFfcgMfc}r8q&jjFi`?((oo8w7TKW#1!D=12;6i@%=`-4uemfGM}I965nkk3*jUJ_ z^%N~c>R*34xo^yJ9M1>iA;MoI54XCrW3dnaR-!}Y` zf(dbXWs!ffyexIF(9X$dug_O=@n46Gu(`Z5$E>bvV&{WsfU}vw&(pAWr2**`8mV#750ECZ zoSFKjD$6*vjwJy|LM>N0r#=E+MR>0i{@7eo6d2;l?=e;ba{%P*9?aML1 zmCVjrI%?}Sn2_&StWxY<56WkskEh;Dda z(ZTiN9=9H=uP43+i@8?k$ij&9=xUw)lZwMY!oi*R@=Z`FnMNj=V2R`k*n;(^HyF#R z=XLD)%4k~(2kofs8?7F2?mc(3Ey&{@~XAx;^fEVbtr zC{Fh2HRBN|93XoNT|AmrvPu;pKYZWnde-DJVYY5j_gJDhWlP3Y&`D6gsk8Q5EI57N zY|N+pQ`W?C zd)CCAmNc)(t>$LSw`-rUF9+4LFBvBt@h2!%(eaLkXMCDVaZS*`3_{{kQs=c7XYX1! zHs7s%_&1A?9!0&;dN?|SQlMzQ2sMuk--;`@S6Wi%dzaoQ162ex<3 z;uYqCWu%<~@GyltxWC|h*d$EhTOv^)L$K8OzY9kBL5Ke0- zdL+vrTN&C>$se6Zv1r~<;*fVPJeqJbB`88_=qbIoJ@#3qR8^ zS>>&!9tlq*3fl2G4tw3{>Aifg7DGb98q z$!!>Ng4O|qmboD(%3h6rp&$9Oc7X2p6a}210!+BK5Rgm!0=1k)T2c@^D?Y^hg|{E% z;COL^Y!FLNq$vd3l;G&1mTI7Eun1j)sO{bsYr4}Q>5g5sJ(2PAU#dGbeDqKk)5c>Q zWM{>MkQRf{gfR&G8KT=cng?@>6e!g8G!b&?;j`*_Z2_Z{ARiRJV~)~AeH=6#8qd#x z>T14kwIT;ADRm77Pgje)5D0-JMCu-ceJ|1Akj9glTL^%!EI+>L!b8;q@EipCZiOxi zCd(Uns;7i>KSU>Y578brP|z92s}_y8i_^>3R7MG7XmqLD&-F+zI=99y(0vrNy}Z^W zwT5W?E|vkU)$y?_{`|sjKZm!jXKP?xvf_p7_f9&*kNCOTcg_su#vLZ|J92oEcPCvvF&2e*g=w3{qh!A3 z9QZ%T({hGHcS8?4fgPa%e7O>BF~8%h>_Pg%^TEdA@{2Dc=We6@(AXMPg|j~r9E7;B zEb02W0KTLF+vNR)(`L;HKdaRk^}OSooDH(zlvU7?kUxAof8nWwza;7Sr9N!HM$(r? zZSY+zW3*!b);Kq`;y`_*`E-Y63g|?VkMvxY#$HF9nWlrSNJN$)h z#90e+1Dq7Fqaoeb(1I6BsOn(*0dmiRjUA_2{@5!a6F<$-)FB+yTrmWPy(8jas3JnG&$A9z}cp6*~XtisDG zcYDHF_*JeTEy>S6!=`*4sf++=L)52Lo?+aqPy$l&qt{Yi$38(D+yF!=aMov4kmP{}${Ibu~DnR~l;Q7=eQ zg8D?On34@q%q-5o=qtr6ig_5_WC`Vckhxi$utZVxAOb(dLr@#1C+ES>i&*32O-XVw zPk|Fp?h>mL&$cMyIm85|8iJ4@Zk6xBPe@^ParA&zT=gd0!baRe9@q!1%E|G(D}jzn zfnP539U_X2*3Oj?ZH@Z#$AxhifP`o;vkBpY%DCuj+;{erj(INgM|#0YJ+9*Gl7td_ zB~K*o^Sdvn0g_(2nC$#~Z2WgfJ*fk0**#&6$pLFKU6Zf_xaGu-w{Pj8IR+ZB=SVR$ z!$AMa4ZPQ6u{fhb-gMQ?yzeFd{H(Yo`|b*V^#Q;A4*2+J?tBPDEGWV`Tg5pWW%#+P z)2q+$V=AVi_lcq7=hewQ(K8X@W5s%x%ITDB+3yw$1{Y( zj<{ASa{~A{it;zQ@^0D~sDp#wII+pA`=%m}6NlS(nd{@pAM} z*uMMTvzl(5+ygIZ$?;wO+7Gi&PkBdV+sv`Xt{ke^|x*gEz7 z4xGx?T6pWyUp~D|da5T0o05E}+n!Bph^A-X>^j*$k|Cy*|OeM0w?^Fo|s?9wBF52)z&8Zxh5Qs4Fz(@OL-?< z$6C}0N;lKG$@$um)~}m;qX&;w$_||Gw%vA)Vj*igr}t%*NL)7ElguU9!SkUTI9;|M z`DCAH-7)!s`1&zajYa1}$*IHZGt>4|_NZNvJwhoXWeUnJQi7A-jz{e_!ZCN9LF@Z< zvfJc>=RjKxp@TA{R~tQlO=^w%HRr0#@RGE-HS0=+|acTmaxmV z#B9C5;&nv9>hWzI+?r3H_Iaiy}g||uj012^FDLP zY#M#nIatp4VH9Zl&AfT6p-whmYS;F?<7{u$+G@sSM@Oxc{LWCpgM(DUChLgERN}dl zr_0K0i_0zXF2I8}lxce$nD3A}2GS|H2+o_bRC~^oN@i2U3i1m!9sI&@biSw^P2+IB z$+UB`>F6~w#f#^4EXAyx;Z!?4&ZL!4FKf=7rZ}lI)5Y3jL;VA@qqXEF^#{_EMhmv| zijmo;ZL&?GGh_}lDqYz_pNy{=%=K|UKWyE1-hI#^z(z+ zAKLGN+k)ET_{A|DY~JVglgCC{(@z!!oS1H|PL;hf!CM<*4yhU70q;IbDw-+$Vzfwv9ZRC5%ST00lxa`a(`p01}8$>KM9uk>~ejhtLC^)28EdT1CR4) zk{enj4v{Sk-89bVH=fx&rU@Z$n1N=Ym8g?Wr)j4Nr!DSn7TKT=L~WcaV%K}MVnzp1 zN1Y#`NBtiRt90VmqWc=&P2=o|?O;cx6tJUM$8&0I9WLaEMZ^=+eSrD}v*&isb1Nu4 z*|y%CeGtvCj=+Lr065fQ)wmyrM4o;a>YD5(I<+-=SZdzcEXD~)S4^F-l_YT*VrEFp z>v#c@Vt)Hihu^=IEm{69(#gvBm$u@o*xYX|JW*>adtpO6{V%3A_SRqi(8POflF_pS z3FXO43aZJ9(<&`6tSx zzZ0SGhhY&beQN_#D`Qdy6;mq#D?8J_8vfX-VrpP-Vh0K&3llToRT=X4gOi;N0AyqS z-2kc(1OSNu0!jZ~_}z(xjRo+k4hY)7$P8d-0Ttu>-G_ylm6_=^CO}pofP<5Rm4)Mf zzxZEz|2Y5;NDOCnFm(>Ax0VyMhh^02?Fc>-azpP5=uK$jZh^%ErhD z0CE61L8G&=a{!o`nb|;Fp0zZU=K#LNodWMpPxWd*tLcY0Vsvu9-ng8cn=E0CED zz`_QSf#v`m2OOaI{SM_nyS+O5>J_L1Gc(6uNdYAvly(l#3n(HSe?{tF9XMDx0l(+< zF9SeUW&mhbuethX07g<4Hb&6Euh}MLWn}{$Sbrp%g@qNs%KkfX|M>8)(bz%Om|l&s zasmNNzg=VmSzraQyiViwJbVqz--qPyBkTX}Gb`wrUF)>dpQQiQ^xu2^SAPDue1b0D)}O3QL6;6g(ADJiGsPcbzkh$q_zz;atc5?-1r7Fq<$}{VKRTXu0b5@$EyIpWhtO`(TV31Dfm6rH&BJE8!AZ^aVnyAYd4&VIKbjykt2geJj-7+b8qLy* z3fUI)JGCaG1MHX0o;96salRrhrs2j$xA^R7@?saF2>?G8Fi?bn+@)`UJ?L1R_rKQ3JUVHqFF09Eq2q+zcGKm9Lz65;K7%cs$s+9gj)5&eBLZ*sMzi+9 z*!mGsBr91S9~JU5?t8=@KBDyr4^%Ben#zCKsg@@)O@EmDv4 z9q39};1Or{-}psseD!ywQx5rTTE}SrB=#oJaLysca+i`kO)mIY9kV24X2Cos&C$v7 z9l8M8QIh;OZf<$w-F$xjUI99V<8`nO6(WTfj=X1iqJFVc@>Wz5Jx`#^+XV;Sk+ej_ zNOl3N2^rl*5@(6c2Rf0TST$wI83VTdJ+9Yo%W;Dt`*8HWdHDJQI`63kOFHep@e3LJ zJcRnz_dN%LAMB8@F#jQ4`J}G|@fY8w`2w&PSB# z*Vty%XYo_qeQZyT^2tPuVYO%>XTOD#nseq8V_ae;wjJ0W#>uhsvGbv7lLA%Zu-F`2 zZzhujG2>XrFD`d+pDU|ViC6GYDH4{p-!qgH1Dwu36ggk*ue6-KcQ11FSEauosAg!` zokea$A4j`T`=H`+Ug~;OdaY}dJaB4UlK6wnk!lY$D4$0Vw;ugK{u>P2giYF~AT>Cr z3sTfDbj*~md1DOF^J%+wXUgZm<6h%YB@(#e#Cs$+f);}9Y)170sGc483(ac(G;?k2 z#gC30SF7YPWn7xZtl6!cAGi;@i092PF9X`+=(<#o&c4EyTtP2x|BOj&2Kf8kPLEbid5FBt=jP( zya_p~N^6*QrOHvQb+*IdS4v|oKGrwYYy1GE692DTk?#@10(q&7Sq=yYO9Oh0c&@X< z(i>rxLbWe|$J1nE(sE__TYjWI5m-YCdj|hIC}yH zk&sa!xjo*2d!0U-I*yJ7Na=W;`J$}1zd6U4sEjsz!zXY#@AtM5g4P+_bR)%HX8=O> z?f^^_XR{CheXQqm42w6rZ?CTi`3+2vO!sVti>p|;(sV}}L!gKjs>~gFbx^Qr$EyA;^P&d zQW-zayCakOLRRB$1|R2xtko^`j)WtGG2+}EHi?)5@qNa|H~+VBaW+Q9#>DF$Xusr_ zrwFq;>BL+zebmTVje+-7g&CKHEv^{9r#{UtMFc)~LI#u3z(PyQum^ zF}9HPcw4&Cuyz&ZvXZ5n)b`G4sP;U3IX?hl?RJ)@Lv3D(B)FJCDleL4_pHUshI($F zuBwC~JKK>Di|FSrO4E}W5-|fd__13AfLd|VKMu^%F89ND2mu^gzvFio0V30IquGqup2Dl z1cg+TTdL{Ustq}OT5_T{Q$4NK#Oe+R-&Z^CysY*WZ0WL0a~uyFW&adACj$A)R7xqf z6)WoTbHSu3!|ioB#e?_*-*#dknqrWU@}O?mxT{EgR(d!5{fTsi0)L@m4HFk z-qQMEp7osyUSyhX`Hq5{2BO3x{OIj!c-rSJB#GImF0H zSJ2Hp2zM0i+chnx^owcYPZtR58T8aJeX-&}9s$<$YSuQ?1 zbYELG@MR)jmRjF6&~vRIp#a*+Wjwt!J!;!HyVIy!4dU*nX&W*UKjrdy1u*LGAXHww zpBM(uocfB%$X}mojQEjr_8^QF3EkhE7Vo_>0c;F-ciE0Y&F5p5nxgqVizLf)3p^x+ zbrl4Z?|r1FP}KU+V=wnJDoL#>I(>8(AB<)$c1u`pu$L-UG=^gd%d2Cl-^t)YI3b@3 z7l?&+qXw!$yxs2yj1umx=+9UY2ikO!`x#**%iH_Dai zax$Ou>ttps<}wi<+^=s}`O6ME! zc9=d=%%vXbh{J^|#AAP0OcrCxh(ha_zShfx2Ztlp=7Q=BgcMGB*ti_+JcEFmfu_-} z`M#gk&VaGenQf)Lq-glG_JQUZNzLds4kIlHpVm(}pbDIhCcEXe%J;N!l9Ua&$Xd2t zXeL2*bNN`p+%A@7`IOTNtiT~>j)LI;hFR=^gji#%rN{c+7l(7ks^uF$kus_Ba1>$% z$PHf`*#>s}4g+7}GJe(FbE7#s;PaAy_l^ z*OgC?0*MYCxCBrUUBew1S)C>73*VpHDHk6kNpZcR?p1FDq$sFZGOHLHbHi`Tu}+gL;(Qh&^D2#`pCtH< zEQI|24BI+XJ!jq!QpE~sSPvcfptZbxe;u2D&NQ4=O<9y8qa8|7%tyQ=T9#WfvQ)#* z&!vc)Q3=V3{3=HP|IMu$m2(-NqoyKfoBLh${+X|wrD<)>)tGUMidOIyj8&82SQbSS z)`>-*i>lm7&&CZ@O%Gdx*-&YAik%dX)wmsuBN1H^G4pBKg_Q5SS=#k<1eMxoxubO3 zs3**0AwqR&Wz_hF(>`ucMqrYRjJKwg#X6z_{ z1K@to;jSm!Ftaa9n;d|z_4my-vQQO^3)Nd&!&@pbR17VYe7NvKA06+@X97sAf-`3% zV{b0r$aK_r&v4?q`=B!0rfaf=T9ZIu#{4qcJvxY>i zFimhm?uyp#!VvS4ziNr0Khsyy4 zd}>*GJ|5BN?y7Evw|n^NlU|>x3KW})55aN}TY$dap-&>GgI7k{pl0Apn0bnaAWv3% zg-jvC241A8gs$is+}2>oa5nw(vRpbtOIhn4bHyPQi|(`{M_^jy#E5c+!rFd&Q6+UG zOWFF4!@>Opf?$@Mfg5FhcL9)3`xK--+~vs>u{*CIv!UMfkr-uH#;~&JkSJekFvn{8 zxPyygL@E9kmWSqAf$^2=Sf)N>0nQ#3LJih2Pqy*9@}*eh`l28C9f}_f6gH<(oN~Ad znSYV4exo9jZ`Vgx*dAh+;15A4?i96}{`^2%tRiWYWV~IQsPW~VP&3kK2(c`6kX^-~ zikDH=I&yhhx4Vfqr{8XA>&-!gX;p<0eR3Jb*@ZJsbQ!}I&0*NDHkX7q-{NP(J7yI4 z9rAM9PTq_#rZvvmwrKeQ163XV^!HstXF6o$SHGa_a_IgqyreO>TZb4Z=`?0sm zb4BcizQ-o;L9s%Zwh>-2ATPayeMTeRmbQA%=;q+zNYp4j!a=WKHFF+u(0KKon>}*H zMY86oXE7bVl~xJP=Qq3G>N8xI#?UAzuoR zFe~E{gi3{(hiQbhM)e|jK!0Y;J<)KT@ryN#WXUmZT?XbO+|V~JEH28>H$dRT1-D(X zF3Jq7N}?^xHKJmJ>)}PM(&}c(!G1zOVd>RnJrx~FTy$@WDllHtComppk|m$3-UO2s zz1$>`WpZqo^;*jAg%3yiPWsNgcbe^;Z4kKg~yk|F}g z6;_unlCE6UQ%C1U)S!*iP=@i)sMXB7nqPpF~kJ}YHBjD%f z28FoXc8O~MgGHCqPx{UXp$p@ZH7D(#7qS&8itP15PlpWt>!^oX znULQw@aUP^29vIo4X(ZqGE7*zwUUyCXh)PPFW}cPD^GsI&B0N#!0s@dkFK=A=I|#N z!YB3^dl*5N`kNJ&E76Y4|o5cWmz6a!XYuXd=k4wkJ>oq`U?p6mu}B)sdlM3&_>g z6MKFwsVW<)+aY4lpzJ$|xtfW#zB$<9umNaATJyGk%ST!8c=xRE z^6_PZe{~x3i8n0pOo1@yS!>@D=5kJZ?_~)kkVj_2@3!UE>K0Gt9| z(Vb$}Rem_Q(5_yf3Nmd$oSXWmt}#z4-G#x^D32z87WgA(MBz9PVgM~V3guETsC5yR z+uhw zM#%HKTu6;5tS9f?pF|MqGjsMNE~PFtE(Z`AX+{LCq$%#W5BXba7pNvHCR6t4?h)-& zd$kE486^3DT1M`~2u{cts2VPx*4D683iC;{Q~ZV=S(sm)6x88X z!Y}@w(2p;$8DdkcysK~CmiuO~F8~i6cc?gmXS10jX9_BG#z9K%~+-11W>-?&AAjyQ89F-&P zjHr&VsmQ#UB)jBl#^)&+u{1Z;mSZ@W(HE6%8t~?BLynPQJ;Bbd z+GCXtgviDcI!+qZB}$9>WzL-u4x@&Cv+Y(~xrOlI7n5i{YHLi>?XHi2gfr+c zi9C^tsqUB_yHnu45p=VKkO*}f|0A53aOQ1 z=Cxb5L6%CB9~(IK(?~7QTYyR)B5lV1)7E%-)&P4hCp{# z9oeKxy- zQ2_n+c}(u}*Kpaoij_3H9P^l$>`47EE&ch>$}ms$>+9ln7rHw7gpQV$L2CMn5l2@P z$$?zx_0A0GaIFRS6ScKGI|yHil8nsrgZcCLt3nrTy%A1Z7@r^jIrZ1xB)E00Z9OpV zW(76`oki@Q-pMWFN7^P^#)|O(apn~>pdrDF)7%CyYw_`eeWaEYE&0@sq{u1o!CiVy z$DQ*Bno_S34O{^qBVhCrg6gQ}k|uU_ZtE5`!~0j0;12J(S9pq^{d3yW&Z5FGh20SY z5YZ|xoBg>VZ1fCJ{cS!ZR*Il&J~UR8_gG_eLCWpZBe3Z-SFfybI13;sBwk7s5qlTI zw79}df#jW^OR7ePnGp-{5h&YmICv{vA*qob9g*a3FmP)rlE>b-`v@?Z+{}q`E2vv? z6T1`pZ9+5{Nv(4osj6O>R!((8ZI=6tF-*m04*kNB$BTd_D$`j22Ux6%qprE{fAzK2 zuCIQ=7502iSz3&Nin+gS4Ua;-tRuO2n`@#fScNG;;JL^@I&Bp#ToHCdq=>W6jjwT#Yg3BRN0sAdD zG1wYPQ3;(fVzNRHH!Qgl??F^|Rso485JnWLF9Dwk>}@P&06W8r`@uHtl9)7XzA4ax zHG-D{Ht#tP1~0xsvAlNH!`I#QNYrC**V;1YMCIm^&BJx(PUxrQ{R*S9_f>6$W9_Vd z9VFRVoovOueZI2>{>vT4G^8YsD9jLaZH!uAYA%u0FYXBeN5W4w%!{Kq;E#$*{j<4? z7J%eF3&=-SCD~O0*$ZX+$UC5VAF;2kQ%>13z&>(`>53)|a?@%5*oV_tcQiuo&0$r_ zxQ{3JCtK{!7s8{Ru`JjAZ>fjx?_cB>YrtTG>^2l5dy(^o%~8?#AWLfb-z6cvQ60b$ zlmOEo>!Hyrw*mVO(@F7FDlC!+-#YLdIk(i949yLXY*-@_>{_sU4u0En9j;Xb7gT-s znu^rWpBHY{sh_NFYU*X?M=bPja}JJsFv_bzhK)g1TkGHpPD!lygDz+cJNkM-unJWPCqg9LuDccsn^uwDvADpZ&qI4@1k4Cq)F;V8b5aT{$J{4mqb)UMotL5ZNZNV#xvK(?O{p)rQc7DH4=j%9xD5ERdQ za^6f)GZ|nO`mvA6;YqrFFzqxexp%VYB1Dfubl(siP0n4ApHFCy@f9E#GQ#bnJTNNo z5eZS~+%qJyw_v5g1@8Qc@l}EJ&sE5Pu9d({)J}$m|Mr7ln;OZPrRH4$wD^!5HPRMN zuD5(l&Udak-(i7(VF8a}fh0pZa?q_iSk-EH8Zj0nABP0LSzIbfx6uxtw4KCBtqq(= zYTxysSe%n&X4-w{6nuFzXg6k3%oWsj-U}nTa6Q=`@%3C_4Mx_J|0R^|zDT+_I|GUP zxk9V>{t2(bJ^u$SmG(eS#pYAR=4Qp_*&Guq2G!ZAMC;2tUQhIhjNH+A^V?pA&*vo_ zr{5tf)>YQAUPRUy24yoCqP_0jEk|Xm&YA*u#eZUgN<|OSFqXGxn6DjK-#2y1W8s?- zEHYn?W<3O=3ymZ0#}?RLG0AJAY|~K73f}R_JrjM$kR#S1`yN4bF(d}=xs|BmiTNEj zR-fNY>tn33P!ePwxFk=k3sb=doNo{|r3$gb-zl0}6{2Zr-!(z3_Qc^+_(;B`?#@qQ zDOp|ikCXPzG1Jk>j%aN{qb2ac8>pBRZ7R>Ityt+`tBRMOg_|utxmp))m<5)k+=uEN zcCgq|1+N5FEYEdB+*%WL#NAdXl#>_Yn0J)5ooVNHAS7s)Yp#0Tb#7aXI*BBWy-Ybt zGrp*mhWLu(h;gS^&B%O@+l6xuYh&%ydWhq2k!Lg&MIj(w|UYu3gOhmhBsj{N`^ z12p((n-a`~`*-=%zGx`H+>fHRh}OMNx3He*9sYd1iu1Z6nQro!LIm=BT)yeT3|T0X zn9R8TW($&~h%Ujcy&t1!0`qVMbl%lyMtw|lUoa@&o>vc?{;ah0eS=ArUe8)|)bauy z8S%vMLR8Z*YDf6yhYS0PtGUci4OVrc!F}(L4!j?PUjv?--ewh`#X)C}yhK{8LUg1w zyi4qdTAN>rTlYgsG3^l~z+S9mr7W%0Lt`$KQx^I5 zKVdqrf5`qxiLtYCGW~_8u!5L_-y8l*QOJKvRQ{*GZ~qG#9sZrOR9gv0$4Wq2 zz{DK_Y)pO~YmXel>G7JDyp1^D{0RUyhfrY(GmP<`=`(A$(tFU;mT9j^q;-;Yunu#_ zJH${Qj!-N;T_RE;;{cU0PuEbDoc(ir`vVYzntj)Dm{ih`V ztL`TYJLf++{?7=~Ka|iP{LeoumXxCEM@gkWSuA=%YYT(FJNzF3S!|$Er+)xhAOwgF z1Y5BI|GxpU*nofd^WOooSQ-DW1N#?{#qx?lyq*gGl}!6>@_z$l{m&xvKc}*oIsT5_ zKk)`}6t5}yKcccg9MYex%>N4G0J4KnqF0dV)&BqZ_=nT__ck^TRsir1N`;h-gY7RQ zijkBZgxUN}%K$-y&nvD3;(pjcEZ3iW4LchvfQgOq6`^7Up-Zm_%AZ36*_lDG(;vhZ z2PcS~Vq<%~*8Gc+dR=7v4MzRt3>%0%V|k^l{KY_A;wS!PC z5bN|h8tK1w1kq2wIipv9SXn?|+HXdRi50;1JM^qfKmf?4SK#Vj`~5Y`|3AL|D=q&4 z8hU+?`LEE>D-!tEIrwK`WLBov!2I{1A!ZIB$Nvi&@^I1B=u0~tX|Z1`pje8gTe78F zIwwquv;6gj#z{0(G9}B^{+L-tQzEV zKI?T;|tbuN8B;6yvF(}-(&W`QRee`X;$FiqoyZ%9(XU%v4YuLdw22su)qwmfURQHaS`#)A2A=qF}p%; zp*m2;Oz6tRpxeBJP>J*Ubsbf!9`t0%?S)O`A_m9=$`SGw9F&y2Z_5sI;2=`rP_6M{ z3mSk1TGdNu2yo^0kpB|E)#dpye5z)^4~_S%$+~y-5%QX}U}1!npXvw9M@sld`Dr{v zFt~S+O?;VC;1i{z#bDqcb;!+JC)gU)3g!-|DxEXMsBjU{Gw1ffP?31JfJNfFWJI|U zh`y-{qSOIX|V04>lAG!SxYzhtwn(bDRc%j1BuTXR8+Xgk!yZDJdv;* z3xVs|vn%TD3QFnIq@K~-j{_;mU4YdGr&y^&_2sL@8h>ouX~rksAaCq*d01IPdB3;Q zCal@ncM!Wy`VC9yV#$Ogcq)G zhxhE{87ca<47z8sK*3rN38M8Tb0`!)lLTWb2BxeYcYi!)$_r}IX9K&8C)du(33-2! zl4oq_Y?K_DB#$Gr`iX}(;+Z;DF@3LKjfY^#1M3am7 zf2e!MAX}nsLAPw%wr$&X?Xt1UwySp8yKLLGZQHh8U8isNyXSVFj(+z=|9BlSW95om z88dQ@l^Ho>G|mB#B@p9F;3j`)Kc>_;lIs>ze)gw>8Ri zChwQ|d{PoCE}f2ke}=}kP9#5njm795ZSEXXZ{T<>u(q95J_X*}(@=5tq;s24Q$h$Q zS3>IRGU;EGzsX6VV{}>o4J|*E9ICHok*eKoWUUQ)JEkT#P<_-a5daox;JyhYASSOI zanh0gUP^#+00=)*cv=Dq8F+?lP-abrEPs=ynVa80<2M?UvNGAo5s;4#VP+8i_gX?b zJmL@;=s#a^+@}H;UXe}GH2WSSPx9teWwZ3Ppw3NB-};c_?G{VSGzd|+1Oe|MsaPr5 zjhl}y0DG)}0S63)cs4$Hgq0w`b~j>5c7(DHIfBV=?^6PwWv-S}4DEQuPqF-13^e^p zHu_X-45ASTEyf*SmjqJnGbz!ejIq$9GT<_E2PoLf;X_TmJMz?a*5j3g{a*xvB!Mc( z&?1+1g2kgTblrocd0ttF(k|tKTCiW0NBp4_VZRV_!Dgq=ao;%K-pb@W%@(POhHFXP zoTHltBz}~miK2J8s(Gn9jQn~@=!*4+h)HXZzcQyzpo{awMQVpB5sbNUmza!^WOc}v z4oHX%@_@z)$TQhaA%SF^P-I!!|8z|nE1^!7HA|Gb`pU-vD@Jk|NyNoVAVsU(ew+d< z3g>W@wt(!&QV9UQ1e+5l5u>n*4xTtFvUNwsm3GR+QJBO>u5K%vs>k(`(Sq$bzTu%_ za+V#dfGLr0;PXqAslbXFuL^>QJNGFeXU(#uBEpbXJQkPUamteZK5^ou$U%^E6AfLA z*F%#8(p_|qD@apK5|5{13MZ8GSwJ=kx)k96>Ai^!g4p27kfWibz%Zkdx30Hs#coG; zlHW?w4YqCj{u0&6Txa{`YxUOO7e7YLhVRWii%my=Rq_jEtLgR<|7#QX(HZe$qAApf zmhmgmNbaNvx|s(<4IR%2rg2AK!TFGB4Wr$yj2xN5WLEICUt_GS=Cf zUF|lis9BcYG?k*1ht{AU>h{^qQIxyIiw}-%JUOPW!-N;{(cUgb?vX*Fsq@xeV~wtm zR?zJ*X0)IPHc1=wQ1mgiDk3g)FSo{gZfawGn0{m)1KGor#Z-+M^-tuQRz@E-( zPuO&D3FmjdvT)&Rye{Gg=6r*S%!RVJg*XI|i=))4gn@v{0m@kwtF6lV;*qAE>d62S zc5j@J3IHkr;9%(|3LRPb!zWo7SFbg0MI4YLm~yxvG3kI+0Hk_Hb_g3KR-J$FF(-L1 zP5uX|b}6ut-2x1(Hz=9gy}%?wff8ljeDMPh&d~)ewh;BHq-G2bW!#8%zXz`fW7=d* zk=(|NYju2fu|hXY#Zr_ue-Qw`=Eg9O0tZVv(&Uk>Qyzc$ddXLQI{g777+HlQ{?@;l zTrQz@)hJ6!Movx&{gFiO!NiI+P%Vrk*Homu2v`hDE>Rm{d4~X7fA12*I8O~ z`aJ~35T``$$3$-OB7P*;MB&`F-)WmzWW=>wnI7zdRGFkzEI<+Yl9(}d8Fe565}-6M z(-yqX^9@<>1xjY$I=4otdXA9BgKXiw;LO+`AyUA_%P9zJlio2#Eo_y4 zmP<N^4Od|(;lb3&8|}d85FCA;m+>Xi z3S%wIMUoP(B#$ySganb0epyz~hQIO^6b(H>T92%Vo%~QBR$cb17%CNUUJ>dP8bcIY zqefm%PHY3=;Ks}23}b`Kx<+eD(X+zc?TP2sioscZ2n=?2S9@af|82qd>`8aKvo=Tr zt>X6iu)blSimn`C2{=fHBFw%wK8vF`y;DVC`W8qmNG73Bw1{Dd0eY`mMT8R`f~1%j z_EXPu2Ue0VRRipOw2NNvB~`v-s@;)+%)LOBuEt`8$PtlE0e1)1cP+Q}6S3r7$HAm>nPCVNhGgcz>H0`z=r?W}0ww>GQq0P#nnby2NRn0{~SjQ<6#(u?D)SZa?|PFF^+ zq>fJ>nFR;{k8zn8OwPS&A67_3O^Bd9yXfy2gLZhX%4JCu(}WSliPKs|j|O)f6+|wI zR8Ev|CkcZ;pS;o1cccMC1q&-2)ME@kgu6TdSeM>Q6YY2@`AIECNbkZbqS_TJO9&HD zl0F9|^x4P&&_PEP0TVPK6E&ChMbG4~z?Pl(WNkb*s?XKwWnJ{;;%FK-yYXqCewFW! z*5KOGS^cf*FXB%{kB$xwqLpG@r1tq@h)sm_ZdBtO%vXjYH1S=Y_l}Oir$Kj}A)EOc z3$rRN@&FanMF-S!C5sJ2T4*K9WI~%!jF&aMh*X7O(WYTqMiS7fl3yO8wOziXTom`p zP(l>?P&+uN`G2i}lMH{CUto#8T7@O$=l_!71sYpmLe7p&aT}rEcc)rkNmh`fwUVrM z6HTB3zc5b{I|oDUlftQZ*{@^8C0WZ_n=iYkIbM2tmCo+|&P9F+x5d@1x$85_Z``#) zhQC;K_f*w{G{bXq`ieJEroS&9D?7t)w>d2g=9^x~cPtxkmTKCZw9|s%8QY_x;x>C- z)H|o~jZ*$t#B0g(hhxAf|9+pMpElv{_7lhp&S;pbb})etpl;6?uJ6>mUUskN8K$nX zKB9%(8=HHcXsOxydav(EHC%6;cz!l1J&(ZIo7q8){j!D-l8ZErw|1j5p*Q#KAPK zM`B2DBTeN2=!NUgMv;v%h}7VdCWP^Vq)qEW&L@4k=5vpFCmB6Z$IAkoQF)^##Um zVB7W*iZ#URjmIOsX8Jkq>);HQF?(9Aw&Q0W9e+hY>;(Q+P`LS; z5x$~DaE7T=scIacv88;s7<7VyJW>{P0-P z!Kspaq!2KXi+Z3T3Cby#dfqe0SGa!jZYP1I7`ykSAGznBh6S&KGWOu!s{C=XK# zR*W=%;?zkaVB)xvd_RJng#CFF$(5G2Le8oA8tU(|&58%1So2>LG@EGFVh`uI;w3#7 zJujdAgq090(9p?7AJy-WLgD0BHF+D7U$thp(Y|FcpbNpY=o~sloT9@r!NI%X+RZZd z@e}x!0lT;!p#c}W5`y3_VK_(@K6Lq%o!Oo}3z+IH*l3?pbbJ zmnczX`IaE_M8y?2hCq^;OQJ6NVF*naOLayLJSCL~VEf0=H;H1be&C$YC2AJ&oIW>t%V)L95$3$Lk@w3{0W0vXvk`Ec=johd?)@E z8R7tyl@!t=wn{RU9ZH%h2CUF6XV5%KIk$gJOL9n(DMo@L^xzK{Md_HofnX1~cotgY z)zRA6c-k2I5r}sLQZRR!m}|#-{Q#n3yWMu$z)Aeooa|$JRb>q8*6D8=w^_BgeHyzI zoj3`rbm)uHJWsmTdvnp7)VE}laqhKDuFzT6@v7iuRTXiPHy4@jIQNupc=uVo5_ZKz za;1nF_&3o?Hal4@)N7aZeF^00ewza3^A9eyVhL6qv9ePqcdbAH8ctYu0t^(hiCFs~ z7!?u>9;$>LHrH&m2I*PV3yl()pgPq;iR%GZA9UV!II<_pd)g zAmQ?=p}pU>6_CiZ(Y>$DrHfR7;Z{;}x&-Y^#o({eq0z#E7Up@$`VC+QAb)a=jX_iA z`@37;<2Ku4c34lrLEB9v9Yteg(K}aOSEf@Ut_CMhjh^K)bsMWlFdi(wR*iFCDulu| zA>M=oeJEaG^lR{w@`I0!Kd(+#^ZF{JD*1Y9TtW;mosrebSIDxK5#kJTz7UHII9bO_ z2oCMB7*r9Vg^glLonUIfV9A&b2()_uXEbC}Kn~=Vhl|giZ%}i2m+{EAkYW88G&U21 z&~L1jM73~L8Z*v zh!9!RQ;r?{V+UMFXCX(XE#=W3=bHKtY$}ij_EAynj6mXVCty&AgP+#+KI{c58K~II zxR9_yPzZt9?K6bw9E`slH#7?Xp+W$12@aU0PiU7G!Q8n1AIR{a*oxaUyQfU+ROCaD zo?Mc2lhpK7eL$n!CU!LuKkHa(k==5SVM=a{DhD1mOqL@Q7jICTKS1R_u?6yc`~4`&^ibYchG?$Mt1e zQ2LFYnJk}0?kQ#>mKGU3&WS|N#5~^p)iQn-<9q2j!mDi$cKP<7l~3`Jj@IVed7vBD55d3%mddLE^_0Ui@Dh1vA2;mP@x9#+D?kUT0d9J}&X+(;_IEaj zDJG1A>l|hL60hkh;8NnXRg{!2_^pdyzt%z2l4nQ3q0&NZIEg$4_xc&Ic=~|T#N-?b zQrR!NZxg*oZq~76xC0WI_B#i_tmLJiMw=#mPVW_ag2+?J-9UvlCcUVbt45u_)a*fo z@a(5Zm8s4{l=+M_8R3%GV+`QGwL0BDVn~k-mY+04)umN%(}n;-kIF1*SjlR8ZlbPP zJM`R%iLv^RIC5H;xmOBGv9AJSG?f!^{p`#>mIldGDwIXtXVk9)?IPCRcIGeQw}s{H zYPx>2!i&6sQLg(P{nwmm8?()C>CkFUpLKOEQ~Cw_+C=>m^zfBYS0A1q?c-UNHhMEl z9)N6_ZcxkDD_z><+@@o%d-RKqz2@_?*h`mG_v_Nq8IIo1IF(T7{6ZGzhCv+B-yo>@ zzD0=&`;-(8!Ctun#Cqpt@N~P}zaj!Qt62RTLHnzGuHlxGwyZwdp{-roZ|&gvQE-RO zh=@9zk2LISJ;aDSJQw`kuI_%3{q?YDogy-$!#2Gk3B<&5XCDygBX4RCvs1s}Rh6Yd z3b#nu%rfH12vXn4>t|;Et5OcQzc96ec^8keni+2meFtl|(MlUwdKKzANeNLEAxd9G zr*pK#+R6Cx5$XsX!8YA~^L#mRUQFjja(l4O{bNW!JodaymKvAt3Ss{d89ce&o6ip| z4^DV+R%z4-cZ=0u7!#kc;SO85qYiaoRRqUm

JW7A3sb`SC+f(PV1xj8-I|yc)hn zh7Qa_AXK|a@MNdrlbvUWq42#zY2vYC#*8o7$wA&*eQ3j$_wr>7zrY;25q3f8sP(dpFU=aNAL9e%7|lL z_c^ud^EcyubLr4c>Nrl%yMJHDGJ0+Zbb?!)46T-M)vJh99yL-WcZ5_}a^}lScZdci zt=4Xy0y{K3$0)`A9imT4io3>%)!DBP7x$98jobb!0yhNKnHJfh5<;##(pHfqggiey zP3}K~&8&=mlyDb3(?=4ej9|$ipq>b4K7!-HWd+CkdC2LcC`~q-G}_9X7a^rXjM~=^ zR#)Z+*e?_9Qy&iAx8`nGG*^o|7lzBzEbrx=GPJIA!2$ z5TOO#`6APxTt9Z$>l93gc2GMKE{7r^tiVLBU*I0;(nb=8#-jASP$IGrITX*S7hV!f zMlP=uERg?$iu}R~_?knqXba1{jzO8A*1fW&ZlO{?G+5AG8#66TnrY}pZHO(3@Z+}l z1#MxX`V!Y+>Z~m(plAy?SOh5ny$AOM(jjIdnXCB68}pDfxD^2Lx?kd))uW&Wv~-?> zi5%JMCpdm7D9H6A_d-3DC7t% zIPX_+OpGdX%H2;{Ya09UORq6i*ISD|2NJ_gN7wu}QR!UQEe$1eHjXr!3$JUgHlB@E zvtxOjFPrtpDYmF?y40u*4-zR<@L~s)n|>EcExl_UfpzY1+}y~`jWD%(^03FWxpx= zJsfx@6a|wLsK69KGi4fwsVLOdDBwhbnTWLnBb9}U0XpP^p#Y{M)P%}WQ5BV)+!J?O zh)8qv5+P5}0e#iuKSZNDs}dvZQ%9kHIT@r!&{;dq>UTwWfY7b6q1ypILjS4@KCDwx zT3g;vGohI!EoL?dj!hH-0%EBVV4B?#3KK&w5p$({nS4eOiN^!mV09+>)1Zef55P4l zf<(cH>f_DeU-~(`4U5U{<+BP5|M=9bw^sjfW+w{!^zpRjt7ofqbF^p#4__IBZ{6|U z4m}VYlAd}Y6uURGYE_xV!1h+3QuUbSB5GhhU%*)MLZ^=T*U7%E~0 zJKt^AJ+AZTXvd$%LIs;`crtSJApE>FfX6q7sR!h4Pr`_bB1L--u|i}5!ihFFR$7OS z$`phYfDFP>+B5>wov%&*EymfKgvx`-pc1_L**HJ~%Trh`$<-qI}}R`u#ljz$#oJ4qrbl-?Tj?2FzywEuTP zCqnXfpDsi%pR>{yjKAXe!*z?iV7AI$rAqchb+XV@h5o1!@060+1QMmTzGi>Lu15np zC!GVPRNme%9@i?o%O->LN#t2(!5NUIR!7kFjGtHCa%v^!(YQ%z(y2;Z2q40RDB1^E z@k*sAQ8_)(b9sYvbC$}D8j}Z(13s3erxdh!L-Xx#L z+*?{r4?xY>de8Hv)HH|*^N_|2yisRA^J%XS+f*$TVB=kpTFM}xyabbtWJ9z==flV2 zr~`YLF-Pby8XqYUMG39GCSbabfl|A=3r?Ev&)!MNQ1x`PZwUYr!ALCL{B0|A~Yg8^dXv}~GR#n(VQ6q>C z7=4PML3wCWWN^mXBay&2g^kxSkod)Mwv1e>6Pf#*Eyr?wjBL|iqO4Ri4zTPTDytHR zHYE{6@W28#FsRaUe$jPzlUyqxY2i@tWRUzuqX|8Ph^W&R6_O_FxkF8WR{@KSZALOT z_}eoWMCVZ$RFmCQT8VQ#^^V~ByT46BuC<;V z9HG|`WDTcYQg;zvb%+f-*oA}3{HfsqK8!kihDYRy!d1L|aPg5Hhj^Il{vyQ$2afB( z`-euckzmqW%1;e2EP>Jmxnx19w2DRTNJTxua+cz#LFIXu)vMW~(CMMq_EHv7S zi?|y5A>D>bjd$cQQ!w>|}%? zX7J>atWKa=g+Hl#W3WH<@|PZ|?k~U6Hith?p^5cwQtH?P(u0~TZ?+X*+hxRm2UDwP zRNs|BsUoVjmq|AUV=CwjTB}>gVnFg)BZk|Hm?Nt}q3`+_pyL5*LpTD}gHPUQnYu`o)PeYog?!vOw96-wZfB2j zlb=K*9V8N8TbL+ORSwW>qdOL6B5@%6z@`%U=1w%7SvQ+F>&q91%JYq} zkR4}9OykJXL^M4sa`NX`s+=}Pzvfk9Uq=_Hj$pr3s5&`WA1$FqT`oK~h*{|Nio7e; z9jPMP<|h4{wXqz~lBXP(er(5RA%95Qwc6JVy9S!pha|wPeP1Owm34JxE>@t*I_^h> zYV=G%acU^fBC2BQa?YofZg&1xm45Flt%=7Dn zG2|Aa8K_Oo+&QVTaLp7pCQ=^*>no--9T_#b^;6kxJ{ziS`+s;(W>>#HCfmk#sp`!{ zg+H4;m-%UixVZ+4Lg_AA8~K(FnN%xnEVqs}85sPaqj~;hriV0f&=xsd4_`I;RU5Cy zlU{G%1+phQ(a}A=r|ICgNnOH`$1n5W+qi!^QsTBgxhQ+$~13Zi*~Fr83AK>(7+K`2I}g@`iMO! zp+}Y307n61n*Rn1Or6$Z`*bu36(Kl2&+AWwbvwJ5dvPHvlMRhl|9Sq7Fyb<_iHqTh z_Fc|}2$!=^+dU?FB8B>$N{$E&_HYQfg1C}Ma*Js4C#G6JgWOCIS^W6D*9}M7=jTu3 zUFCLWXT|^0YQOJ1v#F^hM_2HC&8xDjgd8#HC{uo^*vLM5|K-2&K;d8ExtMmAf}+4S)VGK&R(cTXOc zX+d1DY^j~yND>z8;JTN0V(-@knQ>Z0asKxQau|Q*iucz4> zx-!LdBSyd-);Bjaf@NW&VV!?_yqqZ88^0Wwk$bsIqt7x)pT^xU1MHmNe!5vlFK42@q?95ob?7^F-b`f01RLKYmt78>N>h6R(ZZW6Hv7Z&cD z$Z<6@H{=+};i{53N_B+w2p49@K5hX&D5CHyN<#(Vwixff>!4hXV7`f{h)~IQZgk{m zjwAWMr<4~LRt9Pe=TP6?@l0_OIb%nP&*i>E)FihAWgE%`HT0cu~du>kMh z^W*5N{XKn@G}Bdu;R7DdC>rU~g2LJqw@-A48p_d6s|T0WEC#S}T(D(pMcp~dgVk0U z1B>`LKjS)Bh8OZ1)>Wc%PwP!dcr%+|_9;D;Bz^LVBgI_CMjAxmbVz0LxlL63 z{{D_oQ!hu6Emh(Xb%(s}#Y=J;gUxi76N2Y-YNM8cXx5(S z)JtkK3PNhcidMG)$|K)Yus;@Z&1-i#8F7`$WpEB7?m=8$O?Bg$yx}og>zdp+fUnu? z(Ok0r{Q3}{?X<_h{44gk@3volQo35f^AXH(aHDnf36|DABchSLv(0U{u5~c!7;5gP zQsbT@M!JnB70*x(!sS4~ib79ZHLn+^|Db@$s)12Pj?@~mJ62~z&!T0HsDxpuoO%`l zftl%bA_G52nM3fwka%;!uhi^tQ~qug8_TXHg=RAj6?eZz`;U;ZT*vdg@B8wCC;A4O z?XQlK(%Y-T)7;~m`W8U(oAGH2bli1s*|%l*50cNT6V~q~x6mWBG`eYZum60_f z$4HxI7(f8D%o>3+9p(Pv>njs%(P6fPEFy{#M1>eZrR{#W>Id%U=|<*cjsXZZJL)Yb8LHQ;lv=y!~-O zG1_4noBEJfiT^u0Xph6H`omy!J+%d~TWJ05#m)js9$RLYW$E?z>bHJvICrv2xk#m& zsImEq5g%q5pJW?S4j(eAtQSkA2Sa6_uQ$RsY8qUR?#FTiRXuyU=btHCX|}C499ekX zVgqRw=QO!V)5)kbJu48}DRAW$6!fz*`%bbl?I3iEHRto28XNR3F(aUB3kZ+;Y&xhL zt4PL4pEf4_P`HFuS1$K*qXw-}1cu?*I?|Y`sagr(hin-vYSZ4;d$Z2RI`13DRlbqB z=pVnP6e!7Y(5ft{mQme}%fA8Yu@+Y})daDPYCDAw4-4z%@)`PUA2Frv zDZ}hCykpsETBAH%jgo8q!bUy>&(0&k^2XC39D5aOD9Zq~n!(m)XZ^sK&r)Ke;NirN z0VjX$_R&h95PsT;{1$|b`)ei>bmIP034pX|RkqB1cCycUK1b-4^h7RHPA>+d_yz3L z;1HW*x_50t6O2~L;`Evn2RDwLoCAWWW6V~>f)i7YKo+E%w7u@s*t*N)oQ!~r2?h0$ zAJaRMGq1U4G(EUBYObwnP?zcxV7NzxuD_Iv$zB-NYZguY_c>Ym(=!C|)vD*w^tupz zerQ+#UmeLTio7Mq5@L2I31S=q)2l4@fS9QW_p!9^-4y;@w&D8vwf?>G^QOo8=kxZ{ z=X+}S!~1E18y}kydljhU?fbH>*KH%ZuBYbOd>YupT6kpFXWY<7uQoXdxa z=k-ikeS78cxiV9G&E`|wRPqh}bT~qK&g4UnKBiiVKl>}jh@P$_eNFkqT{M2%T|k8% z@^vICP;&vrj$5E=7+1o~x~{|>+E&4eWu&A_I8lV1n7Ndbydb^ZKO=7{!8^P1sR#sFDbuaE{H;rLxd-82mz zb5g83j#X)kZB7q|X%s+5izqk|qm^+%l3Y%K$l6EUMsZ)o$V)2iyrhg|z7K-4#SIC| zn30XtBB7x3VtC)7LNDvVHFickw!-{xGa3WEg(DqJn*+x1+%)cL=X>cev9RN-Pt;*v zdc-v^y4m;PR-Rr*jxu1^X_w2)Uw1ds#lIfz`Rr!}5l#FY1lNDK6XK5M9Q6K%XBzd9 zHPh^i7&- z{~{Yq>Co)A0-vocc=-6}?GS>_x2%z!AF?r5(ZnHcc537FRy2qyb8Df0!h5%Shj*%5 zpYktu3Pl6%nYw;=I2~ZND@v;pep@Fzw zN2x409q*^b*pSk=N3YAi3?2K6&a}#?}K+J@?)Xw&FOwgn{#)DeQX)AQi%hl0q+UJyA~3- zF6gZbF)Ntyje$;xD}vqu@*&&-1Sd2t6V#Q81y+oN(4-p!#%01)h*Q~eGZ6=o^J`*$hIFofPTz|ec}yz50flK}qu;=_5}e}ezb-TB#l zyGv(`2X4JNm0_%%LM#&w%Z%d*;){QBNi&}7^Ku^eL=VVgEfN8U51$w6S65XSYzsDq zCB6;%Mv#4Z`QFM=mhtJ zMIT?vL43wEr-^vOR>fv9)SR~sAUgCGc|-8a+$AsrfYU~t6s9ulZtpvW0Xn`# z>7Pb|0ntyBpLTFff~D0mp~hxb*I7LU>?Xlho?}Q-w0=0yRX)q((T(lRFQb<$D|o(^ z*PxxN^1ufh%ge_hU@?v0xk4os-d4~~gSd3`32#6C>k?mT_v0nNxv8hhuiEqw3vJt? z-#MD=?EO73A7-sXLu;V{m%_lpv`Uwil(p%)3eRb}Yk~qg+SwT-W`5*2-gDba=&`Y# zZlbo-78-Urlhm-DWQBTi{y{E>x!Dc+h$^vn@NdfIqP7TiOL6mdxLDW~`2)x&{R(AP zMJnO+OyHkJ*?A~e@L6AWE@OTfL@25Jq97L#E)OwL&LE$-MxRE&$n*Kw0X~j)*4ul7 zM#Pt&H%nEz6s(NiFJ!i5`$t`gt-j1z;4S1RGqri_SFjpyiR*NSXn>M{2B+q(0MIu& zBzgejCGG4x;3Ac0m-j$f9*`TbHBO{KAVJ#TMl|_RJLWBPfmv#pFdz`lTP%cmuyzSp zojK}l&-t)h_9P*~40xXhqXl;Zwc$LNs#(V2&)~bX;3cFd5~UH$dI_r*R@*%E!I{4M zw>1wuCRUdwoif=VjJnAJYY288Mq{WzEhH>pfj3?ZCUAu>Tava$+1u8DkOE@1CU&== zRvw?1MwnEwN(Wg;TmVY&aMpMUntu>J)r;wLO9?U*Xlfp0{cdMrwf)U^xb2t``TZFk z%l7O2*cnVAwLTvW=2Z6FO}kYQWo~lLsqrUlh(-#Ny#>Acf6{*i<0NW3O7g{Y*=|16UakP<;&+o=gjc)i|vc(>xIK>DD7Y;@H!@_&HlP6zUK&ZYA7nY1b><0C}IFQ>1gPqZxxD^kHf9U~Quc3ff| z{{Gvy4#7~=LC5-%WE;3te52)1q__6*F zf&;~dch`F7Nr-Hl5*-c&M1%|lPxQ|B&SC4b95>q$O`n#)pq)Suwb zi7{Ku++jZDp!U9hjl;}cZNbDBv!B>L!xs)zZRvQY55K*KN&08RC-w`($x;l0q~{C< z@D;+sH5WMbqQ&EppW0LE5S*6jLqpib_W9&-4!s5D$SRfP=^hLU7>b(4)+rSF8hT(Y zEJSsNzNzDbl%(Qq@M3_70ek;MimJGP9f2u*l%niMM-am; z3SFY+7b(!Tj+@GnwV=uodO^}q2Sn{tUtA_<&Dy$*WA166q{M9~;ebwZ0PKO|(Gpn$ z+UA{6iGS3SU`3btiCt#Talvc@87hw)W=|}D1wqoXpj3?63H-?DH61XvVEjPp`;WeTDKh$>}K?_<6yJz>xuq^J@GQVHWfRMTtLMD>Pm_!39 zeZR$8kOJ}_&@MKHX`pARi(J;t&@Xv@_0|rQll`gE9cPnHDByy5s zQn3@cX|^T%Ig-~{-d!AzngVe?1sqW0B>^*Yzzhf)7t^JHWT`YqH2i|t!H*I5?eSsZ`2jA z=8XRehCSnddYL?zjmjpfMoIiQJ=p!_;B7K}v_wyIjK`9tltAl-RRTN@W2d(7gfB$4 zj2>67jx9fW%AC!`N@A~`gWaOF;HM|l-by}`Il-BTAT^u0QC-BpkC&Qdx+TbdWADWK zH^@tSCNuWh)D(sAD_ap-J@82IRq;t}VT>mn=fYJH)s;{Sa+q5N2{-thii6H{S`arq zXNtsfhfZ92)!Q!k`L6s&k*Naj{&U;Waf~#AL<_pPkh{|2Obcao=WxHG&oJ9{jQJ2Q z_NOT#MaxONgI@s@2=W$0O-xe6G(8KkkUk@Wz}16594|vaUIT@XAxV19UB zhp7GT<%x0|xHuP^RP&-WX71Mv+DGHiKpFm<|M<`XbS2X9+gH-PlEc3_s=cET+3nrO zMRzCJ6n+bilzMjqbQl8Xx!)cp+BZ~KfQ(~!R|9_7hNIXMOo%`Zl(?diC0F=DcN9M*87$*<7+OY@-8lj^~bm z@ha92cHbowX5?BY7a)D8zmZ9wrl@DgKFS{m7>a>MSD6}^w2&$GI8+QS#?!$|Y3UGs z#3XHxDVDfXU%xww%~ij9N}%d|Si0;q@Nl2kibUVnTllw0Ju-c$E*&@x9k_K&k2?w+ zSc?Fkd6)11pYFh zAGN*4g6g}^cW>-y!m6w`;4HfO<0hK(ZK0Z+Yw z=8mvzUqtyX2^;xNtmn?VvSIc&CLc_?F7?}y@)z{!#5bQ?8ShQ{nycgA{N((O4mZwG zg)Xnq4`u@1`;O&Sllx!x_8nGU#$HZd*KU>{ueZ%ZjS2hNk<82TGQJJp0<%JQz&Y>m zDS?f~xtX_qLn@v<^)t^Oq%W114Oo*pL2gaLoyhawM3!O|3>xeD11DJz(kx4BarpZ7 z$SByW9Bua3LknV8wYx_B1&oHL2#ISh>sLRE`kHs*uJ<BX?y*ko+<2mRv! zhdP$JpOPCdK(+|+>eS!a*3sXd`W0=OU&by(yJ9=H)GeD|zdC<>bVsd74hGT}rrX|M zYT46S*U&wSwzdzO*P6ROpw^d;EU|3xGkXEf^v+eYMo%v^4zUZ32KMG9BEWP8uYQi` zQF#pBkeJ=$n_)LBD_Mwi1&qO2wgzn8km%gwnPGD*i^jB+>46lDBhDjEm$Xz<&d%Jd z<1@`7ynK(Q@`&Ldl2QXK5I?O+zn#u%-LxjIRtA>Vtiz{kSHg09TOfz-#fiDDG=7VC zgkZaW=#37;k|aWKK$wibZWD0V-%E+wOUhjDdw>?$-+$w@#4z65ZY2z-SO(jOs$Jw{I&c;N=Fton=a^x*5g7T;85Hfxo(n~Yw*jAC$& z3`23cZW3Nb6#rhEiD!1@^Ega*7`t?tz6%0T z+&X$b`wfzPa5DHW5H$al;qc!$LyTx2^2JvWS=6o%^qb zO}x4by@Bg>tVFtPZY?Zyd^#)skcH`D1!viMb)Cp}s)?`ePBjY5y_ebIvU;TKs4ke>1W>K)2Z zcVvyf!Z4QVN)As}d+U)60gJ%Zc^(G5hx#%CGWvJ|c+!q@?BNVYwe{anUK)VU;co6F z_+xf7$Me*r;c0m^47C~dY4@V?mrQUpsq>OeudzCz-;o|j7oZyYv;wsL(L=}=><6|b zY(oeh3{S&Fp(uTymXf6+wW#z~BDbMW#77z)3y=Af-w=#>)*m`EA!|R{>+!uVoav3E zcav`SUOOLI!XcFFQ_rtqD=GJf@qB9L7>n$qn@_rBli;$CFQE9Y%lm(I{rrI1oxqlnk|NQw+hOmFqul*m@!u{}({-q7>CsO~e zaQi=Cf&1@+`wz0W|GxA8*6lwD0RQtt`1hdx&pf98`Y8SnJSN6}C2?c?Pe|N2SU5QT zgT!sp1KcZ7b?b`rnw$4GS?U5HQ-5p_10*CQAQ5STR0$;sM=lv5Mv7cXxM~!L=FO-Q9h#!QH)q!QI{6-QBfuclp@e*t@@bzukE68}a?~MO1WW zWmaWZpNu*u;?$G*VAY(j&ztf`UVQTBXf^>96W_p1yLeUhm z5rD&h%Vv}hs?c zhFk#7pHU=rDv)eT(qBirVzn$}#brkh*A%K(Sf*#1#aZcyfqgEgR7N-Wq(#3g5E8Ub zsm+?%Ozg9YMI9DW@p}q*PD2zH=I*ZQ`ftC6)&>Uli$Xz*^%v7wnan2AEEONoq~+Sg zjntsBYiT8FCR-OtFr=)$3AqCWbW97`sK2#|51HPiAbaMMd8*p5p%x|Z@647M6?5kd zB~C%A9ZZ`JPr-_*IovAdaPKH@=TukYnw3(q$E_KTR2GG|_qF^A+w&|oQo$%mEIU0U z%-x}AlBxL_I$(;FO=RcqNm?C(^vJx9B~2{BL_i{_V*xXjQdj0!!Xl1o#Gf;D*bO+Y zaS8>KJjW4ewCx@A;1f0oM8{6&KdIFi>Ip~I8fhLMw-i({_ZSc=D7cMbKx{m?D5ld^ z*V)rjYrO}F-SgI%rTy~0j0+Qez%>ucu|EZRoLRl+%T+Pd>`*9$a;NymeBL&^Ym**z zq={|r#;tqR;FxASR9nTD$k{T$S}u@n z)<+9$wx~q2J|oU6(DP9c<+~W3^|)ie{rS{6vMB;_zbr=I+GhDS_+U+f5l*l16ODoI z3`97Q7{2y)9EgXezgjOfG0wfn*}D7os$fFUir9+i%;EGRWUWx)vvz4%%bW^U^$Y?? zI|yn3MQiAZe&Vg+%a;<&-R1(cB&(+y8!=4qp`yIBZ;;RHZ)Oo@XNUpb0?-%WO#+E|3n;DvcQ260Z0&K z2(Ofn&ewMwY#N29JFp`G#eT3TQ8+*#KmzDRRpQq_vVR|daL7n z%hs`qq*uK>`fXNGNZ-{S(F4U;b`sa#@n8OGJ+ZM= zR%tz4eu(cUiK4DY#8*x{it%3MX}cOT7&#ER$K$K?B$B)Pa+* zIoeAaPemY0NGVBK2jx}=>W3D@hP^_G{A6i7 zoO7CibcY_GFqXbaDQ|T;NAfu}FHgRE5Y0f5 zWF~=t`wzKQknBd21>kXpUSlZvsJ04m;cn?s?am)8U8se}17VTT-AF=jI+zL~b8){o z8Q;d6nUR_Gj|V8b`flqcB6)TdKb-|7ClIab%|=iMH_n?B*^o37$G^;+1tyy(y(>^W z#2*t9BcRqyN+N`rr8=I>^NEk2?zdYrd+u1-?oVTp#OhS5JAd6|{7m0HOXdA$DlPtc zxj0RE&Dd7GnMk~O-zE}y7fVq3Mo(>llKPC-#8PGaw(qn%Kf_&T`RlhFxa#DIFw*7f zmFcnRF&~lUmOjHngAHiJY>fdT6J1kBy#{}&eA2SI#YxFIK+nEUI+*8D^DN$Pqkqe{F&L>>uL_u*en zqQZd#17TeuC&VMqE%4NMI_dHaWwUh#H`^^e)A^BOX-bKyj9H+wHw)23{%MMqY#T*a zV=c43-&^e1sd9;HHBz>PO;p_E3?tj(hk8r}n9{a)g;?oWhO4>=EGr7MiMhSKg~_Af zm}w2a%6R?jrc=(<7~+tY0oe&`s3$rsTJdatUWaF_$yH34sY4=IB~Pmdk!eXt0%tdG zB8K~9tHw)Iabea?;+M4H6kZMa-HW-cT>*`D5%4EK3`~6dr1_~I8IUmu5Yeg^0De8|fv^PDzf{fEvqJWwgqec{h$^dGA+`OThL;0ez|rL4UyA``QR zo%F~+mGVt)@X|4BH`c6#x%s4e-BraAaZ%mQEWLzF3SEMO+3PpmA5r$>Xc01fHix2I1K6 zcdUu^(}bedr0xOIQ5W9G<+P$zNvAPu$?OLzzo%W8QwH%I(2B-m3WwjR$D+kpuV_CN zAO5#acD{7T6~(X_;pU^?vvOAb(>^FYg^OW}2TQ+Ag0%7%cjArwH2VwLIVK7s+Xexj z>kFu$o9yu)7N8T`*E;HM_g<~^X+&9abU|k+MLTgW*0XSKdeetS4HRw#DhIss+sUzS zo5t?VTZ^845PpX&Rh zQRaPnn5(R_PL z*g+IPPUDx@FP?J&R*oHW&L@4cr|t0Nz_eMkzObpEe(eePwos- z#ka`>Ok=fy_plBgGFhxFWUn_{6OHd>^FRlZmdL%0Q&BMX9Q{^nv@N{7dmT$lEg=$7%Eir?aO_TBR7%Se?vmyUCX#Yi$g z>n)?Pj!LVmK5HmB+EE(>4txhs@G=VyqTP z3DfZHE4lPTp*59ICPSsEn?)}~`}HuwEoGb8*2E9E5ISd6`u24jm(VApo7q9*sD@}+ z3jrvAvU+r90C`6m_`Bvj-mOPsWt-+3@~Cpa z1O8HY$*$Y!$E7dRY5#U7v1ik3Zu4x%PV!=6oPDa+h+u+*t}#{w)2Vfal9d2RIVn_T zpw}hc;vQNR=W&7_$#b_}Z^T7LCVkOjAkar|(bc;7doDoA`;Wx*+Vj&DuFxMF;M4j6 z`TNnm|AC?66ZAd}z|#pRdBc-fq$`H~hjsnr6TWoBcr7 z#6{}!=;>>^4lwxwAI=U{SmBQe9rcw`4!2`tZSQvk*wzuvnT6V7{N=_Dqk(&v#iy1L zCNXwmP5%0wJCx^6U<`=I*%T!#R5A{KgPJa#4;HZDbH{!Abz@hi&ECVmeRpFA{h86_ zrQyMt>h}_+1bDKiZ;TvD2rUdHllD|7jg<1C3}&Kk#t)0u?Ro8%3fl>^26XFK5R_0F zyJ?)H-fZ9)k7k1g^nNE>g0~`YCP{teJU(%}Ee2_VaD+ z7!J7}WPiiwBos~c>SbA7Y?=&Z*fTI%qa+Op{kvYEZjEyNNW+ujwEM^t{S0l<-G!}3 zah`&C!^MSl(Gj}JvSKQYOQ6fK5wb+0_S#GPtjl3VR25>O1cP0a`+O0FB8gGS_|H9F z{c?huT{5b);_(M>Uirkv2s)d`9p@eEqK;*IBc>yRc0rt@Fj7BZ*oIhJP1wZ>G`W~1 zu%#@WD;=up2TvcTX5YRNp$@bTIYTXt1XIiwXv(B-lucHft5z(St&D9+4G!b8TZrX1 z(*|ehuny@C_4C6l71sDn9)|a2QA4P1E5_Z4EElLO4_<4yQC5$PXB9&?wqaQcnGc?< z{-l**K2+I^Sp!SEjCFL-XO_L?KAY!rZ&uGw@S7K)`v)|HFxkpm&g19tXz?|ntg1e}hOt@8O0>PR!fih#|{3-aAt0xS-O^4&Ryi;bU^ z@YI);;M;)X`3DlS+XsQj^CDQ*qXw61b>_hP;cxRDD(AjAM`F8gStqSr3Der&i5@2G5FTJ8Y0a8?6yejTv; z2V~mU==&#F*u}Xjj~2NM95{Y`T3@4*)eMr^K8QI^qV}>fJcDYH49%1vCf>^oEG6JE z8X0{na!NA^BqJlk_QV9e^;V%$kgh#%p^_QAIp$B*xdj({|28=MAjUr9uWbFE$7X6e zLvqTdr!^W_UBF=FR-EJZ%Tk5EgT1>VtXGrc!5fCzlx(rlDT?|#BI3&AvfaAHq{Y@M zk6&%9WZ68ZhKZP(w%Ad@UD=)6`ZDEJI_1?=(p{39rzSF&YJmFdT0GxT;0t-Xg1k{! zE=UpGZ5R`DJIw&7*GWjMXXx5`if65QMP|RF4u7?3hEPI6QoWOnA8T2@3WySqy#?SvH?| z+e4u4F5QsiB1hbWa7txI=x3A!*4S54>F{6}aw&0WJdu*awHy4WN=L<~S!^4bx^?3< z>*L{827NM_+IVGR&nf{vI8e&M^!shlHeTlRts}{rzqibrx7g*m(-Zf!(uJM%%OWGk z!@!}*bw^pIH!-8&$qagd1m$960}3v=IeTE}tKuX2d!{Gc1%&}4O`T-$8pWa*q9b@V z7~T_&>Lu?Z#qN7&_WN1XjSelrEkV_GVAMR_{cS`GS#|tuj9P9CFCc^HTmjEH3;9ch z&v~6+tK>TAK~bP{e$PAVN0u7)@EJ@y8J-F^%3R08_(Q)LF%RnzBG2em6fZo!(w~a* zomiWY^PNcHIg55XJYj`}m_<8ndzAFTA9d0G#Ansm{5eltw=JeB+0)%J@0i9B-wC8i z>kfm=e9~t924XG^!Hb9#keg9onbJndu7|*@qiM-qHnm%#SB2ibC&qXTQTv+^1s2c~ zNg=nyu8N&ec#|SVLl2qvzJR?pp>Unw53E9Km+cxkm42ry72bh2!Y7W>6`qfEGUQwO zK2P|8e-SEN7}6PR*{#^kMR`m9 zCE-PEwF_&Hv2%gdzYF&m_)E%*P=NTCllFo{uAg-KbZ%6^HH%pf@+m z;pKhz`r$k$*Ze8bv1zTKtv*ceRe%^VezG|7I@xn)(63!m7}{K(4eW^hc7pVK`VTns zFvsj26uzRz)I&C7CD#Emd!C}V4J=!$j^ZBPrW%bJ?NbtKjqXeJ+! zqN$>xz-QO}U}rF(*f=~QnvjTw8DWX_!6r9J6yOJYb#3oZov!8wg>dMtVcgN~$t>?q zPT>?4b^LKEiDSf$CG;B{&OKc@M|lW^OycqGw`2)L`*cod111J}O=a6xWF-z^MfcKR z>PD`p0reuonswkz2+*lv*YOHCZoySF#q9$p4yfK=Da+V#bGD$tQ`r9PML40YcMDXw z`65!Xo$wtAoE=9}^*SeiSBn?X;WR`F6p%87ausEE60Wf zj+ryRLgL)B#|AbjVa#6b_g z5cd0`Iq6(NWGA+V%p7NuSh--9C|5_7UEaX%1?loNZwPFAq+px{pTu43uc)5L;lKoK z53t+9op5K19TD)I(}Ryvk@>>}IUy|Cq|(*o+Q;O%urj(hw8GDp?8YOnWdQjIpMtF3 zz8+Om0U)kxrIH7yUt_(R+wXn zSY$BpRMxaO6mqM_4kWXf@!bfJUkh_Y-roMLH)r6TySMI zQ!@8(9@-`5b+Q9ru6=ArJO!CR)RNJdP3h$&Vx=k z3O742fLJ23XIKR2Zyry{9xA7dNLAl_Qg`>2XFs}Tv2VHmNgZoLFXyC3vcEBY>TV*o zI!%zbjR4Ut7=DPDa8DlrgOgTYHQ_>+>=&J?tJD=zjC83gy=fM?m-yW4tDpx3#ZpRM zLI{XMiv{&RSp@zdJNl6z~r*aNuDjl;!%e~HA% zCcTnn(bGC(EllSwSjVD-lsJ^f*b{+!4r|VcP5h26OgC0oqZneH2S4UsU{oQmP$Xai zVPD-CXkk|gG-}BrZjIt-eQ}2!9%xhthdENo7>w!RPfn6kU@Woi-qo;J4A)d-%B!mW zeM&(JUW2J~ly&!`mt+aLOJC;CfNsUu<>y5Q)n6E46Wf>A7!`f$e~{7q#_G5FC3)(N zONlV6ezrduD(BVJ<>ZVS@mO=I==B_7Lx*5c^nJlg!9nC`r? zDj z#$`piO}h3~)k&`-(l>$9C!5ODHmrA;L`R61U6wb}?OdFD>XklVXL_2lXG(vlEGzmn zQ;aVgnOH^~8;aguo{Z}G+qCs) zD~$k;xc3znsEuHC%cprt*`?a?ESfN;Bz3ZPDsPo)269FBtD`C$|4>LrWJS!6iduH< z*tr*OQ$&>a%Jl(AOPFVsF#IQBgj5T`(J#ZFI1^(Sz>LS>#I9YfR&T%U@yv9w9LKBc zsTGYV&{k6(hlKFp;Zs!;ps4Mbfxaaz78oY-eqKB7Ev>GcR*q8Kze0?X_xeI(jttQs zMkLB5^m1In6Kd6dMD(CkJg$2($72YU{PQ8%fP+uyCCQ`nm zGD5pTEFzR%44hsD)%cVZa~DHQTnsR2!;C`ogR#8cvOOMKZ~vh^cX@jm6pHKQ>J&9i z=m>uo@_?}LIj}Xxu&*TG*>j0LHmaS3Y!wOKCvlYLOYOiV(Gd;)0m=F)2nObXgudnr zbU7I*CHnU_-NR_Wry~w1@WKiItE|Z^nNBysZVY67QM~;M7?}6?=r8^x0A!R$%IA(N zNgMLXH$&2tu*;a>nA~VB*Ae;Kij(^T%aR*3iNsWKuA$g^!h524=#vvW}Kgb0W_&;a|pZh;32iFMxBI(5zX(anzfml>PmmTxKMUzPpiv{(O>h)lzaFW^zfmeUMR1j<7mjFEP#RM|6-gl= znYh=G=*YhiJzF$bLQoM_j!ZZY2{j;@u-BESABIUe_$!g7;3|EuDba8MC2F=}FbYv< z040ikE)t3VH|ky_qObmg$iy073Xs$U;n1=>kWvJ1P_rwLJpBievKx>Y)vd$)vi`;2u|3s1-gp3n^4S+E?4;b$HGy#%}wp;#Y6KeE@W-&0> zRT7@E?Q>q(rR68v`fbqXBQQ1fld>Utn}oAVW0&5u1PsZrR<H24*7Y?iIm})!Hj9mR&V@uo8B4fF^BP(v+SiR zmc5fjp4^kgq9KK03W|k<1@eV>S;=zx3ds^$*`m?nc=CK1$|yVs+i*pJ{n>A3j`klV z{kiC*@Rc&yLh-RhIA}JecVn-%ceAgah*RZ-IWVW61lmTvt|xDj4hC4<4&~VLN+3;t4T-i8*08nb4{Mg1~};k=+uzLG{Mj& zsl4g}n^Vr_;EXUE>2!1Vqk1KXx`1XKfbbKiV1rX@|AwYO3P^AN6toZv{=`$D!>P6D zm@zW}^xAfeoQVQ@ZQk$|oO61PfM^SBIMcUo*a|8*JwXv5Xzno(S^)#6=QxN3kZJ$q zKeNHQ|~cjD}d(W>jXss&kkk}BXHrGqh_c9G+b*VW{?GY zz(l(zh=M#IHYeSdBVs`x5W`M=&7VM}q_Q zSP@VGt3VDY$(3MBy|377Mp}Rj40OQmH=`^d0)FL!-&gFU%2dEF&;)P+tGT$ijO?&` z%?Jy?fKLw15eno5Uh5a;KXm|}oJO`sV^nK6+HjIPvteTS_L5t(aSGK7;dJTbcJ{74 z+u!*($=rpOGFHE~l;8C5urAr)|S6v>vKd1+)Tj z05Y(fD}^h-?(3f6w&5;XH&wC%Qo(ndLB^k-C?F{KDDWugDBvmBD9|ZV;(9~uiN_Hb z{SZx|%fVHA*f%*gnJ;K;VH&@@Ks@kVz}kXwBEG=AdH@DD5()SH?fUncxI!8Xx1jdTSn5f@==!5P3jeAYVY|3F@V zkNudd!q=s!gm6V(M6iUVj`Re3;l04UpuK>*V68-dK&^yy{b~x%4w2?V;TzEj^+!p4 zuN1bruN)DG)qi80z;8wT%|z;w zA;Y26p|J)e3dA+Udt)&?BxEMJWc9iMFJG0sFi7IdiHsuk%9bOi_3*VWRS~uJLU8&r z#$%cA$EXph2w3Llq(Oe@!#Ym9pdgzk znS4-w%a%*%XbgVeWwcN?gh zMpf=_FU}X3UDYhEKLNf5^Cw(2`<%En#$(lrKL<*=YD~sbWpLl$y$|1O!QS}@9A9ZW zdZS1CO}~$3@C`8GIMTuBC%&_!1sK!(_&AL7dtYK~5sI}Ni2n2yNnVKO6Tu{cCfKsi zhR;Z6MJL%N@de`Mc_%|BP zi<&RxOV-KPsjn-??m_=~AHoIV`qL^m$Wj->7LyUR5h59^(HGRos!PoXnG81zR`(sA z5vCBT*hf;Am=Ww7VmL%UIJysPBi=XocnG8KR6oJdAVfOFbw4wreFI1P#Pywh^K-S2 z?{{xP)I;bS$fr+O-)#u-#39_lioSoHjGKL#C|!M@E!g&6_IW=NTWZ+n%pQCPw;cM6 z_U};Ee_;b=Vq{`w{TI&q-_Zdx{ol|5|FGU+g!@40bJquTN772s>3*hMmO?nCXKz8Q zB%@}V91PsXy?Q2N6Tw{c8@n{+B&B0#2wD)z;8=U1mExSvp8*`uct_6i3n;EA z;myiN%VL{i{V;qKpd|xmh8mtjty5HY3U_E(iVUba=`u(HjdzOuQ=@f!{02410f6Ze+?59v~eZW_@D*;0J774K)VUqIXFJ3fj=Orf5)jZNI2?Qni>4C zHnB7!Wc>TA9}Wga){Y;fv;T1NH!%9&`gF`}9Dlb9>Dh`KnVFb6{@u;rRsSny;J;&D z|B8ZTX8HF?2LEvRe_#gwx0mHVqwCrJbw&Ogy8ds$_`gEev$1l~bN+)e_b=jK@xp&m z|3&=Ai2t+Vub%#={Fm8(5&t&oFWrAH{-+`TN&gow|4aY>bFu%cX@B{dzli^N>i@9( zx7GjW&R<;rd-0!Z|BLmXs{j9f|9|#p{^IE0VB7y+T*Dt!&;Po?{gZ2$`ES?p9~1vAB8UuyDLY$dj5=WmEd(Tk$F-sZL>dAx(D|Cx}^qHj8~+$P`Vj3Sp4 zroI}TQ58Q{(SOhq%o62ITSkd+-^6*f+ABe z>No4pVjB&fZ`Eztg}bjL=TTT6l``|x?_6?@Ro~yvs_a)It(WliUwZ=2eyUEN9`+NK z|75(~+Z++;O7i2}QU-cE_88@4e>F9Lg25@bifI}bfq#Aol#CoQR?9Ru`7e^0*lGgpAIXnyVM`bXX&+Jgq<)Hp@$H$I)$Z`$V*) zh&Z8oR+nN5ukMMo{89_*LQU`YVY+c97HV>**(j#tF{p@fEjAZ5vw^)a-xilyMRy!P4I}dCWlbyy)jw-vXjl>q@)3((4qorO{-sjeIHcL z51jMgQRO|{?MhzZXmMah=pKT3v++HN){)58LsLDNT*FUeRZLvp-(M+VR;pb2ilIMR z*9K)+BFw(v{P%DCJ5W#Ol|)s4_y=-jiYBoCEc0E?)Xj*0;g=~a{1TFm$BVL?{oCrS z^2aICgu8BB4ShKhaQMkK>1vLAK1+*pHY1*>ij2cD+GdU{mnU}S)NaNmng9L8j9)8u zVeg9kC@w5NvYfX=IcZnI&J7ig$~{gyr^`seu)lXtg*JxymfVjPNBSvFXIxV=eGMgs z{R?b2*h{0sp~h)RFm#P+;I^0xxI+@kJve(D)|o?<#e}7LQXx03oR)dWC?9)5*;nsD z+_b?&UC}^PW|Ex6!Tg><^8P_6Hfjfbf3f=s{TZebW-&bWf3@@qpwJDDbVEdcA2!bB zbYrEFy^xXC4>!-Q+IX{JM}M@1$lyBkqwq~aTqZVu7#Hsxc)ycVYs=))aEuMlCtG?Z z?VpyPB+|(+D7PK&G8uy-pp)DRV4*|Ab4bWZn>F0BZ z80TZijN>V=P}@yc)8tcK^P68#YKcW6b4Zw6??i>-)Cvg{^#EFN98mLO>*h27{B~E@y=m%M&@HoaTa!X)GOLjvsV3ip%K); zEUdOtsx)tXJi{?3TJDdvcse`{FIPR@9!nhXJM2ZTm4Xs0_v{3pjv`W$|@l ztS^o7(%6_2k~mpTp!`1gA~>y9hYr2zC&Px#?MtiIO<8+ew&I{G0qhoW;?XBNOKKnB zgX(~7BiOzX{g5OPbOsH|b+93f`nXEJNBu=2fKwOe9ORB7-+`jm@kisOTne^3yuf$l zK!C#&O%D3<@#GX0Oe`qJ|Li*F9eg3kBztB6uXdEk(dsTpqB4O6)@JW7QqxrLqT91H zWySVHYEw+ZB9|#(BILOfnE!`=C~5nO4Et~@0@}TVnnR#j;_i5iy9{Fm^vtlYv#cJy zQSF%lq_zBo#|EDst=-RET)^IEvY*}mb7!<47Ms9q7NAVvRsD1kr&QpBcrKwh!k!=# z4ra&Vr?Ojvi$d1M`-4 zzHS`X;|Ls)JEyH#B<(x~yP2A7qg*W9hJUyJFj7stiBO%wu1a}qk>S7 zUM_ChO^=X;)lYomt8lKJDGXr&Nq0@IUdgfbodGXO#T7UyZ0;UwYVso|91ab8ISqhB zHKpyQikuTMI2m{;sN-3eb!&@iLsSxK8NG^Wzkipg9e*!!~cqFvVYo()nd$rFxLvAk{O#VTx_E|{5o$A zZK)Ql(|YipNnU;e%!zUfGiYbU49v&UcGaZE(nbyo{wf;{&M&=eE!-2$?QNUdZrAw| zurw@W62q5l89WV>F-Mbq1*EDdWyT7jG*wrvzSr{vjg|GrYjkuWD-|@rdPiKHjkhct zwiVkzWBq`Rkr!_t!!8A5*I|J_p`S)*q>;#pY(INp0F0R35JR2q!K!F?WP);<) zIe9G=Ed42{w~V6TnfjyVd3A0w)GzFa1Acu>Qk&T%t1OtuA2=Qq|pR5Id= zl>4Y(cc*Nqtg2RNfFQw@j9!yEoig{yN*SV74W7^#QgQE zb8rJ5*+=e1wP!i)j=^?sFF1RIC7rgh=;v_Ur%bzra&82MYi`MOfLj0YSXlTIhX@iD z;@Eb!4cxQZ2zB#B@@CL4&xKPxz_5kq;Wnyz_r4+<;Fn^it-;`z9Dx9~<%Kbgu9S%k zyXc}fDMN2!_;9*D&|YqW2{$d1clQIK&~Q#PR>BoaLK35u*cwZF=U=4k7=6( z^hAu|oF*972>=8JHsg#>29%>?y!18c6U4dbfY-%ZFyvr3F$r6wE9ffYZQAK4b9JtD zM}qWum*4;_N`xBDg*)l(HBd%krqLiYP$zG>H>g8Fu2q4p(uJCe+`jrf&V~B%@WBbO zOv`hE%Lx4#UlSVtzOv=2H074Y;@8=v8cRWj(oUW?&p~Higwo1gIV6Wq!>o;tyj-*E z^G)C>9(rC_{WUJ=M`<2LFF!PBlZML8_=;qRSq@J`Q4HDX7}+TTX-;nUkDb}8Y6`#l`udnyt23voOSjIt~1-( zq!9vXAosAwt+HFs?}kx|0vvvIVpSvhm=9$s`t^yI9&i<%`91rJvx+FWE;8jFbRAyOiNqy z@;XLt5|YEUFA}G|C-udk12)WWH|<>$nDqCF3kUV|*WqdI_EQhhxw2G)BTmxg00ONc z{cS+6?}FWUIC0!yj-}H{k09&Q@a(O6e)$Ho(^_K4qH;dzeI((^!jJkMKT8MbrEh_*z zJ~ZqMzS~N>mjkt)C~RaXM`w!6v;`^d3NzUGg}J>$)YZt`T7OPt0SBA{z?hc(Uh8U5 zOj=-D!qze{m2NI!PzfZ!j@#Tgj{hywB~n~jHl3T|JyGSXVXTp|Im_7tllcP{*p)u0 z$}?f&5k2^vr?m{HPdwBsQvA@-lagmf>f0+Zqu;Cd?N8jDs?mZX3b*>N>~BFmI41+dS)e95WiA(}$(JH{P(!1JHHh!mD^kVabNQFOlqBsw<7F{r9owZ>!<=HZ`pTG+$~sZcZmd zx;%WrtX{s1)KQX|w-(R})o00$S9&tLo<>{Q64LvAOK8Ucv8ldG$Rc>s1gN?dh9~5W z{3(-+ns91Bz~VP0{yUPsHpY3{_u!nEW>C^~-*Q?;ImRJ=nyXMF@|ZauBS(os zoyoI!&U_l8lkqo+Dc3fh)<9{2=Cf2%}o5&03yT?NUy<+&EbXOn{{|L zp3>+2!fZ-g^=oRBmHXYar+xT5_`0})7`?Xp;{`ZPf_@M*Bs4rKA|VhG!)M4~d?i<% z2}gOCS^P}&j6a8uQ;$msJw#L*O);n^oLX>6LL1d{muv1RT6K9fv%5f9quhE!>xO`Q z1bM}CMeG*v0+pAPaC}YKCaF#0O=u$zJ9|C^-IzgIVg4RkW5^sC<#%yiW{B+dM&MOj z#98AE@5xeYc8KFfttOfV3cEN?zZh1EC$@(3E)4p{=G_l!bUCzeBjUW@U0Fu=b3yRL z&hQ429WRt=&D1;rmDWr$>+JikjHFr;X|-qTZM$CP6UDEAOENXaXM>t5;mr zvQFEqYP9TA1i3h>BJ0A&jI0Aq5pnM7^5rYal*ZzM=-$b4Wcgufe&RBA!^A@IqIey% zGHW?^u|oe@qVmGnbjU%*A1V^%=E7d z^X_s-$4KtIKI?=Y${5c@B|Y!;v}s3YAv^Z1QC0s^ubyDuvPIg)$^%;W*o&NpM@xZ7 zJ>dIF2eEXGIIa`QaUgjU$0||g#DUR+-JW1Ftq{@j%52YwZVdpBWGh$ST-nToEm$;? zq{qxnbj;?#sWVze#j^Fe)i#i3xfP%lgLpyHx%4R7&Or^ioa9iUzgk^4p{LaQHouAt zzaSXEGiy?QMxYaLk9X!0@@o`chHi@3TaI-|uMekd^SgbOoox8D=oz|9NmSguY`t1t zaYN8rQe#79d(Z|U&dA2BolgQB-U-89%R@qp;`H!2$#GeKKA72yW=o%Q~U@WB8K1w@XjSQH*1Zyx>fk17!s=6QhG3as$jh zz>lfD$T*F4^bbYvQUY^I-qJumoSS;)&Pe;$NSPb0ge6rqiJPBfx_aYM3fm&}l;7sm z{T+oGlT{0NMX3-miZT^+7)stwJD#6goXdJxEg;R1#nQP4q?^!|#L);KrB-QFtG_qNso3*Lim5XE zmHZ1!qk9C#B7ceU@Ynr0sDZHCFU?3p`QZ%EPo|)~N@1Fd&^9g7TS4$Cm+{4#4T80e zoL19Zf5u*m!8)U~VLq?F-wXj6m-OrJ-7K#jTwHdu-sdVJi$q#v?O|yqb%fk<-#ES> zW;y3x5nNhKh?DDHB8#4aSU($wsk~V|iQKqOWM^EHDC{?>(p++HwA$cg zKERpnXhrXEk!;w|5241&wP?WzycyxugbTJ5_#-?_Y%{B?_Fev|<6d1&s8Q=sY(LJ` zx+Qp1j=&teeX6PTaRes<(&?V(qgnY7;H#0k z-!Xl-mJJp4zc$(wTRyLS(I6_*l-C8NR)V*Qr#x5d-hJ`CNoD?)id}jJDCJB5BPV{X zjyVotPC?4a6H=CAeFH4KQ`=#_me5pjz$Hk_@pNeHl1I3wYtr+5tm6v-0Kw_G`c8Zm zvPwb1d?O|3&`)2e<6XK`lqj5ucjp=<;8FDSn)SB&)8bo>TPYSl z7^T1$>{m{qdn3T0lFD>fL#N^N0_{zP zP3i+a#*D2o2S_fc=;qa`<96b$)y$$O>?G^_m16?y6ZDb?RB&g>`CFF0d(kQb>@wCx zjo+csc_7NnFG^30sLV`)KiRId+ygK<9OM^2!z+Eld(NqKjrDs~YaT_V<=O3<=4zbo z_3wj9Z+NGa$$eQS^B!a>M~6mI>4Zu@9mO3vlM@|j?_O;DzG{GNubVs+D>TB}KHNRM zn={vj*`5;bhv*-|59YEs)P6tR9&)K z*2qE4)>u4~cUx(qvu4=i!l9nP@^wwGw`(rsAQLlQD`- z=L6t!m`BIJ>{aVEGkVd%w`BgPt|zvrhd_465TEcSVIMPT64Bc6a=)Sz6fOSR7w4^= z>eBRRbe;XmtwG5r?UAZzr=yLrBoRDF`3$puR~RdM1YV<*CV?O0nIBp&l9nOZ`il2+ z<~8nduXXYr-Y&E-eKd&`^8|}Iu|BpoXam&U7R0KXV{3C^ezT&Y2UQ!+qt}2H#ZWk- zIVHyB)8_132-;mkCvx1R=(lYHVO)s-&MER{yheD){C(mU?Y?&bjJ@C5saK>aEjE5q z0I{&a?}r+RcVDKyEL+D=OvGj;Ws>ayNcf7b-Sf5G(!S<5c3Jy<6kp?PE_91`c>{Gq zyz@OuT%v3abVtWRO?|tFQOw4Q30A?d;jjUljH_irCL_NsB9(AUodweAa@*t<3~!Lj zKDUba7OK|bQrRtvQ$<9NY}kr~0W(Dd02j7EF)T&W3gFZWxd~XL1vCp=ARFc(;RL8N z0Jw?fp{7UxW<=v(41Xc538&KmG=$4g4Fi!z0@cX@ibO2|hp2|3NO;0^u+{1zqQZ61 z)$$?W!lM|uDk11Z`_N2kAt9g9@uOcpgVbe&N0AK+kv_3tdH^dCcHn2yFx`;f!qQ)I zWkWQH%mRwhb0tHDgaZPhpcSY9q(tN}OhO@7!pcwz^Z-tx;Q&mUufLJVgi&Fc#6qTo zQK1zmzxpCQ34;YH&0YXsiNZdr*0h2H}Uxd+xk^NwV zl!bx=Fj2Sjkv3qjGLSZ4uB?eVzHI9Wd(Z*YggvML0)hVtHb4>fpaqBvdr$%(g>f;q z34~vD{s0ivh~9|-S%EHkAx6Tl5+QlQZ4`i3;WiS$if|hlfFRICDTE`yMJI$r_*Li+ z?x6jXJGcr%Vt~DhLt=or;vv#S+HMr)WdPU<^U?sU16;&H^k6^H0y*eUPJtrOML1+2 z&_y~#L>L!!+Xo3$_!MJXf#@E(S}lZ67!YuXK}-!G5$2@@hzRpi0<4Jek+#)@R~bGD zgH;*;pYSRjKu36$3cwJ!NCv?B0|~GcUZn=m39r%uWQnYhx5bF8kha~3Dp0mHiM)sa z6M;=)A*F$jDM&m4O_CurfrlvDFhuki+ss7tXxqp{UzbHh|L0`^hUl7r`v2E5jZgho zsllWE7e%u@I28D3TV1RGlFOd97kGJG3ZtL7-`~yk2t;8f^`-9NdC zzE{^_Pb%sjZ_f_>gf2pmJxfQo*95%OUrh_k!g7us%ntt!oZ*$V=Mv>)vrp~)$zDV* zTgy4N%j!SlAUng!W@i@Cd?Iw0Uf911pG}p1Yxy4k1AS; zz6h7!!AFUmfF(RWONpFdd0=Sd#q~3CUGgBIe`t(~Es+~Ep=St9Dg#<_e|J|5vWV15 zdN-kKX#B(?y=)b8VyI_m^h7#6A|0+xc0yu+iawDUHb1g})t5Eh*eb#0GXfoEib&R9 z62&bpspH@lugKbUt<&`gNA_d;4}8I};>TnX(*o|Kfa?*gY?l3V#DeFrRF(~Q_mPqA z!|cfb)PN5{aCj_ievTN;OJc+&ge z(U|%*?<7w3Zgchm7v5ICfQ?(^%mr8ba9Uf>(RVA4(3$XbuYn`*_1(tw%!B>|PQH;N zj`Yl}Tl4knpSo^gGX}D9*DVyBeB+VPw%mXt!XnUg2$zw!wp+>~&-8n{Wfc1$!Rlmt z;NmQ$gc*`_{QX;`Pi*0A|5k7`)J4X-PrNy6#~C)s7STp#G#HlEVQ z!?{`n(_A0yxh%K;9l8*y+*@0)IS%FG7Ak$xKe$XR<#e>?PMi6hr`KLIoOB1y4H3?I z!@t8DPj~AAlpu?oWW%}Wwh`C*FD!_Pz+ZC?ZgRAqFzRhm2dtgxKXRc63Q}fpWox-BHL6MP;aQ9%ELx~aoIVL0ad;u?I-j3knL z%?u?ld`gTY+Otd4h4D<8ix`WLiiXue#+|uClgRr|%d?@=`v*=fek$8gM=urm^!J_8 zW!EHo@|)6D((EZC*B0r7Cv!W;0Xesg=}wY zXg6K(&+vM&H>s+2Q;oeRyj$4G&OonqyTk*o5y^?#M6}Ee^+fkfp$$Ewwj$pmpUX)D z?JTfNAbgI>E8ZWvCtSw52VADQ7hFJaKraT~sEffZ?ZqpgT5yMuxm_fMW0}D+2d?^UCkH)U_1$Xt?+EGFG_GRn6CICl~UU1M*YvoMx$mr%K! z9|{MBjudO8TS$4CYHS~ZLVk!$2i@W9GH^_;;h2s=aJzy28iZJZxPVw{<-yjVWe91A#HHZmuxNv!!8@}AIi7Q=h#G-@cTUp$`wsw(d0R2h|CYoW4BySh1i zy%&qtnk1h1%ULw>{5;Gdks;I}p-~(?sZkXD%qpCgHj6-`%H1o!zKx6-@$4XxL!7uZ zjl_O9jkwnNGeRSAB4pIZ)6Lb$c=^2lo5<7bx3}}(u~d7Gv6{TR614@cGsZZrzF0q- zP__$I^41Ix{5;BCd%g4gW)*yiG?_cWAD??zEuxcB@LN|lUDPtcN3o%Z$?G~)Fn z-j%M4hEf4GcDe?5w#(_dMW^}``|0c2MK;AjH_6q*wQlL}f*Er{B z>E06F%T%7MxpO5>1%?%dlTH_frc1H&j_frJuPbzpRLUc#bPIb8L=l-}CiB^vOxJ=O zyAv--4F!IDjMDRD*0mePm#Lc7BWM&

bG8J^-XnnNb;ncLpL#Yc+Y%Lv?~^YgjCN z1Nro#TvhEe=60DRVq<<5O2DKE&p8?>bsx5TxQz3iay@ZCE->_bpK7@i+QTSNZSh6( zA075uC>Kw8vydMqeT*kqhpThJ<391cVG~5G!sdij2X_E90W|@p@kQ&h)5oep zJp|$QB@=|4M4*L02e#}I)(2)JFa_82aqZG31YrfW_gVUccVUyEM}Z1KXMDu6fr}vv zL6m&Bv(bxzOMI#InUNrb1<4qplcA)6`a#hIxfl^BKgp8$S02I9o zE*XeKAL!NxAq2F}=f^ct1v4QqDq((jj~JwHeAh#lb5~oO$$p7`DZVMQ z3BT#M33Um%$+r2>RoX?b_~Q7S_@4Nf`|1G+Kvn=(KzKo%0#$%ifIa)r_>B0D z_(=ImeOuVo4SSQT{-C-S=zA|({6KxlGW<|F_5RnDN18xPKEx360H82T!7rechCrfl z*&)EF{~s&=?Y`}D)eltn{C(?1i!Z3|S%w!%r=DSdRDP`3K6*bE-F^P2@zE<_yw>t1 z6zio4oq_lRcAB>0^dC@?KZB?L&E$iLjqyKV66Sw0`C$ITvfy9GTK^}Lk2o1?e@3{V zizhUGr(hV#CwZ~}R!0nkm&rvhAX3?IR$54cq0;aR(hHo6)_$G z8qQ6Acp1=5qm9{LAlf2i@t7I&bT3LD7nCkkg!iqqRMRz0OjH(PJf`<+g5aGde&An9 z01IB@!v#(0=s$R#e?7KZ|JV$$3RGr;$E;I6uYa(93yAr8)4^6JP_dF};fAco0=tCsemu7p({U z0CR{5kP;>B%ZVl%YEQ#P=gxBV0}wb%)g)Irc2hUSYPo8o(>UPxv!2Af%pEHOI)_?N4)9mNfTx>X@!)8VZIg+L z$2X9Vid>z48nS=0jrfdgXJP&iR~F`fMqd7dN%<3g`2z_0i~bQ)l@k(@qY?RpbPVl& z{`-sn4*&dB|KG4bY@gT<-KQ-C;U{^<_(|8=0YQuntZ_^&X{pUe5* z5jj@oe=>^rbIktr0{?fIhJ*c+eEa)~f2QGWgSz1P(Xkfq&`Fw+FXDr~*j`qkk3bs} z5CfDaIt@KyCj{kt0hY{jM2Y}2Z(xk*B;3ThBaFVi+3$$UQ=cMh-e`rrp25if#Uf#O z$5y+w|A$4ij>&evWt{ArIj`f&BK+~e**UaO$jp$m$+NiAL;J(qTgSyq$HjmIAY@Pq zD^3DuIqh5L-Fa3)$l}V^>8?pUqvZu}j}OnU73joEd~xf|50N_N6DYqhzxulJJgjnU zKmSkyrS(AMmQv~s-G%h7I}poVS`jpt^_4%OawXujm}L9iZUp(-Se5npeZ=_!3r|vz z0p0_-$=iBcaQRNr7UvSf*ZgQDXr`5XogVldUt!8Sjx?Pv$B@&X{L#32mssIg@A*nf zwcg@qF|o2jc$m=fjPw^za!n9Ie6d5Vag26ZFYb{G1o6n!+?l>U{3VKml-A5ei4at# z>&N`*XBZ4^6Q_{@hml@2SxmxDw@>gAU0E%(1~ygupbXf zUf$K1_|0DCjvM-)ACl-)BCfY{XWVHI zlG8VOS6PebUTKrJ3PucbCha~`D~a5M^@qizf6Ni9I$iBtte&`rG!w*lJMHfC2)yyw ziP6SGrDkbQyVb!`0!d=w~1zaC|pfI_+KiJd-SnF-!QbG*1O;i(XEM zwBBjUSNt3zJ5cw%s%@RUy@mN!%`(_Ax(OZhk&-kPB@P&398{gu0%9Cn8TkuGN2QeB zzuw~B;`$HukQy--vm_@B^gJWZg9IK7XT6~<5)fuMj)=Hz3(TrDl((KAnH4kN6Y=x; zZlgnPYbTMaLU!AW5e+9QiRvlO2l-{a-&-T@Kelbxi1~a?*C^Ua8>LLh=oh5upJ-b# zp6-92=5nrMzIH;}V&>ojb`+jzjOT@H$Ge-w5^w&To;Td&tN ze+12ysx~x~nd+|3E>>Cmd~=jS55~}Gy$pA(UpUl*`g!d4bd!+UZ2v=T0!CFu6>NA! z@{PZ8Ku1w~H_rBy?uUo0I4e&hX<2}9<2oWi#%9o#p1vr+70GkU*2Luj4z>38Kds zS$TlEtK%kK#F$=Ck!4%5O*<%Y+f(um#K$EWyKBW)6FzbFt$%0oa26E%;<$EMc{2Dno!DO*p{oT_=r_ZRNoFLur~Ca=oIvd;iCw>2 z07G&z_-RAL#c0{oIEHOa{z>X@X01)Jn-0n&^qH*Dd!VeCh%fPO%+>I*Qe6YIL-n!B zogqeF6I>*B=rJ3q!BOerrloZPNaDis=6P})Rk#P|@TPimBm&iPBQL`k^&mqXo!@GS z(_*<=S$$LY4I;A^F*AnXL%Gqz$9#K#d<_=D3_rCRkl&wW(6ERef)-@%(7J8rA$pBC zogdBXO{^TCC7_-927?m+XsK9;C2<^UOuS^Jb+IYdIVb-iIEzgvynto@EeeQ}J{;vD zBJfoI;Z~Fs_f)|>% zuufTbtz;5K-FBiL0l7`pfLx7%H93c2sU(b64YI5y2u&3TxYp_7!iK_k|Xos_D^ zr_G@3cFw~I^RlNZRD!eeMlcyel;YPM6P>&-p5W*@dArGupmKQfjE25adTbc4V97~n z!VxW5?5$eSy#+OxwlQtut-@DcmL?nte+FA=3jv}}-{g0a{D4uIc181Yj0#D-x2cqN zbarw^x60wBRnb$aGmQ+qrDV3nSQ*eMXl>UzlDDaJKz@{qJFPps%M^6vU{!HkHcYM{ ztFL^tIvm%KFozI#=#$2orGADhS5o*3pcC)2s zf1>W;x7KcGsBx?llZ3vyEZWdX%yr^kOBc9KWojx7@^4)7) zDP;rl7NKyYa4R1qX$)Kqu7up@6vY~B+-4ZjEGS+>r%M1GN8+A!^gbSYVJif0d@Ypc z^dpa8FG5m}1Fc&g5yE5bnFdj!gaXGK!@}QNb4>d=bPBELv<)u!w0$v*;2Pg`rL%mW zbIi^lcWwZ=Dd%TWf$LTx)*y_qYgaj?_YfCcE7WEuwW|~C@m3EPCHCBGjVYjR-w>~! za*YNMv%lXMCW5L$o^jV^YV52x(Y6*^WzRAbX3CNAoN)CtCU?H$Mc^0aKr%MmtV=5P81Qz0#ec~ z+hx<@MEkQ1&%@D~-#YoBC40O2q|~jG#pYrlo2^~4EnX2c!|%wro*2V=;L{q$-+M)c zHWuyqZ3M7em#aa3H)|+SKRLCn16H{ewh1eDQgQ+=K@ZX<>3*N#huJ>V357V=erEh@o*NmS>Tf>;$%>=!gXFFdK@o5bqIe zFOZ(Zhr!UP4T_rmx*E5kob@E=>IVyt=-XTT@EDwr9L&EIEE84qiBEBk+-6pO!T!jxtq()8`w78JC}CU6#-xCs$n#abIS8wb@L zX17o5+%J813dOPNfli)5>16Xrktl--s`Djc!p%II+h(GR!l7OXArb24{#qJI+LS{9 zAeuCfF2Z=AW`$NFEFn?~u0OL~1u>@?l~gik ztA4T?Xx=KpSw_j(d^r3>7crM$Zokt*pb>iqTCoDzHiLC9|Xx3VOUK3WKl1?s% zkSw#Y9~d57Fha`P4Ng}8#RQ4$QP#n*yrK=+Ws%+2B~hsV-3c!BjP z)ik~XpV&vrAlS&@MN|^#>69l5^fgQeQzE+&U}kBN{PD;(VrK8_Q}6}n!3CV?tSJfo z9J>F0l@&@1YZH9%9PavhHyEDmjd&}t$u4yLuvT$_U>+lr5Zl^`ky;quQ} zEL3QeWI!7!aEAC>l#e=dlB_14^InPH7`wdA8BjZlRTY2*Gb*RdvpRv&f@Ewz?!1L~RGd<<;Ko%vfA zmidoJWe78rWy0m}WlR|Ikt}84(6feRNy8iE-fG*{H7M3KJJvNf)-^*MSn^)J8BJYL zdin*C0218&7QkS^Y&D_sXo+ zF28_TXIJat$9&ThS?t=I9q8kEVt1Nvnw{;|hgQY8j?Q0aA$N+*tWC$|+F87)v-94% zD0%j%toc>!{oUSG@5lK^A`XCKd0+H71nxw7<0}Bhk%s+XmHVo4-|e4yMi-&$Z@>N6 z1wawlX5jL3(55q?ljX2Imy2w~iAC4m@|{jri$_VMphQ5pLsCF~CyAB)=3BlzzoWIs zi^D?h2X990;?EsbL#m!bk1$`drC-`Ysb27IycG;vkc1H?ri%$zjA)Kmf~}n$G-=j7 zcTB?OX%<-{t74{F%2ve!>!#9OZ}z=PtXxn6GUbc*%9M0pS^8F~iKRsXo*~5&*FEz~ zj0}@CSGCz{HawN4PX6tJ)#DMr^s*W>h1dna#cze+9knhAgFO* zQG$%2HS%zAaA;-?W446Z@M5YJ?G>u~a?sVFT4G~7DWu~9^==aOfnx9U zG$K~bi%9~T?zbc2lT`NJ2om{w9GHraZh~_4vsqbuAx{SlJqMv*^iZ~J43`i_cUfJC z7!l-$DHrlWwH<5gJsRqRCIAB(?`A!yxJF2S91 zcc4+}bdEOS*pJH}%N8w;hU|GsR+Ro_c7oBrWVQTH9r?HXQOwMLll=dO`J;ptMZXCt z{2%Yk{HGB1cWI27^`E8mKeb+^|0a9XKXl5!)Q?%Y{#ic$AE%D`?o}NK9pA)$mc&`U15l&sqABx1M&TcTXZj?w z4O<a*NuX&n?Mu~giCt6L+(L$8;zCKp#kp3nlK-A`X@L18#aB9{1_1hJ@@T!zkI4DymWNGCy1afl;V0{yHam+C zdB2!Y{{Y%rk!DBh?FQQ|G9%1k^BmepZ!=?$hg%wQ%4lT6M~M(2l#?Wi>+9%Qhcdn>|(bC^bfJ$~u+M`hh)Znon7S&Mbx{NpJ(40jv1|Vkl z34JTZHMU2iX%w*ofqt1S`jp9Pv)ULi;1VtsT)Z0|i#DE@mpL~yW{3KWhid7#Y?b)_ zz;Lg}O#Z&8!Tw{Hvt=RRAn>e{NR-*YUI%-fTl3?3+c*1iwxHrqg_Yjt*WeAAp`!wq z);(^LhdWJ~5+n;#1R3O{H{%kmYm16;<867nL@E|lIK|B&Hw`#tqNoc7_N|e03HHsK z8RN9+4xE@dj$qqtePQ9*vlsTu(4{up<>nCXGP z=H~)?4b(|!ZBrjvY9)WKjMb};29GvsA)v$j1f|pE&0!bc$1@~xYCvPX@ohkh@cO7* z8?Toq@MR|u#KGB#AAM}*rvoQz zk5waR4ktwV4_v@eE!G`-)A&G&gVsJ@0a)Kk1m!fjzLW*zg(v@myTwp9mq+u)6wFPG zrXyJ$LParFes{8-?I8`j%gO+p>Z)m(Kr{~>2WF(5MxP@Z8hj>qbYoR@4djXIL2fDrR%1<^H%Mj@j`E0cY2n!+W$*qcS+n0>{l6c1N_&S_hQN zVBQnlhH6y#<*tt?Ndg%tV9V)S6n3zFV-r-f)MHy0bcSkDw;_b(n5@Q4Dx=zIQ+t5R zSz+0-w5(2|#LR{fD0v|pieGP7G1C*R#+!y6Xj*Mpo$l%H z>TID=LvamxuVYr0de0{fG80GG<-1wnd8lG%uPS!1K_f{qd&5#Y=nSLfxGAf(R=26q@!ORxF{{EKb9^!LRb0NyAa~eDrme!7zhC0^hkGNQC>(dHd{LBes zRvebLQ8r`*W$kacn`OAsz6{8o_i=XE7N(O98*#4wo#KzI%~9kPi@DR7cEM}uD=MfB zu-^+5v&p-_C3^we)HGVEM=bkW%aMUiRy)Yrjnzo-qfqw)aHFQ$swphAKMYICA!XWV zZ%%$O)zyXjyN+#Y(1VP>hBX!#2Y&33g$eXqHeipS7NymJ+3?V@i^psECc#SS76sQe z)k}bbd|&pc>M@|Q^b57r6Z2fMe6Ve)e*|kND1!9xN~hl0vT*ccgY?)kY(mdNbY3_V z@xk1hn+{YMd zP3x)FRv3>h*E4uONliFATNg99k1MI{>O3DSVd&~CJg4WaZaeIqN)|J^bw5edE^AQ$ zAky@!u%#2QM>kP7JR*daB)bE2P4ItZ+p4o_F(*Gc?7t~BjkFORD8P$Zm<+lp`*#~G zaJJw4Ww1KEqa#D+jU*kMp zjd=G)Q-p5_iS*Zp@R}7HO^i<;8`c`rwmR3YWV6~Uo3~Xj8xaca9bK_p#=l8z_D|YP zX}{qYnIDGd+F|#xJ;<}gN&d6kFWu2)Em$})vZ`ZXTUe2AsjADclm+2CO^mN!SyeN_ z&bGNG!a;OLK_UXdpvxdSeej-irIUS!IL&cXE`DqbJmVN2on-0MHQjtQ$0&(hAAvj! zhn>?erGsU9cifUSq;R|)6Ky5`4E*};r$~g9RbM`+6fIAX05$S$l1U!{A{;C*j z%j3}z^sE^VI3{J7m#|u87z$sZEMO5ZY9*I|zf&8%ZIjhCjE%`jBU^1-h5%QoT~@cY zs&9N=z#`eVdLeQ%4HW&Imt$B|`nxrOKGgtU>3tSR`tE8p?fFX|TTDh{X=2Z8B}`U_ z=+;b8uv}K<@fGb$wJ$ZnxiZ?O3RU-73A14uH8h24eP>R?d_uize9YZbDi0^0{JJMC47(ecCDHR64(=(tS`U4m2VNZ=e4lBs(#{nv;x9~|J3L9?ZArctOk@h& z_^ZHr{^(rW>hM~ssUD2FXVeic7uP$~X!X(%9owr3T)1PhQM!ZXXb&F1tCbldeTX5U6x4LoC0 zJE354c8I0znzroHbum% zavjaKZ@7b+mo|Ag{4A<44!bp6zs&8U4i*Hy3>0_rsO^^9I7kwy%$@ zsZPg9Q<1nq1H)H&)X&)rNcdReFsZ!SA461d>8k5km~#nHIk@!a<*-K7%UW%^7SG6) zM*8(<;Yz=TE8^{?ny?vW`D6FhW$qUVB#%uU0&_pEuoELrtzU5+7o8cfSg0PA1BBLq z{#E}qPXA(9=t0S5AReQe1Yn08s?MLhle0AU|{D_BinNUZ7 zmh?^=mK@=hYMdd`f_VG5^^K+`_x%gnix{Ji^{XekA#7|Y*J2|R24|sa&nNL-!t4lV z7@g*>C*Lq3>`Yu}kSzHNF^Foj zu~;Twi8a+7$aX3xxie4EbLI!No;1z&yY60td_%;IU6M`gShDH@o{AjytsN&4cs_t= zzqxp!%HSN&+EmFr$QU(ES$1szrv&WDfd z9A0fP>kWndm(oo?UwRPrTz2(%%oDvIm-fbVIzb{wal)R6dPhzlGTjRGFicMKZ9&=O z8NRdukV?{E$6_b-PdsR{cUessouU*#sSq*{GfmVwg1A9Ry$;0%G<}RIy|zOsLf*}h z0_jWs`iJc<}Zs2wgGzTE;pW=?iuY`&0s#=X_u3EWg4P_A4|;ds;33NoY6(BM>- z>@B5@{5rZ|>iMXTz7(JtZ<;-1YqN9_Yf{48%>q}B9mPrUR&TO2z_cROqgW7%uZ#&E zVr>@miaTKy@#?zPk_a1(>ui?XG#N}964@QtHQ6o4z2LtFdSdV1P`Lm8se>k7kyA?Lw`K}=UHR!@94!pPKDkTyi% zbI-4=fV&37_|8{P)tAnzFZ|sZAeNpft%HsBEa}6+oW5B(dO&TSU9hAG85uPEDpb&fM zvkDPovf}A3@hGC>vSug*UnZ53iSm3Ju(nJJ4QD!I&WuU&gO7}Qe)h@@5yZ8}jK{YR z53WI4zt8$!y}jH=dD=~!PwDW8J6U`HHXF*d45!B4(w^Dxt<(wHf9l(REYByZjM1cF z;~bw5vIbWKkBnY_|Fxi!;4MuL`)zxAn#@a2!dAh+mqTD;$B7H?4`!bo3m#-bK~Z#W zJL=Fll45Zqu{j{~E?0WBf157#2S%u_7oSW|HTk|c+UP1G<+b@?n`sO?oaJje& zy<$?m0^MJml&l{+jB)E!%x&UPr>auiK|8jGQ&g>F^(SXB{AlE#fcIGpk6789it)4= z=rjas9bQ(xPAL^hQ^jD3L{#!tVbMOgN(Haq&*&1|NKhhYKhol%PDN0)YNPN{D2EZn zCu~s_qhK?`9m!S|vYfcQY2!JIYxQLrCxHLGfh%V`1eV^##~W)wG_c*N75sKc$UGQBZ>-ds1oV{Fsv{iuaE4`#(StsX;W zS9L`>iwOD(_)Q-4aJ1fl_%B#sepQ2+PU@1j#VwLr@fAK>kNCLuav%p-OC)5`QB}?O zM)vwLpMG3Sp&unG%ve~7B)y?qPBL!6CAYN^x7MLG;C{#4M%+@?Kx`nTq0apvsWtA; zxp}Qbx;4Og?^}nrx-i8_I*Bi_udDxYi)(}!D1Ep7x54-3~N+}A^=!W zM>c}oQAv1GFKwlks?_EyZSt+c^AHQEX&93}4MpDF^H*-s#wP)37{k@isp8C#K?XS*ZZZh!G-; z6!n-YLAOav#q^Z=2RWJm=_*ZMCUsXz8R(sqT3*SZ>GXbkb5NBkUsTR4gaYt#v7rWZ zACq|(6wMRK_IfO{RdxHIx6l+7vn+`o`WjV#Lsip|V?e%MFw^|t1 zgEHM8Wtu(j)W7D=t}TJnTe%50@PP`;B&QoFSyM^P69I7&&>hTWuBL<~?bTtbbifi! zK++B6-V)Nf%5@@Y`-p{!*;Bh>FaD>dS$61AXbb36%08B})y{(xGr`C(-QANo5_@@a%YCKj;m4E`*<3 z-}&}o>n*b?$0Ff5CHe@t{xu4crPB~!8Y$vogFWWk6{SmNF|BC6fyz}9q2)gP$gRv1KNHWSwt_hD+ zf@Q1ly69gekE9`b=0!iWX@R=!aY#ch67{A1Hr+_-wEU?MPT7tD@*oGmSMV>X!>z%F zC0rCpsSc&+G5S+vg5mV@kmFw#e?nCy#$Z8Pa9&CSX4R1(BhSTv<91btG+lq0l}#FB zQ`=3d0N*@_R=V-(g`H&i=q&<-4NrfSKU7baRV%j4se zU4nA}GGUNR&Hlz8wvk(!A%_ ziqOR-@^p%|Z@A_y@P_XJ0)XI3&OZnFl9j-qSc@niO<>rO(TVw|lXk0rAww-m5(~K+ zf4<~ZMhwX&=K3xUMf06dqEaG-b-*S(9V1zg3O*bKA^bqquLyDGTf+|nl9u8x_{hnZ z`K@GHxo#3G{rN2?$J?eAi-A-KF|E2hie1EuzKq%DSEWWiLl!8ju%Gtmu4wr9YSrWB zjC}^~b`Zc_kZn25(r^+}c&S;zGbU;^uyRe%ItI_*jypD0h`Wg?yCA@}>}ErCsqo{s zZG;POh)5s15r~qU$dyH9^^p$e=4W6Js0WcHz&N@$x7B29_E%FdW4FKp+SH|I_{S9{ z;e#IIC9sI`u(dH*A+FH$ZPt>zS@083NUFj)GZQckJX`f!q9b+>~YNu@0kcf$}bur$+^+fWstY)Ccz7#0u0clBCv zQafn{SpN`^@^HQ%MIOx(;9b5lc-sq3pGaSXO%`7~7vXbR&m``AP{VClSp z&7X-7I9nG{g=&n0K0nxn+J7bexy2AqvI3WOAYTv8n>wt?a*K>U^lL6sGWA>z?Fnb*whOhB+NNzx z98qur+vPzRJNT9`-#+FYKQ6Xu6ECO^Z(1iNV3c+(K~r&=6CNN>&5-rwM9J}v`>GlS zsl%(JUf#ho+KS9tXj}i5PKk^k*K|Fl@&GwSHfCl+YnbkTncRRThd-evLThD*H)9<$I9j&O7vqwND&Z$tIYB zk``VsIiM)9L+-CA{i-iB6fx5e7n5ddWSy@=n})9%hR^PU&pxwtkrV9kKEV$1#DX|R zZqpM9Ln!JGUh2~M?O~lKhKha+W(pd5p8%=ijt^BDZ>w4q7KUXjG7JG$od}%0If3 z4bZD~$L8RbzV7ZFn6FzEcaxH$D&3rSw3 zrXHnHSsZ$K!L!1@_wpdOsFysW-pF1g1U2^JyR=llUkbd>&AQ&xxGQc`kV~x@*=GQN z?cgX@y|(Scl6}RI-+paOLhiIa=Zs0H7#Xty53f(9*KQ94C|`mJyAWN(^OT-OMV9Hd zvba0hUqc!n2Yx{B)|Z5X<+t!;76YAsy+wo%1ziuGT;p(}nWn>d%+5#5^18!aV$~rG z#xG_uix>c8(xFcKRtxg7Y*1un>5}ua>(CSt$#SqpSa{agQU9Q65^f{%{?)>bi^S7c zXz0}?;xI|E*H^*Seri+_Y^!A>0svHz;N!S1PU0 zf+kl|*=^LoufZBou*X;uRwxkn=7B}QWftM;z2=$LDBS9CT@xk8{jvU>$)8=#WV7Vaj-qEvm8fnv2l~w>>8(C{=C(M`=g37EYo+uspHTxR?zOUVPI11^W$Y~E+IP55Ts*Z`(EleU z_Ak8`^Oul}?H|?re@!eLEcE|Kl=_S2>)%%W&wp9jndn)+qPhO5A7lFxsIjnf{7a(6 z#>Py~@h<@u8ym-$$n3u@{}OL~>9zi5hb-)j^ek-uE+6|3js9^ctgNi`EG%sQkZb+V zkL>^NTm0qx{AXC>p9Ah+aTQjUzf*Ft{Nu9vUxYQj65Rd+tl{P5jjEb<%%!@p08pRJ zl;FrMr$Po1JMJJLoe|UJ4L~9^p4BHMf(C;_LhT&sNm;?eC~}dQ*L14x91qMZ9V|?HgvI z*{`VN$z^W)@!!t`bberJPryXE3GY4|odlnQJut%I3_w+N1V~t}XJo=sFu8o~e#2Rv z00L*YkX1*`4_HJ2eZJ*bI?7K z?RJ%K>#lv#3uWVysVx4%AkNDCjB}_pL$DEk zL>(4smsT#F5XLpaJeR%qu*NAbi6jxl9S7se-2e#A1afzseyceAX4)?ECRG4ABu0Rw zy{JG#vCp!6(zFo@T_b9*WNwEPVbippCu~lr0(ZC{JwWmTAxnUI88kq@c)*g6de)y( zNgSdCN=YA$j=dPX-~v-tK63e&s)C-vyBvl3nSG1VrR=4St!{_9;5S00P%41y%eY~< zQnHT7u8WI{Mx7Oc7CI#)Vg_#uVTdZbUgib$bo_3h|G=xW+>at)Fo&D{@3i)Uv0^Gk zsJkTyML$^*wsK;J?AYK6=F z;S61ZpHF0S_VGleLfZZ-;IhMOULlV`m1mCFu=YCtgds~5evdBH%~OaP z{oAn6>tL~c%HXc+v!WU50i8*}_3nJCGEA8Kz@7}R0b6tIEBJe1X7e1>{F1mF{ zi%rLPDGodXGmFy3MaSg9uH|#An6asI!-k<#d$xEIDSE6`(e&_w7U%jDaSkUPPihuc zu<{YZS)|MFL2fIB2KzK@PI$iK^pxdC&1gp88L~C76P1!Y=S#W31&jS$pcOD3ceU9ok87;bZVGU&Zb!LxR^1i$DGW{Vldts{}P;ll|r zJQ98?L=S?aCrpB$(nVWyr}@ge-+P^;E=hoqzvXGiR zfeV5Ap2ch_mI_p@s0PslApxoL<<@!^m=+RQzlN}ETMHOP7N=u1;}()$Kam$Qrynx2 zd;x{%*kzPq@QSHj;et!y8;kZNK%zy0V%Bylc7SrHoY744X*KlVJ1D z?HTf;6kHl8JqBhJ&0lA<&1arWFZ}qiNwpg<2Q0D6>3#`^^_BV@gDCRNS(Y(HVM$YI z{X1H0;~HlznSy}6L(bm7M}o{cS{~&zb&9fr0UQj(h5^Y~NDaQB1$(v2ND zhI(XseZ6|Mxu^Z;(??Qy#P~SD>SU+uiFR1}Ax%)Z<&)<|a{#+VANcNRqYy7+HaD47^{WCHK!gEwiVNROe;;7555Ik zlOOeYj+_cs6-4c$-QzpvW8UY-=&9(8x3w&{wIYIsanSzXbq3Grf55IXFiY5OrCKnr z?9`l74Kkc5~(r5KyDu zNV2ANbIK!u9T^%Xzu`9^_(7i%;FkqrVSjzy3%*8D@0ChPm6bpB#ro$9)8l>{>-$FJ z`h=81P+zT3(q=hUC6~$Ct338yr5Y2xdxz;!t(-E-GD$28mkE6gdI+Y%=|IXVsw2QE zoU}z$PP>4uDe5fZ4()!xcE>i_o92d&i-sdMosWZ&qn%wLoerX|K86|=B)o2${J{0# z0lcG*kcTj~qhFExy`&@1T^Cv8gN(mMC)uF=<8D7u=OtB^hY904L|VgnqKukJMu%fB z{!8DwLw4dc5h*u(lh+NONWd{;gr;|9~;(->xyrLQ_NzZ@(7 zc$)j506~vA)-x!qIa2&Jixp0le35)IuL8S_9U<$`in6lqF;g#ijeC_z+V0{5T0X`8 zgc5alz<@9KfONDAY-sj?*T1_2S_gjKo<}?0a4|L(?#Sxi@a$L=E~LZrYvOGO11?l; zge@ALznI(cw+i}JON+U56|UwcmzVtLOqN^r39dTccrb@ELZx+jbEE0!&$P0(*FKke zIWzi^$uzV(ljLL$R?{^n-si0?kF9#xeS)R=YORg+!~-}_;*dv%*TaBW$2%U1?oOi1U_Jr)O z6O&~|?)E~(eJ+`I#uz$5*l(dhA|!R38hJ!Dq9URseNS-mSEk)u;XVU0GEl)>Z0Umn zI1zr<=q^}sfQ90_9b$=x_~bX@6+6 zK{+LnHl$fP2Xx7RkDd2wi@89K)Dl)qiLw<=2q?u3@*R@J{a$c|;ddZDxKpFbR1T!d zJW7&J?ZY-ED{&lzbcFje%b9}`e#ux>6S~Jx9#1oNTzBp8n93r2G&jwpQ}Vr=PBien z=fV2rjn(c5VaOw$!xrNQsR)?3E~6a^L25;(eo+8H4H$^Oy6X2BBCb3{i3ng^YSV2_ zCP>JzqI8tO^^8)I=crY;F}Lsyf!HPRR_Z$PWRGSo`POP)h4h78i#s+5tvXB-!QB2q z@3>NdDvPd>q^^=z%7vv%7!;gw3{$MpJ}wr`CuD#)(6h#v{h*<7S^~+5-WhE9lxrOi zN4zwPOn0JzmQ3(v;QZS|WKBxYT9{@_CT3sf0MaFiR7(tJe+scFRz#>~usjN+6a6s1 zvs9)!JN(0p++jH3-5}&S2tg#`6~en=u+X%`zUBbni{uGp;NXRGCnRF_*vUks5Xeup z>lX15@I1cs!uNg3YR5lBm+9j02&d2EPZOb`@MC`dSeYxH?(%$KW9i-&fP5dxLz!#r zKdE0ZgTaqmU2me9ILDns34gd=c)QVI>7E#UXr17q=SU-uNU_D4vQJMfTFXq}yO?4` zgIX!P^p>S+&$;QX*q#*HJTl$aC|MIvHkLyn&LkhGHcl;DlVqv?piEN9l;KO^tD9F^ zLKtoU4?QVU@#0xY+H*?#n6)@elM^9WzmPkG$spn-Jadc~(&u=R;8S-@|6ZK_48pOt zHn}r&nYp4Y)f1nq#Bwp8px_GNoMtAL;r6+d(SG;ug@2FEH9mHO6Mz*|Cl?j^xOK2& z^tzZm?AGMw-+UMu>gJic=ss-f^KjBWrRS${zO=L8du8FXoiEx#fjaJ!$(xa$Yal9_ z_uwVl6IZ{)f^6QskcckQo~BZ6wh$LmDs zjn3|VDEO3m9?q5Kn_vMsjWL=1#kt&xaNYC5?qnu!8Hz?|WF-RVV3NGjJHj-#Q1CG- zp1J7VRBda=rDte-945|48toA#D4ChduXyEu{b^76W7e>@^W|B0ZLY1u%E93n#4I|| zJ|XEvy6?H@j6MO|IquyFdn?Q!wbE&CZEQ{2f#NB|_LbpB9RJ_d|H7*J`|H^dxCToMu=k(dQ5=>P4!2{ zK`L-`-w5z&$2n7!o5ngKgHP`YIYEBdXy+m%;O$-S*i%n3G)F_12m$HL>jj54`9!@Z z7`}DVIt0f!$sE2XRVQ!Z5)NsEn-bDM{GYLDo0m-Z^U)ydKyjM zFMzVWw)ASI78(FF#0GI4XeX$o&Yy54EFe5q_or)Jk?(uOz*^i4!oB|7Nhq&J6bYp4 z>azL-Gtq>PLNmkqvrM>w+FyP*R&&PhI+IeIhmOh7?!mVYP#GvJvN zVyPa|Ku!n7m2odl!ZN>uNmeF)Yg8;~_Uk%7~KEH6o$f_t~fx!zYTUk@llmHeyd6(E3rBly&}avpN}ZYMYWS zAdy;*+hRINLgqbM*k7N1YwK?Q9KLWD_47~gkZNtfoG%$mN+s%acdN_&Z*w8irP0Fd zlywp)aMcCBn5Gs4M^B37yo3?fsRAV0;>IcRw!YSBJ59`r&?+c)F>oGcjyX`^*vB0f zPSc}2qmF(aGVl?b4n=}>46g0R>B$VuW;(-FbSA#|IQ6s7L;J*02;@`5qCy!0dFc{? z6lQy5_KBGV{Am1d6rys@sUEc!5qV6amKZ*?nWjWa#^jWB9Eo}3E&3h(P3VeUwth*R zCNaUr#myQTK%vmfCWz7S%Ut~2t|rWrqxGEK44`n~a>;q_D@fo+A>Hq9e6$wv$q6h@ zhfPf`OA@B0CQ=?t&DHH$ul9~h`^_gD$3&ipofbDZ7%`RZM?V3bb9IjQr>ZmpEw8=m zOFH$oY^zhIp%!bJGTKuGhu^YlmGF(U0+C>iXZAen0^_27jTFr%4NmDH*r@HK0@DOR zs|Pp1Kv|#=C{Zyf)OY}v`Op@E{4v8airn?CE02TKmzgv>I|2#nq;@d1hoPj(Mx#BbQ&JF>< z-hm&xeXOj29nT5a?y?b1XRn_Kd^!kS`+*-ZTGI6T?e)iGE^FBI`aO_<{A&IDrSn1X z63Q~@e-LnhX3#w|+8wSW-JR|0aO5 z?T3SRfA5mUClesEivIdpAez=Sx#2hgoB&4gZ>oEmF;2GZrxOTbhevD#r*-U4yMHaxJI1bm z?~;%9b}36~cnaG3@e`ZuQxcyLbU(T0B!LmsV1HldiWg{=fcTqqGSh>@P4j2c+{e}v z)RKcdNORYC=I&XmgWR4`Mo-LKyWm#WKKLy77T8QT@>5Mv1CRhdnIB@Bi@$6aC@YOv zmk7Q=<;Indzqimwych1!mZ6dvf3-PU5a zi}co^?2?OayMsuckr0b~OCzjRSvg@xV$yHaVe}po_s#V_F7W62 z15HILW)?ef&cyVDOf)!S(Yp)5^o z{9BLdCF0Cgn5Z9P1z36(M?QsoPGy}^B*2xLw&nvtA>VJkut(?31xZ?9zlI=JW^%TB z+vM~ni&pqf9UaDe#fR@&w?QdFFxp()vrDL@;V)B@SE)7DMs1R2 z>Hb@ac(=%xkwf~y1)4`!J=lyh2<#B(?5+8&U~lWb*#!m*5ZWnxgC0rQcO@lpSJr#C zUS-=rP4z)g?(*C{eP`kd6TyvwXEYnCNR2kY24lAM*b2D;ODZp=g~Xz>3?OQkB~Ef5 zsCSec3q5c!t!b%W(a})s_MQa`?)YLg+RGLo&Yj*QJ-YUaS?R`zy*yLoizM^t$4Z@Q zeVUZ++3t0AzktKq7^PZZBLc}oSX0GhkP`_!LsFAfH6*HH<~qI_4M8e%X$yB|nBC`$ zg(=9Inu)AbgNr^>fd8GuipLmJD=MbTGXA{ObPPpSA!WhSW=vyc|Mv11V&BoBq-wLJC_Nzps~uRToL_ zbKA>_@HU^N;O%O(JLjo<%A{KTcfmrz+Kh9~9`GkR4(e@Yi?dLvo|1dKFvhD=&>eRF zdu%jl)MjjB>l%2Ed3CXjjQP7t7Le)gneGJ{%?_46k2bRE%6QRc~$JPjG{R35t zib9Mj4TP)J{Yj+JZkC7~T%XD*|s&AS!bRDQVxUm%$D$B#ObOmbAh5WEG0VdtOTvd>N%$Wu!t z6*lpY;&HB(I$dNil9~wxRy_JMjGEjeaWYa@NjnpK7kDoy?Z8$tXFO1)ej->6zq2y_7-M<2yZUp{i)~*Oh2>{B_IV@105Tkhbir*!(=?h3jSMphSLK zxoY&BK3*ef9(Yc)>@3X1fxB+eki*sj*XW5kkXi~k;lWvdm`n^W?~8AKk1 zYfUt9GweDX5eQAfGyeyzMh+*tOqk67P(sx%7<L5_s9y4hJ;fUpC-)NukrR{_?AClI`d%*3*-A*>~V}qMeY@Y@xlcHNlF1U)r&rkc9IT3gPIdmJt>%LzYSA6Huv?FGhKT>^XwLdaK z?CaBX*spF$1Za)~qDwr-(C&2Bnd}7ZAOt1Q77<~x(t}{A9iM&09d0G4Lf|o9$}^zm z6%9nV^r?^(SLDEkWTa~(qz`hUXb0gR3`o1r{zzNJfyM|}2P7?2Kxg$%P@^8Pu?jdJ z*>K_}5Ras#B!18i$t3(5kJb7Bzr8FH^gj6JI5Mm|Ah_FJYGNLvdQ}q6Nv@ycOklYOa8wLf@-5@jEF>=ag;cv4j z&N`Ojx(Ap*e5H{x5EW8MNjN>{AR68ak~(SwuW%cZ{6G78FLA^jMOt2i$U4e@>PP&HzRFET#1@M#I5n|IvaITscMXIs}-+u9DhB9*qB_$)3#yD zwPLrlV7Kr=O%qY#QVKGR6k_Bg?|2{(t)^q2o8WL1GlM2^$0nHo^}vIjD*GB=dT5r z3Zs<v9+gOf^kFka7-R#@axcT*2DLpBv($d9weM?Fg(!xSrxlCy;awQCVdZ zhH_llY#grB1e$ArHlM`B=2(8NNnEnqtW*06^TVs6hiiXZ{)wN`#V;(v3LQeGbJ&Xp zGZh5im@;jH)$QN8bP`SG+JO`=a(6^bryaT}jb~ZffE`!7qF-CN&70R(cg;5$)9Yy;yPdH3HQCw==lf(q=ATIo-Nz!9*Vr2Z_XpAB8mV-+D z_1wVQKfn*Ae@Prn+GfC@JW5am?H#AJh`ai~#|A4>!h2vslW&W}w|2GitFFYJ8D?2?i=RfSyzuNz$!9V_+ zm5c4m&itQn-QRFv|H-t6;zHIsbmpL$YE=I=x(X{7_15;V(1Zcf70n84QCP-7U z$f1c6jBk8nd(KHoJGPLRdlGqx^aFFu7y5|!_|Unvq_t_9vZya=A8=n+zaxPX7bT4k zKS&KqG^(ww{?>|?s95@iA44|!{Jyy9#jLTq>BXP@g@7fjczrH);ZJ6+WI_9Rc4N&WgLfI$Qjamhqe82IHU_MxAr%##ysO3=iJ z=an`!q~S!5W`dkMqUTa6OgCfCP3x;hJNhk~mHv!qR-&kIZ(8irq6gKaObSN2VQ&~4 zn!dCwjIjYb9JKW3itLsdH);6KYFE;}=c6p+oiuauhwhreRF#pEmX#TPNAAY$&RD=~ z|DpLU_D5c>D^!tK&??awiqQp<3>^=Cltiw0Lmso@1)NvksY~K#aVgYeW@*$q!{E`u ziIB%B8rITS+^?GLs9mcOnit3)7cFuMNA#9pc8bs-q7g|_1qt>n1m9>B&CC7_^W1Yc zZSG|Th+km~`I}$YLvWkxlbec1V6i3(&1rh73^&>w$4BlG<4uRn6B2HP$0~w+l; zW43I6Tzzh8PmTekM zU*}cdnYl|V0leC3Z;nQ2puB)M`d{*OU54 zOiZYWr%T8$}6|>iV|5#0<_6bc2TGv2#-0lilhYFb)m|$4G3=wW* ztM7AFBV&*W=qiuyRh^_C5LB%U{GnA+&cv#n21?_65nT8i^iHr)v8<@pI=$1^0)H~a z0DUd+S}x@jg#|!~L%qV&=&@E#DbqPPCRhM8oLvj}NJW(2UVM5lls8|Aar^z^a3=M2 zQ^q;kze=qzg4cEIW-v%)mX@ z0%8eX5o)_c`q?aK85vcE=UG7tTe(VWV8c~{$@0JZLq~xqyp1Ff3t&Kk)I*>EQRw+J&h?5NqE1#G zMDXyh+y#Xou6N%3EOn|fsZFa&lWm@cepdIkcvSAzS-}3hT$F_*yFCtJIqRyA9BTQ= z<-w4_cc1?}cLoO>v7pFrx2fP|XO(fNG^bNdt5;{Kt2ns8HHT3waOE{k?VcfUi{tyF z1^!B7_}TQ@Jzhi5Sat9Dx3K|gW7>~i@Dig!Ua+)ZO2RvP)ZxjnMd<38y(VRqu<_hQ z(KX_k;Jun558epGbyZcly4glT>xVUYxTg4y9m{@G0~2R(&0JjY_w_BZ{fiFx^S?!y z7DkQlm{B=}^r1`kP~eemOH2Y}(?r0ZejlPxf^DB}IM~VgaPdbKy--%{GNspN(L?Qe zI?^q^=+CHjwFUl8+;$9w{|#!zTzlZ{j@w=hdcjtXe#Uw%Ws>Rgp(T)4{(GlPErew8 z(qhD68TXzGA-|QMdWWtI1UQzR|G5!#F_R!z0+h&)5e>=x6m!hyx5sDezM)#(B)>*`xLn5$9kH^bMC?G zM=3EjJ8DDK{mZ!%Y<3+6>cCicgOilPm6!V=hj8H({L^GUgX!@ctq%JZHd4pD(M-Ec ze7`6V3V^vEW`OLl9q1a?R6{e)l2Z>zc7)c9Q9v62A`pd)#U)B;+=Y|52M+{yH6CB@tTz4=(SSlQB*N)+R%RfQPTDduC5##TC zip!M$2q^bFY$dx_CW-4X`?Pt3=4bDrUCd3u9li zF0lV82W2vMZf%x<=@g(wSEuhO7Br=eZMZqZcvrWZp;>8CsE9)e@678W%bvAju^9o) z4~ujCyd1D}hc}&^ROFDbQ!F-}ZPY};g_9XLo{~q?ko;_Qe(^AnQ4JFV^U`OnpvQ%V z&SNp#+d^@UFbj4DH0Vk^t{QXZ0m8o0$Iexbf{~n=`Ad4uAeW1)*D9kfC%Ec*Drd`4 z927E9!<3#m8@u5=Jsyupe?=ReAzv}QXu&!ysEH~I_sNDGa%$=Di0yU4YAjNI%`9uh zENds(>><_6GS-Ybj(}da-8LMsm|=`1bIo)XxhbQv;G{Unp5VXVD3%_gf8EvxE@C}6 zfJHzo4z6G8%u5j*Iwz!3c>vw6n*T%Z!XRx*wSbC4(vd^1Ti~5~^0R-t_R#d?RKl#g z`6>Zz0gvCQ#m&}d*Oxw#V6)cn>q+Q)>6H9RrA*?5GdGIZo?WJ5QrLmb$LSH zu`pQ@8`o~}7f`TwQ5M)hc*{`ss7+1fN-Lf+UwMaO@Bp7yc?ry@Yh) z1IY3N%1WqI)E023vfxfmH}{*1tzXX2%b>x`vNTDhTBGxtLk&u)*^KSh-^&MR(xkt4 zSh6~*Mv2pEv4Z@;2quw`1@}!~tfkwioy_rHjE*Zt?6olCTS?s&!S8*Cmd(yOZa8{v zlzX$JSd{A)x^@6f%YrlCfp0NYBQu0%?Cc}LC@xgOCGPPK0kXo;UuCyXT*iBdeGk=X zig5K3qg8RJ2{3Zy^B_~EFT=I4IkUFzh%fa@Cu+0EvaG6dEjz_%WH55jAb4m(C~S?a zMF8V5%QwrcU=HT3|AxqNwgl_%U2m$lZs*XNJb1L#nsQT&)w*4OJy)FUL-3 zv=*-|Jx<*^UG*ko;P7Xc-HetMO--35O{1d0`r;68&2zl04AAXCJ+XV#l)81x;UA+l z%w{$sVOuz-N4pE(Uz+12@u4C1(y=e_CX%Gm(7}hIVo! zc6t{TXY#{~v6rll18ix))e*G!XIA0AJm7)K>FU)^`z7EEn924H+S>28?V-7 zwD`DP*d|(Mc}C3d*L9Fl9^|4_=>w6J=@4gM3YH7(w@j?80OeoD?!_z$qf_D?_eqvN zirhhxSO7)k>U9Z_2&v9NgV#xzkzC(mlhA*lUR7u)Uk_rZMKtEO?D`YXMNcXNmf!-m zawUIt&t(VUy`&nQJu;7u^wGc9!cp{UW~PEP4H;U{Q^ZYXw{5r|b^DFuGze<&;fDwqwSl383$sg_#4V#Vp*kD4xur^vg>Zo&RnN zPsjLeGaUw&Ob+{?8hzgWWPHCMJw z6X88%t-S-<9+O2C^VU-9vTz#hTD@Wfi@(ynKX;(YCdxyA9NrVcHWvryz2-ipk1m=} zQmn$7VnBm0QGqRsin=UD$NmZh0$VgD23nm7c};xCG9MwM8j)5{9j+!lod{golYYeQ`_%X64Pv=4?OA2oD^4Vl4!n!ypcHlGZJX3QzSM**f zfxQVM{?P>art$Wy)6rr|n{37?D_lgQHdQUQyR6=gh0iEU=J2bStX?>TtZX<7K#E?p zXau!pBpNWV@q2=ELo+jy446DB>YSFM{F|BxA{RLYz+FH)1k>^_7T=7Y1bCFeRPy7jU=Ig2M%k2rX#*k@Me0zvj!WHSz zR9#d<5)agK;FoRVq7&0$CS&sjr-XJ0XMClo^3E!w+w^?>4|w%w%r!sI^UtO09~o6c zU2-UU6JFu|_<()Ri;krtJSQxFobhux|A1CGYu4&*_2cA}_7?hn(_7bTi24=%nTUWA zlt^5ONpcpZYlvUp+E~8voyV1+fa4VsEq^E31Y)y`)V{d)bkFiH{xfh3MG%4}zO57R zhYm_y>dtdwVp!%qC%R3D9*(>ZIzVVxS=SELd7mFee3m`G{v+i(yMvlC*7@_mg!GtV z*QoKr#xS%Kn4Dm8Y9{k=-e?4raOfce$XgGOARIpOc>W&|$SHj4X;b<2T@i?3&HfdE z?m5z4x)*6VWo3VN4D>nIVAm~vea-YV_;;H=N@N5sE=uQ$=t0BxeR$9Yh8Yp`3^OO2Zh;>jO3QDY-dPMEQ{%Eu%*MZ|T}vQl3ri=2*HHb2>11Rga2^N#~Z z#fwf`>8rWNO*};W0^n~G`Da)Hbe1#HzlD&3f3|qqI*A$ekcDAcW@lwveFe!ZtmaG) zs@YZd>OU!oGkR0?-?o1RRT$m`NN`qy@x}r&*?#FZBX$Z=M4#60$avFk`>(rUQusj0 z85hX&xIpg8TRUoya>bVO>&@UN24o1W;r?pkf@sDM>H!nZG26r;6;Q}<;M2w^n6AtG zb9T$-1UW>{W%ZJ{gkb5~ffY(>&MesS&0Y9h9{$@w>|urFY>#)ZZVSrsRWNjP8;rC!bN0!JwZ`*9#HZa7_$a_opIn996b!*U!O+L9ppK%I|L^>dkytN6&nldL;(`x}C8t#-xP&fa4-#c-au z+nYkTo__EYLIFbNmG(9HFo!=iHSN^OMN|d` z!VGUBjTH+>GH#o}_QLyI?l+Q#TxtahFyT=lhn#vE`kwbq9?-X$BS`8|&m4wT9!R6e zzcUk>aNT8en?n80AFskPgf$fI?Hi$0r6(rD*rA?uv!}{p4ux66VDj=bZF_1yIvyE$ zRI6OQ8Np~uR!@Yh7I=M+3ZconZDCWcd-Aq*S@_k=`{qgKQ(!`vc$WTR;ag!$F!pCG zbqls~cda0ef84cz#55C<-;iX_O@_@DGIDXH%*Oi?oo>T zg9ATgf(<(0nO3IHMy3p_$s1iYOV7-8B*c~`#aa(tWY)Zxfi5Bx#&yEJ(z{HK%t@{m z*-0UPLIgYrhQD-Z%lk7UjYxnZd_W-|=F-JSNlY*f4*lBusw4T9Sk zGn)|}vNHXc)@9L-6i$lfxK`B%^We=kE;c+70pINXvGl{0AEHM=erWcCnny7+Es(*p z)TKTX>uU(LjpK0*6c`%koo1<=s!x{Sb;77cVJ)(%=y(X{@MyI>bwsn)L-RJ%13>h6 z{ee~`+#nxQhp$y{|3m%6d{R~EDsI`2k7Rb4TgqZKWnXDFwa(zZ_woAKAj=hDoB15o zBI2F=G{T!EdYMUz57aa%e%106kII@Ri827n-a(S7x3_b+h)JY2plYT^BE3>S47-xG z)-!Bqkj^&wK!a7GrdyRqF+2br+8k3(5ot%Dj`h;EZ-l$?tx@9FANMUj`2Xzu*b=*#2Lycz?hW=9ULI6U-*yT)$yA|%zG=3jAEt`~vRmufuCR@AFq zoyHHe@(ESO%$dn5G2wgXg|xN}g9&;p`#X_NR>6_s8%F#M9OHY34Ub4aY-E4m98RdR zcxfCt7^|wAKo4{H8lDx=eSQ??18h#$)6UP|9$zoJXDKJ`ULLk*IMCS#1>7%N9|!X` zPxLZ9tzYiDdb=(_eVnKEiY+c5y71bIJOQ08-Unj`JgC|Qxellls-A1WkSWL6s zW^L|Csn4vNOC1-WHl&(ZyUju5&QxU$m%s_XAFjrf;Hfpgp z+6ra^CB)JR(v~Na2kt6J$*2R{dXxf;{vx|-ThAxwdv3jydXko>vDttzVHf`_VBz~? zFG`#eTj#U_o!pPD@s*VGFkLRZPeOh0=#!O@H^-a}pM+&Qsi!i)jGvQ|w>IvVad1^J z-yQpl+nw|}*X6x}VhJ&;z}?1GMk>}DJSvy?(jQw&ft=s%IUP(oAISo!L++WrQ6D5e zNFULqen;B?tQWY%^iMkBuEiAC)`7y{jF~TkADu%)_2=?Z~J_SM!SJ;neSF{$ zaQD+4?5&$#YF;|6<5%g99$fk_$lfqqZIRP#+r@XtO#LXnEjkR%!76!;5Z!>^0C7EB7qulGqi(j7TLpN>ct^p-E&0!x<$}+Sj574S z0}*b@2N*VMJu2Qzeok3_+Ia`c+s6PmUmi@|R<2vf9ez>2*+qI_9XUC3i{3E&0EzAzaX zA~oX_$G`TQjalB{zv$$x+2WtCGfJGY5WqIYL3+pa_jU<3{||NV7$sY~rfa5c+qP}n zwr$(CZEK~Sxzd>{ZQHiFR_C|7>eN@K_U^74-G9!AKM`ZboH57qj^KU8b(_%Y#Lxc< zMc$to-ATmWtt3 z&E{ga)0p36>1`;)^Vza;=rTGoEuBm99CnU|f+lhvC^YcXv+K)Gz5*6sN&SoXMIgwE z0sAS3;t`jmL}lLQ8hdGx^JHGT`;Y^ju zaRN87Rdn@^;><&tj4rd&G^ki%MG8aGc5%CxdcH?_+VbM&It(qEC@x|1&Q2y5>cV@` z#wxlQHe+0BtYQqN1e2nIn@5TpO-alF_v%5M)2KczbzD<1liKE&bvn(~60C>`;v)!Y z?HW>q-t{yM(X33d4wR^=Zg!3NL73aPQoPJHRBW1D*>#>n!uEAVDgXRV6Dr3Furm&+ zkKxBI*r74E-c~T7X2A3sEdXcXbH4&r(4__bWtg`KVsob*pNaQICtN5wuoD{3hN-!V z9t?GckcU2}`$!hjnuswz&2zNDY~}{2FQ$*PYztyHqq6zFQo`rRE|Ed|)~x zO{bU?QUEHz)NBHfuFt*l9e^$wR(B79!OB>j2*BrD$P0LO961oA&o+QpZ7qxk%R-{5 zT$XguP~=1x8R;xEgr~7pS~6V1-XKPzf#On}Jx#`nG%r?zsVKE1+g;osB~eI0|F6xX3)V1VBf*jzpt$(QYoOV_ zwi7!Q{=F38>sJCCi1M7o8UX){#YjB8-i`~B zcAmmP?9LI6@fO!MGBN0anhTQ%gvcYOjOfe^2*V&6aYKv)m>R#`5|L2|YE%s{=@(gr zfqNJ&JW^leoTL*4Fe)Qp$=$YRSqQ1fk|i{PnS#Suik9f5bubD?gE7kI8<-k}w-_Wh z2}2~(V3QP@oK)x-rAe&d9A$+SiLv%jElUHGcb#92WykW8)#W%8Qm=r05k%XOJG7My)ZHplR^6gI33xL zAy0b`=)*3COvpedUGV3yhpX_jk!MLA_zB=M?8Z5C`ZKACaHnuZqY9f4yjTl(#a#b- z0DfTXJAgGWqL>gH2M;kMC*rVRmzxoIVS+H3G|_{pZsL5oMhNgQQe}+<>ch25Xk+Cq z0$&URI}lpn5eNZfFewVz87;#@4+P4SYdA_w%?(sFkR=oaC$P1m0{E&aR7EIA`Y?Ld z53)54INSkrOJ`0O2z_6oLYcf$xJpz5n{b;jOjOf)CEITdxTur^{S_~$(r5|ah~1ie zv~$#!;M-ccoQxM`O3i^(0Gsk`HX6xd5nD(PJTbsGP1WJ0(*gPlM`dVqyiriZ#8<#Q zdn53f*e8jg0+e-ZjCqg7uoo78qNV9ZWm>P-8#q88%=%@LsbiRrbG{8H4}vqOZL&tu zMm3(7!mB*d=OGN+?e%Vo2SSc>E^qJyqSK^e__q;hmLg;>$g=17TuEs~mQpJt=}kKu zXNH{H?hjNB6RRalv)Tn?`;lPW4 z@mXI)h)pG*K6ehRGt2^me3aH%?Ud*4ck$Fxf@ z`uf?-aj8%&En@83nhJy z?7<%IA}Legi_}o~d#oQ&$s{DtLd~bv0YW-Fy1$Ij$_hPb^q?+N0aO8PU|aoy&$X$p z(v21ZS`DR`MlQ<#AFL>aB#s~k-ngb z9%;W0aLXYwq5CTYgb)`joxrH?&x|S%^flwW3?J}w1~DAQK@-D3ucJJ2qC+vZgftp2 zz!Hu_`Ysm``Zpqs))=eXCL~qlJrX@}UIN)^K8aqDUEuxe?QM^k)~^#?ORdirR%g(G z7i2}*;R}lnw_%VMZiTHKZh&-BX8y^z!_$>K@DzK(iP30D!!=e41x4_rdL;X&;776x z^c%4bPE3y{&#(Amd%PEqRp-e)16rg5F=R8C>ILkPGebeA$zp_`#&+>i6$iBo5xB+; zT&eY_j7A?BbK?t0R!H|9!%b8qh63DQnH91VCPep(ln-N%m#!4Pn?c&otfz$s~K!nLH zi>;53o%KJ!$j7x|oFmg3_KQ-4m#5~jwp_~K#;|S>$eQQUlC??D29{^%p|*U=Ag0JI zf(0l5vqUxjqkHL|^GU_~OvQUo_4Af0*C$m-$uAMlI}y(_QO_e$t|wybL_ZQ--)|Tn z=MD1wYbUd3HoxUFUa_z>Kw0*^&>a)qrePrGH814i)+}yyJRz4g7r_8;x1UbeNMdk)jF{eiVwrX8jzeQ z^)OG@a+Y^r0{ZZJ}k!YOqSbLUxc~qLWhd13o+I%#M<`;CGEZ12b6nstE z@7O-RIc-qc#em_;4ko=>yIU9iM`My#JqG?ehk)S2u!08Ldh2K45xzd&75?oi=x^Z2 zuxk(ZUWgCh?A)Opq-p0r3%OFCEp?sN%2ibC2DO6`yTJQM@CE1_#V7tp!n|Tkt|E6x zBIlA2d<=e6`H=HooJm-Q%-DB!dd>5i^P1ByEPD?$x zA8}1|ucOCxQ5#j4?xoK9=fgw(jCJbGAV4ra=9smt07gAdGl$2(OMr4zIA{#XYuMGX z@9j^|{K>Y7&gXtShj{d@7)Wd~n?zB8QMZz-L{SyDHu&-D(W29-xk>oPLZox@sGS%h zq^p4~%}0y?-u8%f?%>?b^VkhGCs_GZkQW|Ne6MqGdB-Pm-u_kO$45;4+cDb2^;o*;PIO61i{|A(Yea zuddv+T$bRs^nRZQ9Ak3du<$R`#utukICY2OHpKKdB-nv~ley|55bms}PAPxpCqYw{ zP1}hm<%_MFbF4;qC_3v+gBOz%z#9|*6Z<(MoG(l_{c<^-Ez%JDoY}gB>N3FSxI?}7 z+jV&eO{(p-wEct5tIA9I17~OmQ!VuQq)b}6LUs&qe=*e)Pv92kSRwmA!{a(qVCFp^ z73WgQR(Z*aPkW4vm_{gK$Hlja9SC$8(tAmoE^v~+ptSc7e2th6@rU>k(mjoshLZH1 zdi*40!n~3{qaIpLt(R9C>yCZ@x>8s2C+edvr`|ZNDPb>AM}E3^kGp$nQ^%;pu{>JN z`4}=D&)%MJGO&971sXgqx8a|y)87o4%#0j=-Q%xSWBC__j{lMz){@mw(UAH-pB(Dd3$V*WMmZ>*PtfsU1pjpZNP{`0A^GO^HcGB7c-uzVlke_1vEvD3dWZvH0OqP!L;Xmpm^qyymV zTUhqZg9u$K|1~6Tf8>5(!Ua)Xk0o@528^ zTDTf9iL`GC28d|Gh6ntM;qe644tuTTR`oaR>5kBc@WzJ`#8Ouw{6k@*ZG-OMCw(Zv zV}3{vi;u96$Hbwv*lBNY!d`sD>@Zd$Ky={9SB8Lxi1aXX9sgj}aH?MViYgE)Sk*%@ z*dwGZBEVz+Y1X6to7iAi1r+~}?PF+aTGVIiEk1qP%9a%r(BnEX!U-$w3X7%g<2T)s z1tdooR2zy;J3XD%Eant$1q6C5ifB5Vn(oR93-@ISOv;CjMh_K@94UFq4mIjp^l0j+ z7c}SLVRaSsBwR3?fJDb8S4i7bp>W_8Y!oSThK#Dj(1!FAbaZWOnltFpFdGfQ+|jJx z2%3qg)KR4iR!tkBrpuf62WLCh5(E_BhGCaUH7U|k`Z3<5y5nRY@?3%) zv!=PM>BM|d@&b%N!veWd{p^Ayzzna&W343khk(t7=}##A<1;>JRaMcpYAdjEL!Gs^ z77CBF!Y<2=tKy35;nb~f(?s#k{s47VI86;o*$mC^Hz`|g2dE||3d!K$KAB|4ZOH8yNg~^ zS5Y?<`fsZlY~DE3-tAnEf?o1hi!a@_It4YpeM_y+yOz5;IPoyv>j9n@r$74}Y<%~L zy`MJ1m&>%ggQ0Z#Zo_xL*!UXDvqE1n1%nWGvSG}lks>jfFt5kzIG$9I&xK3>U2iG54C`0`D#stE6@4 zJLMT4XFb1tG9MSW3it1>U9Lx6H$_u3u8te#DD#4FH=wA%&;1OD4dTOi3G`%8Zl~!o zNneqtH82qa0>QA6l!e_v={(O`c-i!a+IfT*SFh>4UK5ZV&b#)0x#~2&8(`YT^ggYs zUXkgw;AnDiyc%rNa~|YraCk3#`z@;7l2O)K3#_X>cObI>S_Z%Yh2NLM86YF!0F~4S zDNs;Gs_YJFL2$tmL_-7@pj z!wcAR%R%fXLxo&#jg|Km*hy#jHLCgC&$w*R*4;=sXaLyINqdiDVK*@6CIdcSKeAv4 z^gYHv7S|Be?93PFoX`hj9X3cnwO)#fJ1oseS&bWyp%uwWt8>f)-bSTGFRPXHEi{((){3rSRr{Le8 zw{*2J2DHW=DKt%eAK?N_$DhI(l(X>k6*CvGDjkOb?C3sGo6NqSua5H`pRc)}{5zf} zj(|pgrB5(C7D6XwB_vYA%U%e#NH66P~`)+c-(d z${M!BbE1RMqeY^n2`$d!nh0q0l;wo(jFm>>0x*vt9F(bie=wGkQyi%!ov9;?DPJCd z&}=&ALU^_SLD`E{(14<>#1bmfP8k+87mc+xUZAsn8m(nj*ZFd2H)i& z{*@A+1boXj3G;}tVM{ihum`wnJS>$7!$TVKTM`WqY;gG2!`F&TA!p_k7D^7ZoFdH> zg4>3)36R;+LFjP(X_T}{4wUIag}`pe4uD0J^6ipi)QFPWt{hQRMu+UfIdf>F!_X5Q zuT%vrt+nharj(o>r3QZ4S`vByPR(>5NEjVe8-WLtr_!8;-o$zIG@)Hb_47=5;X*!_ z2tJpnPG*KZCsQsl^_|m#Vs@qigVr0|?{NI`+tVbs8hm#-MqyPO(5sUw$iKn``UFsh#W4DISN z&&YiK(yiQZ`R=X6$hZUB^W>A0w&78JswOuP{l`T2NCGETC75Qt>B>1;7(|H|&xB33 zE;RTd-^uk^5as2C7((!x9C08<$Q6WxMk6faaAPq+SDGoa&s}}VN@|WYyo_*v=woPO zo7~>qT=;U$n#;}#_&7ECH>~lN4EsUttDe+qx#Un*G4B5o`_hBf_rf|jS&Nnx`ZRFj zpwbQs|4lq~3v}Ls1se2U2i4bW+S1VWCmM$GF&ZWJ8E%sp7%djX(=c11qZ?)-UUT73 zd$c&Fsbf1Qh)ltXy%RX!{uXq!yq?er9@Qu*o?|;y~E6!XC^jyoxL*wUHx2nYxSh)&p z)&t9I%My?A6vxY;FiKBkU||VE$bNafzf1Cj+vKp^p768gypc@%t8;g7i1fa$BFHZb zXu}Bh7t%DNm)?2d40he3-?5KT-e;*$sYv`(V6ekF@Z(dL4=3l1&aQkOX#^0ar17bL6 z<2G;)#vgiTiWgolbiP;m&qk;&`a8Wy`%TfCz`gAwK$b}PY!kE0uh|(*Z)B+=%E!8N zh;G!az-wXoV)eNX=63G6tQ7qsDC3G0jRh>G(~ zP?5mU{T`H7pnOE=goZ8D4=j@h0uQYu>jiwmYwt!SnnPH!#2484qwV(b=k9hTQCvXV zJ;A(P%qgZq2XwE)_!WEC{)7`xbPqZ3Ngvh=L*Pe2{KxFquBJD}gWzoqNhj`SFdz4> zGx|G*Zzd1GBYP2c$BkpO;Uz{V)YCqFUwVMA!IAjg)+y~GXujbigBLVE;5xY6ZwxFD zd+w25D;kELXs=l=3i#b$ui~)uMf63s3UWoZQlG7fx$Ku1+kRiIg)_EWOzoZo+Z)ch zFD==fM0>Ef7aJ=rKXj3|S33%gO}`pD*Gr|XfR6777uJEtMSudKl zJdYO(EY@_BvYG%#eOJo3WUMZgw2RV4qZKhmqYh9D2ypX&X`}fCLqJ>D$rvQ_EDF73 zlP@JD)NG@g3akilXqEs%%!w|(E9K_!i~!UMlTs|Gftsa4oUOiIM8$}Tn=pbVM+#S# zQ^9`T^fd9+U@hp(sBwU?FC`R=s}fJBRTP{w9_*mz2|yeQRvIF+goqU*M9U7mVtN-a zZ4GtvAm_PgVoG1}U!-0q-SO5WS zeH}vkTO`x0u<_kl`1@3i>tq>2*W98yg#*Fdns;=$PeM4@AY)a(Sc*jG%c+8Yd8b0s zUMUrBxgf5VVS}Kemb0kX1qfqrO`@4|e<@{a9nY=^I@x#%Z|agcqaqGago2r34z&gd zuxgRKvVxZe_)JM_IK4<@N9mYn8v?AhHCm^taEMYmGCm=y_(vKCd+yW52+LDL9=j(P8NbBj$}hd)e;S zMb|*G!%^b1dq^@!a+!s(i49&%C^=~eN*F1MbYe5{9Gq2Ye*y`a*iEJi0+wkpk8r)8 zJ``~nv#A5dQ)xt)vlVh`VkCft;m?dLjbd7yJBpoOgUSBL~!PBm+`6 z$JB@xR8l1#7lfhWC_rO|0E8C;BRZGCvrnG_3mkH|sv+09ap%Y+LRh}WXcd zrDG_eWPO8KCP)uezaTw*+qa9!^Lg{O7QxmQwYk6l@Ai`Z^dU)B$;&hG2augBI5<@w z2A&M!_yZqYqQU@yNnRsONU67~In+K9hO7wDt5m>KD{XK$aUxOb@TlIXzf9}Uqu44H zo03oBP7sz}pG>c2^bI-J#Q`o>uyeRP`d&^(y7X#RHq!OG)qR9GPi;#X*BKY(v3W&A}z_cnQ?F( zAqN8HAdpT5Z7#*6xqtk_1miqfDl5JQ-uo$_*@H#K2N!mcgBmTKFXFVd9jSV&C~HEH zpc|z%Em*)KHZh{rV|k+-xo=Z$35uF3w^S+@uo+mm`c!Lo3tYOigumEmxm2O68+t#7 zE=!VWpx!Dx8pH%Rb_WW>(=rUxBoiZQoTJh(*5!n4mb)ZGOTJ)5_AUgwFPgRasmOpyFVA;xVX|+Tsf5yexzrq>Mdcu)f3kXfA}imr(K4CZ z;2tbW^U%909MCW7Cvl2YnK~1e=r2top6Cd@@7}@?XU($kr#!Qfkj}UH>s^_)&@_s6 zoesCs0NHxzLiMe4#qd6IW|Bp;guPrR+@CzljK`?WBK>pcc%P>Rxn-kcfbSHv$Mcab25bqr^%mHWlu;IFNV{!e^y`8C4UF9}z4T zo)^Ggs4R>i&o?9R=x+@}LIbi%L^hDC|8p3ks6c?}ZC6BG7IiUC)Eh6s94fb39h zcX6M`8aOl(r^$!+W7>bPpOZ3CL)j^W=U5NntD64YJD5&j3q^9yxh88h>(?` z`gkvBHI>jHQ8WPe(Vo7%q`jE$F3fiZ8WRwMlz}-BX|;I^mg~oZ>Oq8~@UA(LaQT?73-3zAO%H?zz-A zSTbarfi9kqHLQCfF8`xw!viJh8M^g@Z zNGG5fb%g!j$vl8GCN;pUCI`F%$01sQP7qMxL9b$qgX6NZ%D2yVjiRhlQ1A;@Kb~?KX_1saxtg}iH;KzK;= zua@E$EGYC!5^m<>T$>}ekvMO%VkM-P0~f$Tv5@Jiw2%YVn=nq^oA?0&*Gg#t_NBH9 zHM|e+{9K^#dGINvz#VKc_@$MgpM3~51O}}a_H{YqEM3qdjNSLUM7zeKUJ(BPODD7u zKpXZ4_WE!;)fq}^u?Ho`tdc3L<7e4EyNE9+z9%TY7ihj8sQk~M!s?!Y`0fDsp8@i{ z0p)rHTg>#}!|8f-DB}7<^g_fvG2!|n@?S=QuZ#3n>3pF-onz=32_~I?} zo=1&Qf3Z%Nq^Km>j_n;<+)F6Q=E?PBHp`ImOC)V5oxO~ZOQ|iF%-hGwbC_D}C^wQ# z#$`ngr0$G^VZJ&4*etUc6antV&mo!I=@znYx_v9pH!y%TFT_PLK=19p? zB-8n|U*KKJ0cV=HK}zS69>M4SqrESexJU8X57Vdp#OYjC|Jl)Hg*8E!s2klmIS{M?CLfo@DBd&HG1S-H`;XSc{H!Heh)G zej{Gc4YUm}z>=V0_-2f%yM==5#8gji&l>#bEa2DO zocl7ueQ2d?7CxXkdUivx@+FBi`=bqkv^)($TYle5j>jvACQ~N08c$q2?hLxW7mqy8 z?**N^Qatt8Qo2+0i$WdLZYdqS$0*tU4kP1wU7LU+0Z6dV zqTVX~8Yq?Mz;n0;E(MyrTEC|EV5@7foufR&GH?pKSET`3WY0mSIU_By0R@nHkD+h_ z>6nNsCleDAjVl5Ga)CinGVlUI6rDMW25b`u&wj{98E7 z#>B|-AF1EpH97w)!T2AToD}|Ha_W9S<+FpQUS**+Eu~Ou`FS`Sp7jij#6YP89FZXW zy9Z27yAs^MX2u}?t;PTPM`Yhla5Avi>_}BW^+u3Lh67t#E|r4Vh<1v7M@*h068s02 zZY$ zGyBGM6?Xf6By0Ew&My$Eaq^}lXDGFPDHvkh#MYsw1xuaA-^GMl$|%WcJH`fAZ;2T~ zv%(rEG!QE%F=vE6l&?t+dn=Lp?4azD+Nidv_Zs&ZA3I#7lJn!&Xh'TVPDtx1H& zcRgM=K1xRq&{&lI?*DAsf0HvYu`&F|u>UG<`}er$Ka$0N8L>(T3JR-f{vRK){v##( zdv3EPv0r|NW`|kCpjv zhL@b*UZ?*YUiw&i;0$LvsOmeEC(*72 zL1=?HkHigw8Qtt6IMXDAfcme6=pbk%F)~pU1RR7T;M9T$A+eEM2n>w$C4&xNNk9Bl z-QvXxl)OLke%@&<>)Pq8-uAko`zy6XjU_-E+n~F_{=L+@Z7p75#40pdW~+Xa_~)&K z`$nMRegmT6_-c@w&i`mW?F6w(5fKU64Mw-^Ydm@99rp1SKW@~MHqgqZ7OAKIG{cZOvhL^Aefr{Y8 z^zb?ijGo8WI@yH0c!WRbLkVM92ri=o6CV+M4iTGo%5}L#@m1py-1~H4;9*+k;vSEP zp2Ps7!v$Rh`A)w<4@E*xYrK?e#34gbvtuo_a@6U6j9#R;G5GlX$b4GKnyf{$HUnEr z#HFsl?qIqh#BMYcZE)%G2|mR-wIzCZSM18Q1ls*s3Y#O;-(78&9Z!ed zFM@~TCT3)G`np4X2^O2ow>fI~Pj&C3qWGTriiU^yfJD;FoyLRBmVg$o5&2tgDh69@ zuQ=il8oq6%OOye)YVvLrd6Tjfp&({N9>*(_B%ZBBpa7Eq%p@u}PC$}JQ ziQZZiM3lu9dOHTtD-c;hEtKYDtA3w(e+Qz63vr1b1`dwF+;xm{cg|AbdHG24g(5;A zGJ;}MsNBGy*CSO@DAAI?(5Owcuhz+!WZ{4Xz!caLJ>7ZuR}}=e(X54G)b8pRwgS?_ z#=M{|&d8fr^8dM&I5Z~vVh*JW^zQ~4gub&ZffC|LUriM zD(OVdmmp1sI(4Iii4#W2qB6dSzz6rnG4C?Wo7qeWO+pAz+J1TBu#OorJ_(qq{Bz8 z&}pkEBw@~?pER_?c+{jEOK4rBvXSp5kW!&7q5J7&0N`>zWiK1kZ(E#^MnSr-WTI~Y^+5>4Kg>nSg6v?(Wunkm) z+}eaN{Rla>X%(s#&KUg^Y)Am=H*B*Ub%$7&1MR{!Yh;g07$Xe<%`^pV4S^X(f)sE| zU=;xb@LwhYkj4y0QGo2*)-|xvcCE^k2=tJ#aZA3EW-V7R>g39^$g``BM6Mzm=rd-^ z#v!v?L(m1iCksmmy+l~#M&t&BHFSS1O5$>Ft{u@mhJ{1fp zGcyi6jBf45rFf?lm<-H;-~cQXY#2`XK+&5B$_>MKJ}W{Cs<*6g>5!5>oFl?DO{|(* zBazkkhN9?+qWB;Iy_^6{qpg>g3S2i_W@b7dDPox&1%!~3ghW{mRIsXwSLN#3o+PTj z*E5kB1>CpXFVzLj+Q01QF-clPrUB0I*}x+YtT|(x*(UIaNH%>z77Yy&WMavE$$-t>4f8qwRz2g622g(spaUx zEy|>C9zi>snZufqvy`Dj2^2ApjtXxRp@fDCPlJkj>5y3~QAj{)O zR`%c@bDmC;l;UGv;|YOAk3x@IL@j0)Tq_ZsG5ypXvq?1Hv4&na3Evquk17EmAKCwy zU_zJg>3^)sb2HUXJT*1m(L|1?<0fk=TfT#~)>%O4$xb{IeW|hKYH6dGi7;@q8ot&3 zLsK!%-|<74pLX=+7f(43v<+S2+uV6BY4rHGv1z_8T(>X6WEgw^+QXd+94VJgQOD9C zC#a2EhG38XE5p)G1_BNt1;Dft(hyiWu!9z{U<|O|oLzGRcSTW=i}iBkbEY_p66~w1 z)kI;JazVu&*Mf$u#Ps0%y|4O*#++dJpm8{6n}-t$2-qrvm;)TC;VuC9nmCS-OL!uo zU`1_<;!o03vvFBk^@LIiXQG;ni!jBRjds{lb< zi3EorLnx7*O;Q7}X3_EIkoX_{B@-w5ZQT$0Y4UP*uOr9yeB+ltcgyBQp}VqXc&AIB z-G2B!m1pIkQ_z+q1gIlwS=Vy-UTjk&p7cQ1WEpb7Vk+n#AE~Twx-k^@Dtk~8#?2%6_f^q3?Gk1644tl5oI5f ziCDxY*%M74Sja3Lvuo1Od9!=Cdt$P8(1?ga0A|RzQYGpXfnd5@36jph1tKt@LK^!5oPfMzu9Iu4elK?!)jhev(4IU3juFU-m zpN5I6Z)~!2Ht$kVLqk0;uYfkzovvl+T>l)?rGesh;Ujb<{z1Kqyv;_b1}dkIV+UB? zwFD7}7F_EP5($TVc0q9j>%#&7Dj+Rs8d$3_*>^S|10QLsr?a8;>FQ(RVRH^)mx6fb zARrFX-z*EGrYMsRPTX@^UC*@EI@F@4eaOd0a2a2=(=u(6&eg zZ-@m@V*x-7OOKKB%;U|J?rBvyrMEAAgc^k2$Pu+Pg!5Yumif~}@ToO@5*}-Iy239#RkeX`_k`K^3 z1)X?bx-YhgDguAn#Td~R3`COaF(O6ZhN1muOj~N(J0s(UjmsO1Zjaf>Obfmq`z1K# zVKZV@anP{Xly|lv>#B{CME+OhB~@7kVH&{%!TljeQpAT$X_{yL8`nghk6qBOz)i>& z4kwk>Uo_#yoqGVTW^LbZ!;_3~zrRk&W1?#4YgQ{b8>F*ZWJBfG%gm9$Awaed?g}~1|i&m6q_gu7j~{& zCCf~h&{HOhHeNKQCxr1NzL9QuYt~lh9>pWC6@a>`obHdwYLs=xjnt(&H4#xziniP$X(Q4WJpgZe=$ z3Tvda!;SB*3tAf)UgtCOE6Vn9aI*8}$AF_*LB;Jbay(y$ ziCL~@Bll2LD0DbiYb%)pVC(j$)JhaIdYVcebrvV@gCND95VHJhp@@kCeE@aqlo6^; zAKbwVhulooOhLc^TLIOS>{aO*D!VDY#ts`p?7`cSu-h=)A#6bjKRJYZ8#V~ZVIBba z^EvVAk-P<#cY!I~bFyi!Il8bq>>$ic$1Q|hWrD;fFvk!v^rCBsboQ;`OjNEI8Z63kmnNTs7H zAeFhQgESs4mNu5!9Ig7WvA^KkteuY_G$kH+ z7G?3{TE|X>^(5Wa+vs-mz7P8PxaK?=D_W>7|8*MLS|d+L1JJkdWKtf1VT?r&^w$+$P z$PF+{#M@lA#sD#_I|SyC+(~D3)DBbvcE~4h-LB&pd5cs@FjrL~EJ>hB8m1DuX>O@1 zSrubGHudA@lRAu!;Fb6RD2WAa9v}~LIgmwNQdre1Meiv36D?I_8jTf9cFhAi$VukC zHhSNH=V8+1kr+Uu4!nR?*F>cr9XugcIGYf(!8V2w?$HI*pB%YBH{z%Q4vNri(_DNf zEL`p;Tx_TvQ5tN1#9g}epy_^$jGP_k%QH3~QfDJ|_L`2anx3c+!_YknI$Dk0Q@H8n#9mge$gz$! zofZpmwAvHZ*4I5wTtaWg$jZZ;1KohX4Rg*Rq3ukch53vk{OY@~GdNJURIGwkcesWM z0_aLFh$d+lW|&%JmIj;aP?|g8L7HK?EBzCn%6~L%gNXNLSt`X&1$N*dCx3-lTeLYW z0a=??H)Ikb+K;o?q*-btj(nH80KCpTM$``SQ5P#3c|rMwP@bD}GjGIc{N!;yWbh7A z)l74prvPVF(2$BRK~5KTtZ}Um(@x`3=JhSZA~9h7H2VU*-KGUnhwaHgZCVmubc|3P zjJI(vsU5-n5&deQocU3P@Biso_H_5_=J@x_mb-tmXtHu>KvzEGg93oK^PvjKE--K2 zEn&8E=Eh`~XZV_tpxi?)+o2F$8|@)URqQy%iBHv!3i2Zouh?_S&Ua>IgYKc>on%l1 zNg^Wrb)Xe|&j6sYL(md!yfg?q#UR)Ekj>gDl-_~;lxke#^GVdp3<8xoKYori2_ zhE5hPL2g|IV`n2qXKMPTqv|mGV3}uRuXp|&4z_$jzv)GPG=)oDbEX^kd&u80)33`I z@UxitO@s>4uO{H>);qYRkO#1Mrzc?n_%rdWxyQ<<`ZMqy_f(8#jlx4L zIv`Z+5zNlO0HMAEt)iz;fD&T7wv&MG$?~!1&F#aH3WoX>6^jWcH>uS;u^qW{ZVbEG ztMh%!ab~UT5uJ;A-3&_B=s`|c9DhV?xj|-D`m2>poUg#1T++OmK_yg(`Z#k7J0Jf1 zeJ0r8TD;ZofN+92BARDdb8>dKvwzJaS-?V|5J;y$EK~p%Di90Z&maUc2!R+AA2Z-! zz$TaWF~&u0M(O21B{o#OwJ!yu$+4V{Vf3SE=Z7c??R*b0L95$x!tMa`&F|}Y<{RS~ zd;joZ@|&Mm&mY%aU&|jEQJL&!a(ks3Lx4K`56PMA`o3qS>iRxUCnK5wwXi0c5d#>? zV;ugG?vjS-ZPgAxoP(|VTx|n6HKJvTEMp^CGid^~sI3{hPI90e%;iBfy0#V*oj;r= zuU}#g0O_$q9&7fCLqzxy2v8hF9cG7CaXaMZJle*r8EqV(zuv`(6Bg|X03~?=Je8mY zo+q00;_af$9jkn|%RE4%H&JSEgHknsTZBz$ooSrtSyzjO$jUoUjl+T3TjNU6dHi?U z(FD7<0>zB6;{z!~2zv(O=ckmV*Y{6Cktkyf7GR&7gjto=ICxMt)apKefm>AC>9U?`_Ba zdsv2(rkM7@`?+ber6SLAdaWsl%Dp0mS|m~8u2CrNz-A&r)Qy|+Og(WGVXdDE3xv2! zSyZ}eR9zeEPeqm1W?xzu2NrgrIh)Yp4V2;!G^P*>iWG0N!3h5$xnVgBM1=aZmaT3z z?wW=SDP?Pch;X1Dk4Q_y=Iuoc-C>uIWErMEAJvdanxZTatMy4@yQ^LbCB3Ctp$?=mK z1&kXvX;l@hLw1$3ynM32YNi{rYV|q#SQx>1Z47JT2PDFUricvh%DuB z9MneBzWb2P+8=R%i$^PW$dM>$^w>nFf~}?_?mO*n+k-n5xD*-+>dDy5g+ZbZ(2+tf zqOj?+^44z^Bm=*~@|9`=)85Ca(^Ku?#RjRBA6`^qFFC)07fXzE89OOi8@&dLaAUn+ zSlL*1NLkT;9#%peqrZvx+uCY(?I1az`P-i8#;c3?Z?1anWlhKVWY1vob-NG4qAsQ?hxF9TX1)Gx8UyX?ykW$9-JV-JxFkOfJNd%QujMh!)kv3;k@)EcRlGV{)vz(H28xN~ zVI)t0b@ry$0{8qS8OT0?X=l?LJQ)^SY@lr@ZQygfjqDfFHUG|wcI`{SRNEI@=S#MJ z2~~Uj<^1|PY{)W=h_a3%LZEJl?a9pqlLw9+Q}d|VL;p&!x}^)*Mm_j@GbrnX zojmM>&;WLK)WGn7U8>C70AQ}EBaaJIIJvE(b{k<^U#*pxlGit>P<}NfFHymxp2t$j z3%t2QwqrEC^$G8K(&oKA9>bY^Be8w08q|cvpQNTm1?qU{_4zJW6dJ-+dzm)vvXxay z&{PHVpCU7d&RSo)q2J2s*Oz?m-z!b{T>$sqqkFi!JiMg6ZluZI%uZHWr4vPA3qE~e zbDWG#O`AhlJN!cP-ok+7v5V%K$`{cSStsbprLOmUCYdg6456(j zA%Q3-CQ8)Ua2QNvqKTfq{Hy-+ZSPDADX;%}467r9Vv^QFnVNy=mi%@ZrZKsrYOQQ5 zNvX7qMWH&iN;a8Ibb`_dc2=Q?+QudsP0egvrntRIqI4oBvC2j*CTDkl6McVu$WPQU zQgRfWB*A$o4TM(Y`i#uc%%#eVslFoDrg(hk@xhENd<8+iysB{5W(@!Bv*%j8W zPZRSSUCz~mFP_;I;G9C{1eM?*11d9k)KM0kUSA?FO?sDt7itjOQP7X!mA^BNXXIIj zF_CVU@(MDMtRPY(i?HX|i7DlLc1%EdEuG;Fh}ehQHE1|+w*k_x`t<6F{+c_eB-V1S zs@wW%)AfZQvNBq4E88#r^)}E(4hC8owKPP`Auke@S|_Z%yHT;fkYA@S>#6*ke9{ZP4w(9x_`1Z zIEDE*l8xdh?3wp8U4M{vkYl&DdSCz)_zK~MBm8vX(T-C|pY((bBn0}i1BfJ)UO)Axr)IW6x~$G1gNq z8OO%%swXig-=}QuvqYH+hbCw5VV>9TyQYbNzTLmr?hVtE55R#8ZWurIHMDNHNE;Ce zg$*SQA?2=3(-QVpSHA3{MN>z|Ikh8h2{eJm~{(0?iuV zFmOEKubGXGQT8x@jmopqzPIG|Kwn1ydVJnhW_qSHeysq1_v<6h#&!VEKCjZh;gU43 zlEn>i3bw_gZ(Vab@&NINXa1}D0qreO6T&Ffv`Pb3AWBxgJ2`K}xkQ&()`lalKv+QJ z7l;!vIR|uPh(-mME_P`7KvCT(38z3DpVJ4HzW>!=b&BB)ges)v+}>M$B!a z+;WqptIrL=@BxUf!5W%66-?`xtlm)l0YM!nd8peYWvwY4U5O$pe|~vMgVvBr5YE2lLS~krl`w z4`?BC%AcY(uqM(D<)lQN=c=zH8r_^M=~9&_F03M~#o0>G4e_jT#MI5YJcW@6{_(wU z68c72WcPcppKDF70)E#NDNC%aI<8&gu1iNyA! z5932BI%>SI1j(6NFNWlxkyKo+J1CTCbM3dq79&1_sh1 zeJ_7pDgNp8xkdjNISeBj`g129v*5QIRucUC8$zRZse z02??eYAxTjkQP;_mN{Ph0azw{^^2aHEFVDV2s!b}6x*Otan*MY9$w;6AHWzK4SO1C z3q>-8S(31R7~UW*TNM+bCMte@5y5!gp*_Y%m;JCt2!Cvo0<%tTDYBX(NQlj`DQ>x<`}Yc0?aX-gPJC_qS)m8tQ|n%5 zHolrL+5f6jC%;_5UG5NN@SfCFv#oGJf`qMn^lCsr*&369NxFEJ^;yDr{8y`Q!v~sP zbLc5mbhyD%IxLDp9vMFNqAR2JAZ7)RhDp3aeegmw5__Z)2flMFW?w8vDy7H5S>h_G zkM@4m;>7I!&OWN_=y9dtW=8%*32xXF)*ubBwnO;>akZk^7jc>3XcePm>hABW*=h^@ zMrgXGQy(Y6NHy5LNpS+3f=MX0n3k7dS>HjCUm8=U)$q!+`X%iwem3{#&CZn2PMq1b(O&(D2w%wMs{_m-98$>6Vbmz0OILa2 z=~5Pf{2f)4Oz;&4O=K`x8fj`2V<;Y?$2>lvmAd`3M$#9O2Y3cUl80g|Iyk3FvjCr+{Pzodp4f>FjaK_yzd6>DMG>7u65Tn;7%_3d8CNg*_$F!y2vsXG2I`jya zeoF0uKgKn1VAZUARvTYJ$sd)ShY-*L66HyLu!r=3vTi`Os$!BA8HNe9q$r~@HJi$n zlY#w4Uv4Gg7Dbz4<$pzKmgmKqgHu)fGe@~nC+1y38uVU-F!>Y#d=j&kidfPJ3fnq% zc!7P#H%aniUou`X9ZCkv4YJ-+NMMt!4=LH0NsK*8g-uxy%BGZ&F0>n*kSc4LLT)k2 z0Z2vcV`EROtc!9P7ubpLv@9#mJz-E;Qn?VtsvdjrPl+06!4JvB0vUN)?m?vBGs3ox zq1gu}g)BhxV(qW-7&_Hal`AM-u!+ox57?hdvk}c;>-gYaNDsN0X(42;>yX^pN}aBU zTnX9vaya=W)`k1hmJF1;AoCS(Vi2i_9Zo!$Hnzt)$WLq(I#+e5fn zDHYGbJvVrQ;9$Ev@^1w0W>qU$DZV|T131C52|@2R863}5Q>{Q&p|*`TmC$Vn2L9Hf zE1#%wWH^GyTRI#`5U^24y>KF*a*Hk);pt0L#y{%hVkbAi(lgME~ zkDZ7Nnm)yB)mbtLw6vCtip+s@g%u4I7RT0y`WAl9OjfMPy{Yx;bd4o>-=ee7)}N)K zJW*h6J-R@q2+?m|?SMymHPO1SUX*#7;N?luwo^Cn-F~Uqb|tZ=#v;#ViYU(1t_0Uh z#$5I^w&)z1aMakYTEL^~0vg_kAXjUt-VPb6_wEwSijAYrl>~Hz*O-WL?Vd_+S6(J? ze&i%H2otAk1eM@TQlPm!2$c)?c3eXX1m1?^GH)?Sc{+1g!C#YHIp35Mir*qPtv_`}!WM$+``%`o zXxJ?8OvFR&Sd|zfotQXS;Y8w-rg6kLoVF&3S(fPVW_U{oJP8VE%6FW0IKGuYQEIRU z6^4~5*B%Pd>(Op6tvF>fi2Q>Dk2GN)@D!%7_C>;-H-`L*)bz-YY>yBJjxbTow>ZWQ zZzKHSUj4BS!VKPC#A+CuW!?U`4%n0z>Q;yyH4!Nxo^ffP7w9m&7SavNzjU_^Em0=+ zF_5;u*U{*8WmxHRT8F*EaC(Dr0B_mI2=YZ-dD`4#RrPw&5;1;p25XAj^`>^()KaKI z`N0%C!9?IV@vbc(h^x?Z!@>xtu-$`-=Rey#DYb4|AgxO=#GsMHQmN#aE+3Eib-L)km57% zo@U-nU0?X+2sa1XHGe@_;n}ml;>g4m!EX)L)J?Y0i>(UHIuaub`*p?4m5uLapocv0OqZ@T8xK7e8!d+dzt zBI>}<-f>ag%VBDw<&DV%1EEu?H{AS6{z@GCNGo_nEBH(s@T$&#LmTn+5nb>KUGNz_ z;FXg923@A}LYD0LiZ1_Rc=B>`6Dt7vU02ALhs%NsHX#SSXQU>9)mL_&AHF9G*q$$$ zIER5{=tR0&`b>Zk)6vD{y3M-8I&#ya#cR`=caL z7l&@|xvg>`d>yoafDZxwT&IIBT%@_HQ|ID)kKF7PH<@uPaAgT-vvU`{in{D zR8z&TmPnXfT$1FE*f(Mo`rpsHa+ch2->rw-5x1VBvbjJNR@r`6v^P)f+!T~tp?4H) z&&cWaP1#;My2$gC@FF;Kso~SxV?Y^dkK2?mP`c+TI!|GpOijYkJ;Lg{8@1o8^)%py za9sLD(8<)mNRae7vPjvL8|vjgFK6f%`owiauS0WWht_3N!#p{78}suPcd+N?%RT8c z6zIEFDBI$Z=wkR5b+AYN%K<46$_J$*ly%sqkv&X5HpV>HG}n|(K4SL-Aen1xmLVC7 zztm{!%@2Mmf(>glS z793zcJHZGhth6-|COdI9*QGm@itGYd27x=TVWlM)-iI-piqj zo$c3)cSMu#gkB*H@29tqdxro_NJ1{{y!_yIm#u>rP@O8;Nu?-UeI4v|?Ctbu@ZTvB z`l_PbH?fYAI|6d9EXAkH9 z9XtMClk#ub@hl+qH_%hW^gpeO|F{wVCwe>^3oGNFI$(cClK+1bAmilXW@Ke$<>dHH zT<2hA0m+N~q1yHP2!F$n|K0sh#P~ltxY-za{`+r#cXEF(F2)XWMrLQ_;NoWatK`^U zjEzCcd5mlzCjTEYV*k)2`-`I3zwklEPS8QHo1NX=i4_!nd4f2IHb z@pAm@EMw#O*TpDGCN`>W_J7QY|5^{g`8#KS&ILshR*(h!9~0*Hlp(T7=uVY!g1k!N@yf@{yzg*zpT^oxFz zWUK~q0fUiWh`oHNc;k+H!x8yH}$1?j=Az@AIf$y|PkJ{c!+t?amsKXDLjE@66{E>y&}-&`CIt+g8eGA7tV#rd zvhv#oxx4mpo{$PIYA}CkEZ-r4TQvHFmvr!Q^YvE;YJl(NrL8jIU4+PxGSMB;>8|n@ zqmWImJmDVp%y12|-5}CPbZC)q%#3gdB!Xzn712f&B4k29t1w=yFgq1)ykhhtWqoz@W^t13wmpx6Qb@$-;5H6&UAb61?!JA;`!I^xXV~fgYO(C(6z%^&U@?WjHvUDO>H6#eOzJS+P0lpwe`(us(i)zj#E=@Um1hOnN{$+)5Aq4GI zX&8#lS9CR3#b`Au&<;F1tubVrtnw)jjq1l69&6PW;X-sl&=2p}Q>J> z-ecIkXUoXy|=Lsg(SnnYqUS){J^@i}aCX0T0Q{(0@Mr1^BvJ&g0wU*U_rY zuHbsxH@~ZJy)VgL>Am($nLt$ISo0m(@cH#F2i?%nu;%;bWy~+lU&4=CpKYjh>>Y(7b3+Rl{~F;d)Cv*)_>SktNk-_x;?Vlb^3m&mrv;WU2FZ z_5CL6%dfHdrTLrPqiX-Vv9`cfMni_c)wSxib{@mk7oWD4;C?1)xNb6@^>!<`dLeK{ zWkDnnXIzm5lap|oGZJp`hEDUuMH+)B0Vv}-aFMqWa_T2I{8babqs&Y~Dm4r_2}!$& z11s0F0M5IGUB|JknDP0x)3h$VRl9|(yVHu@ff^>_j_0kp(o(!sa5Z4hnxwyIqYw9x z?)N^qhk%+ba7^ELgPXTc5gF45dB#sxR=;S`29?I##!O9ftjEC%E;-+gHhM)ihoW1! z@b@mGe)}P#?9&nOaNy$a{DiGw)1~XUc6EE>)8-JU+u5T3!p0|H=MZr!W^~PFN4(?o z4SdDT7N0?(0y$HD8aW~uUb>W}{Guv$POE9p^Ku6Gsh0}X?1NK^Mw;fYw~%-@wj+A~ z+uN5rrHKd2e(#C5%^fEc?u%tg?oj9+vkiya>)s~TJ@UZubJ2qXv>#_ZWZWB|^%a=< zv-K|2hH;En@wlW^A6Z2!i0DHgQT#-IGzQdMkFu0g&xJXRoEP9}six(coL*mU5?nl6 zatjem1XGG-vTK1WKK?x9hJUBZqqln&rh450A1S8-1$7Avzu%onu0X=CNJ6E=?CU+T zZPQ2bnt86kogE1;^$9j=qnnpffyAz6@@%(aTH+Or{3|@Hq%_6^WMfY-rJShz9*tLt z+&dNTd~7$^633;(nIn;2p4ya*&F71tivtAM<1R3GscZL&T`&png)3=zbKZxSD9LGy z8nU_)Z3IEztJQksqo=FsedzK@r7kecLOSdq<2H;z0|Rf2v`K4-!=1Yis1oMSA0mGo z$bQX~Innif03<@avK0383rmV&^nHl(`usW^CRHZaqJ)q; zjn#+ru7|A&LU{s*xi-208%0@M?`9voWzQG#8zLK-kqNP-0p#WB<5l(-f^L>C#0=wN zPWT0PSAYS+NPe>gKgVH@*a*8_p`;;RJP*^gfT1~)uH)U9e9BkjzCw}J>BB}?D^Jsa z&MPt{r z$9k4hEW-6jAB>CLz!XdWqUYW9JQVrcCz+WYh~%#$yT*__P2I{rceK9)t+*sP!gYj+ zvg^!Cz9`j`13g2I7F*3EZv;zG=q+nEzSG)0QzONSLU8*m1r4YgZmX?*lRibD?kDt< z!OEPiKtj&>n1it1=6O8sL9kL|_|mT3X^_)(e>>zz{08Lfc}08c^nG{#SI-km1Kwn+>E#(2^`t#|_v(|)XrO^=>w|o`(EJ|hHwt85q zgqF}+5C>KzJ}*tA23EoQ({V$VGUG=q1pAI*Q%dvn()>7q|QjSs}&N)3{UAs(sxdA z$Z`l0cb>|Y>6~l~@A5QSPjoav#_=`d@EfJziaA(fM49%3pk&>CRN6M*F1%E2Ac; zM;~h+$16VIRff?>p0DCr3xOz5$W=pnPUNxJa}+s#bQH1t0D3+|6>CY$V19QxVe~f{rMt6AP8lK1+~(P*Ajj2?~j~Xpo%7*UCfsj-^l4nNuiP zO50UmAF2_#EG8FTEkBfUhE`1=GIkF?H3NAJz^nS$0P`86&mIc}5X37kk#sj*4jOY} zR)B1?eW7gHMHMJ6P%E20jW1!_eNOC9!F+M?)a+J9|7CVPQMnY-YWkGxDqvqha%xLY z9(*B)PNkefSH2KZEC3wp;LV5w2kl5 z$iN%ao#O9`B{wro;LQNsH*9)sPK1|7e5l-L>p-F+S&Y>f{bo=k&T6L&n!o$wVjQX} zeaH{Ant%vfoN96de|!2b@?{f0 z+;+Hx*sk)z?QWQ~Jh?9P?9YoEbd;>kp(1kTdU$OlyaMG`aufgR5EkFIY@z=>?+xyJ zx!+U;UB1eb(=;quuX{{Ml+=nsXQ+Lo-y>f2$L0vX$DTpiW*t33kVkqvj0dF}XcAxu zK7o6e@ceY=dLU~0bI=-VBG9Ps>G)%YAf?Kj^u39zWl#HxWWXZZXT{sjir4!+#PT2U zYMk3qo^JG!HiY2tusO-qc1J(X1Hxoaw_tI*Bid^T&$c_)i$)XQ*2<*U>85*sTTNA}A6y2b`URMsaOv-wtm3f36}v)B&5N0<{^JA<(RZE$G#%o%I7U30gtpfI9I&gVs^}C+ zDmN6jkX3!6+Jgd=A0{u-hLQXSsGe+V&W0DXw}3(0cQxd%{`OTn1?~>S87S%x6USB( zqLIsea?`*!IQyz-ed6FF%Tq2>Pt{WaxG zSOHA%5R~Lpq?~UIcs}}hW(V^>lJaYoQjq*rE6wOvH8R-%g7Rr>=?&3fl~?j;L4)aJ z!ZRf@a*~|Ia0#1h6WP;l(B>1ktvgJXcBU0z3yZWtowd3tBlwz7V91(K)YHvmU{lRD zU97N<&a;z|{m=RK)tYhW z_uZPkX!j3vGH3@P-kZ6gz-Tj|w{FZ+As?y4p_gyY(}KV_dgj(VBM2a4L~qZt_T|K= zM;EodmqT$c8-#DXvdQ@zUZc26usW~ygyTO}E?oy~Ngx|2V4N2>hHPIhmC!Fw)Hy0v zM*xk4iQQX~!#h`mPm2_xDOXexS5ej*;MJ%e*{Wt5&U0x~<#waQp{a#ab9-bpRjQ(# zW>ZJxUPdM7X{?b|q*Sd|7*2C#(+KLaKpfkdcVI!dwrO^Y39MV`I#FbDMtHa#KRP9g z8#VXv##WqBEoI1iCHV1M-wX^=?pfSnl>UdE7a1Ggq7IR*Q=7#RIn;uRPTEWr(oJ}YSsh(0LM z3W(k+x%ZD=DM|N_{#nB9A3asF=odX&;^i0JUxMow-C5G?8{J%@2dM1dy8-0))7=1)``m5-;r&Hd0Pnt+D}a3;*A>9H-|PaQ z-q&&gknP_)0|@rhodMYU+|B^h{Y57L!oHUi0BRrCDGuz-`N0Fr^9RD=$dQFFBpq8Y z8`>B9pK0H5Dip2{OuQSlx!QND&2MPWh5b9UJD+xswuxZ)DUD_n;N{-(; zeXcE*{5%`AU)nn%X9~=#4xIF>YQE5auh^STW`f2*C|_8CCmj%CdF3%RJn`7H99yW^ z^F%&(TPyDGoXo9etogjYVfnf;MU{73>`Y7i%e%dEt=h^p#aC1I*|@&bf8kdR(wuy6 z_tmV0xBoRD;B?EMDsbJ1U3+(B8z*eTQ4^eN<=Z+m88BOXbk+okB*APdAq32|&RZ8NjPLJ|M^E()NhRH-~(3#+<4|%6U=6+VLIw z8|->l)#%?;+y5xw{gzq*74F!1xLE&DZs+{#=aN6gXtY$!E&f{lV_{+C`nMIn--SR` zYaeqGcFsSmf|?|{EF^3stbY_AnN%Dd-ALFu{w!|)j+Jq+a0GSyDZTPn%L9g=-pU&4 z1cR5p=X4?YaHPuC4*6xqO=Zn{AxZsY)U?sj5C{;oXV{++)9ItgU}$0Ri$maHq7h)s z%<~e{o6Tis=XT^3l1;2i`;@%D9kFeEbutO+(s@7*Qz3P3PDF4P&e^An#l+}?&d6^1;8S58>W~o{U;y%-m#E+Q9t|*Lk{uN3 zL>3Sm;D!5P6D>PdYMNN?0-1h*#tRAZ0>cj@-jw9CG3sYi=G<=7XUq~4=m-a?Iz>S&L-`Q%CxdTKF}p@jooMr_mtp4yt4IYZyC#4rxK)7QVe9gn(8i2D3?{;B7VqmxT|yNJ@o6OhZl@e+vx{Q8>I zK4wFF95qfUZTNj*raHOaO@L|jNhaRrPzD-;NY%I#S1&kD&9?|iZopq{O=$vdNW67} z)bdV>7H=f`nxO8(s&yh_z<>v@yX+vR5uN^6@+GB~60GJhg-x!SFjpfvIS<0Z%o4cE z4K-5X7-!2GhK#gq&K|Jx z9~5#;7u>VM9|aHOSV!#1Wo*A@;gro3!RblLhMHpt*vpa>shzMswYH~MDt^|~+Dx@_ z;S({)37Km$uWaXp-%qeC_cZ07p!n6d!{Fj#i_fz!zD_FPd9a}GF?|GplTY zQG+ss>V4g;KeiG-8f5+}N~$RNjMw(S{#g!XafWac*>|{AMUArRdO60u4Q_InkFm6^*Jj?|%GDsG)!0to zZ|eN*t;ldg^clUY7je;Ox!rx#ZtZsT4OXvbr0ZYbjIM6RE^b~fpf?^XGf0?;4S|wU JLP-+gKLEVV$H@Qy literal 0 HcmV?d00001 diff --git a/fforte_data/exkursion_2024_11_15.csv b/fforte_data/exkursion_2024_11_15.csv new file mode 100644 index 0000000..4db1ef3 --- /dev/null +++ b/fforte_data/exkursion_2024_11_15.csv @@ -0,0 +1,55 @@ +Nr;FELDNAME;TYP (Feldlaenge);Bedeutung;;;;"Tabelle ""Exkursion""" +0;ID;int(9);Fortlaufende Nummer, Primaerschluessel;;;; +1;Datum;varchar(22);Datum des Ereignisses;;;; +2;Rudel;varchar(24);Rudel bzw. Territorium;;;; +3;Teilnehm;longtext;Teilnehmer;;;; +4;Jahr;varchar(4);Jahr;;;; +5;Mjahr;varchar(5);Monitoringjahr (Mai bis April);;;; +6;Monat;int(2);Monat;;;; +7;Saison;varchar(2);Saison;;;; +8;Dauer;varchar(22);Dauer;;;; +9;BLand;varchar(55);Bundesland;;;; +10;Lkr;varchar(55);Lankreis;;;; +11;BeiOrt;varchar(255);naechstgelegene Ortschaft;;;; +12;Wetter;varchar(55);Wetter;;;; +13;Temperat;varchar(22);Temperatur;;;; +14;RegenVor;varchar(22);Letzter Niederschlag;;;; +15;KmAuto;varchar(9);mit dem Auto zurueckgelegte Strecke;;;; +16;KmFuss;varchar(9);zu Fuss zurueckgelegte Strecke;;;; +17;KmRad;varchar(9);mit dem Rad zurueckgelegte Strecke;;;; +18;KmTotal;varchar(9);insgesamt zurueckgelegte Strecke;;;; +19;KmAuProz;varchar(6);mit dem Auto zurueckgelegte Strecke prozentual;;;; +20;KmFuProz;varchar(6);zu Fuss zurueckgelegte Strecke prozentual;;;; +21;KmRaProz;varchar(6);mit dem Rad zurueckgelegte Strecke prozentual;;;; +22;SpGut;varchar(9);Spurbedingung gut;;;; +23;SpMittel;varchar(9);Spurbedingung mittel;;;; +24;SpSchlcht;varchar(9);Spurbedingung schlecht;;;; +25;SpurFund;varchar(9);Spur gefunden?;;;; +26;SpurLang;varchar(22);Gesamtlaenge aller dokumentierten Spuren;;;; +27;SpurTiere;varchar(11);max. Anzahl zus. gefaehrteter Tiere;;;; +28;SpSicher;varchar(11);Spur sicher?;;;; +29;WelpenSp;varchar(22);Spur von Welpen gefunden?;;;; +30;WelpenAnz;varchar(11);max. Anzahl zus. gefaehrteter Welpen;;;; +31;WpSicher;varchar(11);Spur von Welpen sicher?;;;; +32;LosungGes;varchar(11);Anzahl Losungen;;;; +33;LosungAnz;varchar(11);Losungen eingesammelt;;;; +34;LosungGen;varchar(11);Genetikproben von Losungen;;;; +35;UrinAnz;varchar(11);Anzahl Urin-/Markierstellen;;;; +36;UrinGen;varchar(11);Genetikproben von Urin-/Markierstellen;;;; +37;OestrAnz;varchar(11);Anzahl Oestrusblut;;;; +38;OestrGen;varchar(11);Genetikproben von Oestrusblut;;;; +39;HaarAnz;varchar(11);Anzahl Haarproben;;;; +40;HaarGen;varchar(11);Genetikproben von Haarproben;;;; +41;LosungKm;varchar(9);Losung pro Kilometer;;;; +42;GenetiKm;varchar(9);Genetikproben pro Kilometer;;;; +43;Hinweise;varchar(255);Hinweise;;;; +44;Bemerk;longtext;Bemerkungen;;;; +45;IntKomm;longtext;Interner Kommentar;;;; +46;BimaNr;varchar(22);DIFO Nummer (BIMA);;;; +47;BimaName;varchar(155);DIFO Name (BIMA);;;; +48;BimaNutzer;varchar(155);DIFO Nutzer (BIMA);;;; +49;BimaAGV;varchar(155);Geschaefsliegenschaft/AGV;;;; +50;FallNum;Int(6);Fallnummer;;;; +51;MHund;varchar(55);Hund dabei?;;;; +52;MLeine;varchar(9);Mit Leine?;;;; +53;LogDat;varchar(22);Login und Datum;;;; diff --git a/fforte_data/exkursion_2024_11_15.csv~ b/fforte_data/exkursion_2024_11_15.csv~ new file mode 100644 index 0000000..6ab7261 --- /dev/null +++ b/fforte_data/exkursion_2024_11_15.csv~ @@ -0,0 +1,55 @@ +r;FELDNAME;TYP (Feldlänge);Bedeutung;;;;"Tabelle ""Exkursion""" +0;ID;int(9);Fortlaufende Nummer, Primärschlüssel;;;; +1;Datum;varchar(22);Datum des Ereignisses;;;; +2;Rudel;varchar(24);Rudel bzw. Territorium;;;; +3;Teilnehm;longtext;Teilnehmer;;;; +4;Jahr;varchar(4);Jahr;;;; +5;Mjahr;varchar(5);Monitoringjahr (Mai bis April);;;; +6;Monat;int(2);Monat;;;; +7;Saison;varchar(2);Saison;;;; +8;Dauer;varchar(22);Dauer;;;; +9;BLand;varchar(55);Bundesland;;;; +10;Lkr;varchar(55);Lankreis;;;; +11;BeiOrt;varchar(255);nächstgelegene Ortschaft;;;; +12;Wetter;varchar(55);Wetter;;;; +13;Temperat;varchar(22);Temperatur;;;; +14;RegenVor;varchar(22);Letzter Niederschlag;;;; +15;KmAuto;varchar(9);mit dem Auto zurückgelegte Strecke;;;; +16;KmFuss;varchar(9);zu Fuß zurückgelegte Strecke;;;; +17;KmRad;varchar(9);mit dem Rad zurückgelegte Strecke;;;; +18;KmTotal;varchar(9);insgesamt zurückgelegte Strecke;;;; +19;KmAuProz;varchar(6);mit dem Auto zurückgelegte Strecke prozentual;;;; +20;KmFuProz;varchar(6);zu Fuß zurückgelegte Strecke prozentual;;;; +21;KmRaProz;varchar(6);mit dem Rad zurückgelegte Strecke prozentual;;;; +22;SpGut;varchar(9);Spurbedingung gut;;;; +23;SpMittel;varchar(9);Spurbedingung mittel;;;; +24;SpSchlcht;varchar(9);Spurbedingung schlecht;;;; +25;SpurFund;varchar(9);Spur gefunden?;;;; +26;SpurLang;varchar(22);Gesamtlänge aller dokumentierten Spuren;;;; +27;SpurTiere;varchar(11);max. Anzahl zus. gefährteter Tiere;;;; +28;SpSicher;varchar(11);Spur sicher?;;;; +29;WelpenSp;varchar(22);Spur von Welpen gefunden?;;;; +30;WelpenAnz;varchar(11);max. Anzahl zus. gefährteter Welpen;;;; +31;WpSicher;varchar(11);Spur von Welpen sicher?;;;; +32;LosungGes;varchar(11);Anzahl Losungen;;;; +33;LosungAnz;varchar(11);Losungen eingesammelt;;;; +34;LosungGen;varchar(11);Genetikproben von Losungen;;;; +35;UrinAnz;varchar(11);Anzahl Urin-/Markierstellen;;;; +36;UrinGen;varchar(11);Genetikproben von Urin-/Markierstellen;;;; +37;OestrAnz;varchar(11);Anzahl Oestrusblut;;;; +38;OestrGen;varchar(11);Genetikproben von Oestrusblut;;;; +39;HaarAnz;varchar(11);Anzahl Haarproben;;;; +40;HaarGen;varchar(11);Genetikproben von Haarproben;;;; +41;LosungKm;varchar(9);Losung pro Kilometer;;;; +42;GenetiKm;varchar(9);Genetikproben pro Kilometer;;;; +43;Hinweise;varchar(255);Hinweise;;;; +44;Bemerk;longtext;Bemerkungen;;;; +45;IntKomm;longtext;Interner Kommentar;;;; +46;BimaNr;varchar(22);DIFO Nummer (BIMA);;;; +47;BimaName;varchar(155);DIFO Name (BIMA);;;; +48;BimaNutzer;varchar(155);DIFO Nutzer (BIMA);;;; +49;BimaAGV;varchar(155);Geschäfsliegenschaft/AGV;;;; +50;FallNum;Int(6);Fallnummer;;;; +51;MHund;varchar(55);Hund dabei?;;;; +52;MLeine;varchar(9);Mit Leine?;;;; +53;LogDat;varchar(22);Login und Datum;;;; diff --git a/lib/screens/Excursion/excursion_main.dart b/lib/screens/Excursion/excursion_main.dart index 953667c..f0a7f32 100644 --- a/lib/screens/Excursion/excursion_main.dart +++ b/lib/screens/Excursion/excursion_main.dart @@ -1,5 +1,6 @@ import 'package:animations/animations.dart'; import 'package:fforte/screens/sharedWidgets/datum.dart'; +import 'package:fforte/screens/sharedWidgets/var_text_field.dart'; import 'package:flutter/material.dart'; import 'package:flutter_gen/gen_l10n/app_localizations.dart'; @@ -9,8 +10,22 @@ class ExcursionMain extends StatefulWidget { @override State createState() => _ExcursionMainState(); } - class _ExcursionMainState extends State { + + // erste überlegung: map mit textcontrollern und map mit rest. maybe später schauen, dass alles in die eine map und mit instanceoff (in dart version) checken + + TextEditingController rudel = TextEditingController(); + + Map getTextFields() { + Map rmap = { + "Rudel": rudel, + }; + + return rmap; + } + + + @override Widget build(BuildContext context) { List getSteps() => [ @@ -22,7 +37,8 @@ class _ExcursionMainState extends State { onDateChanged: (date) { }), - const SizedBox(height: 10,) + const SizedBox(height: 10,), + VarTextField(textController: getTextFields()["Rudel"], localization: localization, dbName: dbName, required: required) ], )), const Step(title: Text("step2"), content: Text("data")) diff --git a/time.txt b/time.txt index b8df298..dc25110 100644 --- a/time.txt +++ b/time.txt @@ -60,3 +60,4 @@ 17 nov 1h (Besprechung) 20 nov 1h 30min 22 nov 2h +1 dez 1h