{"version":3,"sources":["webpack:///./node_modules/@handsontable/vue/es/vue-handsontable.js"],"names":["_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_createClass","protoProps","staticProps","prototype","_defineProperty","obj","value","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","push","apply","_objectSpread2","arguments","source","forEach","getOwnPropertyDescriptors","defineProperties","_inherits","subClass","superClass","create","constructor","_setPrototypeOf","_getPrototypeOf","o","setPrototypeOf","getPrototypeOf","__proto__","p","_assertThisInitialized","self","ReferenceError","_possibleConstructorReturn","call","unassignedPropSymbol","Symbol","bulkComponentContainer","preventInternalEditWatch","component","hotInstance","addHook","__internalEdit","propFactory","registeredHooks","hooks","getRegistered","propSchema","DefaultSettings","prop","settings","id","type","String","Math","random","toString","substring","wrapperRendererCacheSize","Number","filterPassedProps","filteredProps","columnSettingsProp","propName","hasOwnProperty","_propName","prepareSettings","assignedProps","hotSettingsInProps","additionalHotSettingsInProps","newSettings","_key","findVNodeByType","componentSlots","componentVNode","every","slot","index","data","attrs","getHotColumnComponents","children","child","$options","name","createVueComponent","vNode","parent","ownerDocument","$el","document","propsData","createElement","body","appendChild","componentContainer","componentOptions","Ctor","$mount","version","globalThis","window","global","createCommonjsModule","fn","module","exports","lru","g","f","e","commonjsGlobal","NEWER","OLDER","LRUMap","limit","entries","this","size","oldest","newest","undefined","_keymap","Map","assign","Entry","_markEntryAsUsed","entry","MAX_VALUE","clear","it","iterator","itv","next","done","set","Error","get","shift","has","lru_1","HotTable","watch","mergedHotSettings","updateSettings","rendererCache","$destroy","columnSettings","editorCache","computed","$props","methods","hotInit","globalRendererVNode","getGlobalRendererVNode","globalEditorVNode","getGlobalEditorVNode","columns","editor","getEditorClass","renderer","getRendererWrapper","Core","init","hotTableSlots","$slots","getColumnSettings","hotColumns","$children","usesRendererComponent","map","elem","autoColumnSize","autoRowSize","console","warn","containerComponent","$vm","TD","row","col","cellProperties","getAttribute","rendererArgs","isRenderer","concat","mountedComponent","lastUsedTD","cachedEntry","cachedComponent","cachedTD","$data","parentElement","firstChild","removeChild","componentName","options","isEditor","hotCustomEditorClass","mounted","beforeDestroy","destroy","normalizeComponent","template","style","script","scopeId","isFunctionalTemplate","moduleIdentifier","shadowMode","createInjector","createInjectorSSR","createInjectorShadow","hook","render","staticRenderFns","_compiled","functional","_scopeId","context","$vnode","ssrContext","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","shadowRoot","originalRender","h","existing","beforeCreate","normalizeComponent_1","__vue_script__","__vue_render__","_vm","_h","$createElement","_c","_self","_t","__vue_staticRenderFns__","__vue_inject_styles__","__vue_scope_id__","__vue_module_identifier__","__vue_is_functional_template__","HotColumn","createColumnSettings","hotColumnSlots","rendererVNode","editorVNode","$parent","__vue_script__$1","__vue_inject_styles__$1","__vue_scope_id__$1","__vue_module_identifier__$1","__vue_is_functional_template__$1","__decorate","decorators","desc","d","c","r","Reflect","decorate","reflectionIsSupported","defineMetadata","getOwnMetadataKeys","copyReflectionMetadata","to","from","forwardMetadata","getOwnPropertyNames","propertyKey","metaKeys","metaKey","metadata","getOwnMetadata","fakeArray","hasProto","Array","isPrimitive","collectDataFromConstructor","vm","Component","originalInit","_init","_this","charAt","plainData","$internalHooks","componentFactory","_componentTag","proto","indexOf","mixins","_a","__decorators__","superProto","Super","Extended","extend","forwardStaticMembers","shouldIgnore","callee","caller","Original","extendedDescriptor","superDescriptor","registerHooks","BaseEditorComponent","_Vue","_this2","originalValue","state","hot","customEditorClass","_Handsontable$editors","CustomEditor","_this3","hotCustomEditorInstance","editors","BaseEditor","_this$propName","_len","args","_Handsontable$editors2","_len2","_key2","_fireCallbacks","_Handsontable$editors3","_len3","_key3","beginEditing","_Handsontable$editors4","_len4","_key4","cancelChanges","_Handsontable$editors5","_len5","_key5","checkEditorSection","_Handsontable$editors6","_len6","_key6","close","_Handsontable$editors7","_len7","_key7","discardEditor","_Handsontable$editors8","_len8","_key8","enableFullEditMode","_Handsontable$editors9","_len9","_key9","_Handsontable$editors10","_len10","_key10","finishEditing","_Handsontable$editors11","_len11","_key11","focus","_Handsontable$editors12","_len12","_key12","getValue","_Handsontable$editors13","_len13","_key13","_Handsontable$editors14","_len14","_key14","isInFullEditMode","_Handsontable$editors15","_len15","_key15","isOpened","_Handsontable$editors16","_len16","_key16","isWaiting","_Handsontable$editors17","_len17","_key17","open","prepare","_Handsontable$editors18","_len18","_key18","saveValue","_Handsontable$editors19","_len19","_key19","setValue","_Handsontable$editors20","_len20","_key20","_Handsontable$editors21","_len21","_key21","removeHooksByKey","_Handsontable$editors22","_len22","_key22","clearHooks","_Handsontable$editors23","_len23","_key23","getEditedCell","_Handsontable$editors24","_len24","_key24","getEditedCellsZIndex","_Handsontable$editors25","_len25","_key25","getEditedCellsLayerClass","__vue_script__$2","__vue_inject_styles__$2","__vue_scope_id__$2","__vue_module_identifier__$2","__vue_is_functional_template__$2"],"mappings":"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","file":"js/components~datalevels~observations~providers~qualitycontrol~sensors~units.6e73b86b.js","sourcesContent":["import Handsontable from 'handsontable';\nimport Vue from 'vue';\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(source, true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(source).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) _setPrototypeOf(subClass, superClass);\n}\n\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return _assertThisInitialized(self);\n}\n\nvar unassignedPropSymbol = Symbol('unassigned');\nvar bulkComponentContainer = null;\n/**\r\n * Private method to ensure the table is not calling `updateSettings` after editing cells.\r\n * @private\r\n */\n\nfunction preventInternalEditWatch(component) {\n  component.hotInstance.addHook('beforeChange', function () {\n    component.__internalEdit = true;\n  });\n  component.hotInstance.addHook('beforeCreateRow', function () {\n    component.__internalEdit = true;\n  });\n  component.hotInstance.addHook('beforeCreateCol', function () {\n    component.__internalEdit = true;\n  });\n  component.hotInstance.addHook('beforeRemoveRow', function () {\n    component.__internalEdit = true;\n  });\n  component.hotInstance.addHook('beforeRemoveCol', function () {\n    component.__internalEdit = true;\n  });\n}\n/**\r\n * Generate an object containing all the available Handsontable properties and plugin hooks.\r\n *\r\n * @param {String} source Source for the factory (either 'HotTable' or 'HotColumn').\r\n * @returns {Object}\r\n */\n\nfunction propFactory(source) {\n  var registeredHooks = Handsontable.hooks.getRegistered();\n  var propSchema = new Handsontable.DefaultSettings();\n\n  for (var prop in propSchema) {\n    propSchema[prop] = {\n      \"default\": unassignedPropSymbol\n    };\n  }\n\n  for (var i = 0; i < registeredHooks.length; i++) {\n    propSchema[registeredHooks[i]] = {\n      \"default\": unassignedPropSymbol\n    };\n  }\n\n  propSchema.settings = {\n    \"default\": unassignedPropSymbol\n  };\n\n  if (source === 'HotTable') {\n    propSchema.id = {\n      type: String,\n      \"default\": 'hot-' + Math.random().toString(36).substring(5)\n    };\n    propSchema.wrapperRendererCacheSize = {\n      type: Number,\n      \"default\": 3000\n    };\n  }\n\n  return propSchema;\n}\n/**\r\n * Filter out all of the unassigned props, and return only the one passed to the component.\r\n *\r\n * @param {Object} props Object containing all the possible props.\r\n * @returns {Object} Object containing only used props.\r\n */\n\nfunction filterPassedProps(props) {\n  var filteredProps = {};\n  var columnSettingsProp = props['settings'];\n\n  if (columnSettingsProp !== unassignedPropSymbol) {\n    for (var propName in columnSettingsProp) {\n      if (columnSettingsProp.hasOwnProperty(propName) && columnSettingsProp[propName] !== unassignedPropSymbol) {\n        filteredProps[propName] = columnSettingsProp[propName];\n      }\n    }\n  }\n\n  for (var _propName in props) {\n    if (props.hasOwnProperty(_propName) && _propName !== 'settings' && props[_propName] !== unassignedPropSymbol) {\n      filteredProps[_propName] = props[_propName];\n    }\n  }\n\n  return filteredProps;\n}\n/**\r\n * Prepare the settings object to be used as the settings for Handsontable, based on the props provided to the component.\r\n *\r\n * @param {Object} props The props passed to the component.\r\n * @returns {Object} An object containing the properties, ready to be used within Handsontable.\r\n */\n\nfunction prepareSettings(props) {\n  var assignedProps = filterPassedProps(props);\n  var hotSettingsInProps = props.settings ? props.settings : assignedProps;\n  var additionalHotSettingsInProps = props.settings ? assignedProps : null;\n  var newSettings = {};\n\n  for (var key in hotSettingsInProps) {\n    if (hotSettingsInProps.hasOwnProperty(key) && hotSettingsInProps[key] !== void 0) {\n      newSettings[key] = hotSettingsInProps[key];\n    }\n  }\n\n  for (var _key in additionalHotSettingsInProps) {\n    if (_key !== 'id' && _key !== 'settings' && _key !== 'wrapperRendererCacheSize' && additionalHotSettingsInProps.hasOwnProperty(_key) && additionalHotSettingsInProps[_key] !== void 0) {\n      newSettings[_key] = additionalHotSettingsInProps[_key];\n    }\n  }\n\n  return newSettings;\n}\n/**\r\n * Get the VNode element with the provided type attribute from the component slots.\r\n *\r\n * @param {Array} componentSlots Array of slots from a component.\r\n * @param {String} type Type of the child component. Either `hot-renderer` or `hot-editor`.\r\n * @returns {Object|null} The VNode of the child component (or `null` when nothing's found).\r\n */\n\nfunction findVNodeByType(componentSlots, type) {\n  var componentVNode = null;\n  componentSlots.every(function (slot, index) {\n    if (slot.data && slot.data.attrs && slot.data.attrs[type] !== void 0) {\n      componentVNode = slot;\n      return false;\n    }\n\n    return true;\n  });\n  return componentVNode;\n}\n/**\r\n * Get all `hot-column` component instances from the provided children array.\r\n *\r\n * @param {Array} children Array of children from a component.\r\n * @returns {Array} Array of `hot-column` instances.\r\n */\n\nfunction getHotColumnComponents(children) {\n  return children.filter(function (child) {\n    return child.$options.name === 'HotColumn';\n  });\n}\n/**\r\n * Create an instance of the Vue Component based on the provided VNode.\r\n *\r\n * @param {Object} vNode VNode element to be turned into a component instance.\r\n * @param {Object} parent Instance of the component to be marked as a parent of the newly created instance.\r\n * @param {Object} props Props to be passed to the new instance.\r\n * @param {Object} data Data to be passed to the new instance.\r\n */\n\nfunction createVueComponent(vNode, parent, props, data) {\n  var ownerDocument = parent.$el ? parent.$el.ownerDocument : document;\n  var settings = {\n    propsData: props,\n    parent: parent,\n    data: data\n  };\n\n  if (!bulkComponentContainer) {\n    bulkComponentContainer = ownerDocument.createElement('DIV');\n    bulkComponentContainer.id = 'vueHotComponents';\n    ownerDocument.body.appendChild(bulkComponentContainer);\n  }\n\n  var componentContainer = ownerDocument.createElement('DIV');\n  bulkComponentContainer.appendChild(componentContainer);\n  return new vNode.componentOptions.Ctor(settings).$mount(componentContainer);\n}\n\nvar version=\"4.1.1\";\n\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\nfunction createCommonjsModule(fn, module) {\n\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n}\n\nvar lru = createCommonjsModule(function (module, exports) {\n  /**\n   * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most\n   * recently used items while discarding least recently used items when its limit\n   * is reached.\n   *\n   * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>\n   * See README.md for details.\n   *\n   * Illustration of the design:\n   *\n   *       entry             entry             entry             entry\n   *       ______            ______            ______            ______\n   *      | head |.newer => |      |.newer => |      |.newer => | tail |\n   *      |  A   |          |  B   |          |  C   |          |  D   |\n   *      |______| <= older.|______| <= older.|______| <= older.|______|\n   *\n   *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added\n   */\n  (function (g, f) {\n    var e =  exports ;\n    f(e);\n  })(commonjsGlobal, function (exports) {\n    var NEWER = Symbol('newer');\n    var OLDER = Symbol('older');\n\n    function LRUMap(limit, entries) {\n      if (typeof limit !== 'number') {\n        // called as (entries)\n        entries = limit;\n        limit = 0;\n      }\n\n      this.size = 0;\n      this.limit = limit;\n      this.oldest = this.newest = undefined;\n      this._keymap = new Map();\n\n      if (entries) {\n        this.assign(entries);\n\n        if (limit < 1) {\n          this.limit = this.size;\n        }\n      }\n    }\n\n    exports.LRUMap = LRUMap;\n\n    function Entry(key, value) {\n      this.key = key;\n      this.value = value;\n      this[NEWER] = undefined;\n      this[OLDER] = undefined;\n    }\n\n    LRUMap.prototype._markEntryAsUsed = function (entry) {\n      if (entry === this.newest) {\n        // Already the most recenlty used entry, so no need to update the list\n        return;\n      } // HEAD--------------TAIL\n      //   <.older   .newer>\n      //  <--- add direction --\n      //   A  B  C  <D>  E\n\n\n      if (entry[NEWER]) {\n        if (entry === this.oldest) {\n          this.oldest = entry[NEWER];\n        }\n\n        entry[NEWER][OLDER] = entry[OLDER]; // C <-- E.\n      }\n\n      if (entry[OLDER]) {\n        entry[OLDER][NEWER] = entry[NEWER]; // C. --> E\n      }\n\n      entry[NEWER] = undefined; // D --x\n\n      entry[OLDER] = this.newest; // D. --> E\n\n      if (this.newest) {\n        this.newest[NEWER] = entry; // E. <-- D\n      }\n\n      this.newest = entry;\n    };\n\n    LRUMap.prototype.assign = function (entries) {\n      var entry,\n          limit = this.limit || Number.MAX_VALUE;\n\n      this._keymap.clear();\n\n      var it = entries[Symbol.iterator]();\n\n      for (var itv = it.next(); !itv.done; itv = it.next()) {\n        var e = new Entry(itv.value[0], itv.value[1]);\n\n        this._keymap.set(e.key, e);\n\n        if (!entry) {\n          this.oldest = e;\n        } else {\n          entry[NEWER] = e;\n          e[OLDER] = entry;\n        }\n\n        entry = e;\n\n        if (limit-- == 0) {\n          throw new Error('overflow');\n        }\n      }\n\n      this.newest = entry;\n      this.size = this._keymap.size;\n    };\n\n    LRUMap.prototype.get = function (key) {\n      // First, find our cache entry\n      var entry = this._keymap.get(key);\n\n      if (!entry) return; // Not cached. Sorry.\n      // As <key> was found in the cache, register it as being requested recently\n\n      this._markEntryAsUsed(entry);\n\n      return entry.value;\n    };\n\n    LRUMap.prototype.set = function (key, value) {\n      var entry = this._keymap.get(key);\n\n      if (entry) {\n        // update existing\n        entry.value = value;\n\n        this._markEntryAsUsed(entry);\n\n        return this;\n      } // new entry\n\n\n      this._keymap.set(key, entry = new Entry(key, value));\n\n      if (this.newest) {\n        // link previous tail to the new tail (entry)\n        this.newest[NEWER] = entry;\n        entry[OLDER] = this.newest;\n      } else {\n        // we're first in -- yay\n        this.oldest = entry;\n      } // add new entry to the end of the linked list -- it's now the freshest entry.\n\n\n      this.newest = entry;\n      ++this.size;\n\n      if (this.size > this.limit) {\n        // we hit the limit -- remove the head\n        this.shift();\n      }\n\n      return this;\n    };\n\n    LRUMap.prototype.shift = function () {\n      // todo: handle special case when limit == 1\n      var entry = this.oldest;\n\n      if (entry) {\n        if (this.oldest[NEWER]) {\n          // advance the list\n          this.oldest = this.oldest[NEWER];\n          this.oldest[OLDER] = undefined;\n        } else {\n          // the cache is exhausted\n          this.oldest = undefined;\n          this.newest = undefined;\n        } // Remove last strong reference to <entry> and remove links from the purged\n        // entry being returned:\n\n\n        entry[NEWER] = entry[OLDER] = undefined;\n\n        this._keymap[\"delete\"](entry.key);\n\n        --this.size;\n        return [entry.key, entry.value];\n      }\n    }; // ----------------------------------------------------------------------------\n    // Following code is optional and can be removed without breaking the core\n    // functionality.\n\n\n    LRUMap.prototype.has = function (key) {\n      return this._keymap.has(key);\n    };\n  });\n});\nvar lru_1 = lru.LRUMap;\n\nvar HotTable = {\n  name: 'HotTable',\n  props: propFactory('HotTable'),\n  watch: {\n    mergedHotSettings: function mergedHotSettings(value) {\n      this.hotInstance.updateSettings(value);\n    }\n  },\n  data: function data() {\n    var rendererCache = new lru_1(this.wrapperRendererCacheSize); // Make the LRU cache destroy each removed component\n\n    rendererCache.shift = function () {\n      var entry = lru_1.prototype.shift.call(this);\n      entry[1].component.$destroy();\n      return entry;\n    };\n\n    return {\n      __internalEdit: false,\n      hotInstance: null,\n      columnSettings: null,\n      rendererCache: rendererCache,\n      editorCache: new Map()\n    };\n  },\n  computed: {\n    mergedHotSettings: function mergedHotSettings() {\n      return prepareSettings(this.$props);\n    }\n  },\n  methods: {\n    /**\r\n     * Initialize Handsontable.\r\n     */\n    hotInit: function hotInit() {\n      var globalRendererVNode = this.getGlobalRendererVNode();\n      var globalEditorVNode = this.getGlobalEditorVNode();\n      var newSettings = prepareSettings(this.$props);\n      newSettings.columns = this.columnSettings ? this.columnSettings : newSettings.columns;\n\n      if (globalEditorVNode) {\n        newSettings.editor = this.getEditorClass(globalEditorVNode, this);\n        globalEditorVNode.child.$destroy();\n      }\n\n      if (globalRendererVNode) {\n        newSettings.renderer = this.getRendererWrapper(globalRendererVNode, this);\n        globalRendererVNode.child.$destroy();\n      }\n\n      this.hotInstance = new Handsontable.Core(this.$el, newSettings);\n      this.hotInstance.init();\n      preventInternalEditWatch(this);\n    },\n    getGlobalRendererVNode: function getGlobalRendererVNode() {\n      var hotTableSlots = this.$slots[\"default\"] || [];\n      return findVNodeByType(hotTableSlots, 'hot-renderer');\n    },\n    getGlobalEditorVNode: function getGlobalEditorVNode() {\n      var hotTableSlots = this.$slots[\"default\"] || [];\n      return findVNodeByType(hotTableSlots, 'hot-editor');\n    },\n\n    /**\r\n     * Get settings for the columns provided in the `hot-column` components.\r\n     */\n    getColumnSettings: function getColumnSettings() {\n      var hotColumns = getHotColumnComponents(this.$children);\n      var usesRendererComponent = false;\n      var columnSettings = hotColumns.map(function (elem) {\n        if (elem.usesRendererComponent) {\n          usesRendererComponent = true;\n        }\n\n        return _objectSpread2({}, elem.columnSettings);\n      });\n\n      if (usesRendererComponent && this.settings && (this.settings.autoColumnSize !== false || this.settings.autoRowSize) && (this.autoColumnSize !== false || this.autoRowSize)) {\n        console.warn('Your `hot-table` configuration includes both `hot-column` and `autoRowSize`/`autoColumnSize`, which are not compatible with each other ' + 'in this version of `@handsontable/vue`. Disable `autoRowSize` and `autoColumnSize` to prevent row and column misalignment.');\n      }\n\n      return columnSettings.length ? columnSettings : void 0;\n    },\n\n    /**\r\n     * Create the wrapper function for the provided renderer child component.\r\n     *\r\n     * @param {Object} vNode VNode of the renderer child component.\r\n     * @param {Boolean} containerComponent Instance of the component, which will be treated as a parent for the newly created renderer component.\r\n     * @returns {Function} The wrapper function used as the renderer.\r\n     */\n    getRendererWrapper: function getRendererWrapper(vNode, containerComponent) {\n      var $vm = this;\n      return function (instance, TD, row, col, prop, value, cellProperties) {\n        // Prevent caching and rendering of the GhostTable table cells\n        if (TD && !TD.getAttribute('ghost-table')) {\n          var rendererCache = $vm.rendererCache;\n          var rendererArgs = {\n            hotInstance: instance,\n            TD: TD,\n            row: row,\n            col: col,\n            prop: prop,\n            value: value,\n            cellProperties: cellProperties,\n            isRenderer: true\n          };\n\n          if (rendererCache && !rendererCache.has(\"\".concat(row, \"-\").concat(col))) {\n            var mountedComponent = createVueComponent(vNode, containerComponent, {}, rendererArgs);\n            rendererCache.set(\"\".concat(row, \"-\").concat(col), {\n              component: mountedComponent,\n              lastUsedTD: null\n            });\n          }\n\n          var cachedEntry = rendererCache.get(\"\".concat(row, \"-\").concat(col));\n          var cachedComponent = cachedEntry.component;\n          var cachedTD = cachedEntry.lastUsedTD;\n          Object.assign(cachedComponent.$data, rendererArgs);\n\n          if (!cachedComponent.$el.parentElement || cachedTD !== TD) {\n            // Clear the previous contents of a TD\n            while (TD.firstChild) {\n              TD.removeChild(TD.firstChild);\n            }\n\n            TD.appendChild(cachedComponent.$el);\n            cachedEntry.lastUsedTD = TD;\n          }\n        }\n\n        return TD;\n      };\n    },\n\n    /**\r\n     * Create a fresh class to be used as an editor, based on the editor component provided.\r\n     *\r\n     * @param {Object} vNode VNode for the editor child component.\r\n     * @param {Boolean} containerComponent Instance of the component, which will be treated as a parent for the newly created editor component.\r\n     * @returns {Class} The class used as an editor in Handsontable.\r\n     */\n    getEditorClass: function getEditorClass(vNode, containerComponent) {\n      var componentName = vNode.componentOptions.Ctor.options.name;\n      var editorCache = this.editorCache;\n      var mountedComponent = null;\n\n      if (!editorCache.has(componentName)) {\n        mountedComponent = createVueComponent(vNode, containerComponent, {}, {\n          isEditor: true\n        });\n        editorCache.set(componentName, mountedComponent);\n      } else {\n        mountedComponent = editorCache.get(componentName);\n      }\n\n      return mountedComponent.$data.hotCustomEditorClass;\n    }\n  },\n  mounted: function mounted() {\n    this.columnSettings = this.getColumnSettings();\n    return this.hotInit();\n  },\n  beforeDestroy: function beforeDestroy() {\n    this.hotInstance.destroy();\n  },\n  version: version\n};\n\nfunction normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier\n/* server only */\n, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {\n  if (typeof shadowMode !== 'boolean') {\n    createInjectorSSR = createInjector;\n    createInjector = shadowMode;\n    shadowMode = false;\n  } // Vue.extend constructor export interop.\n\n\n  var options = typeof script === 'function' ? script.options : script; // render functions\n\n  if (template && template.render) {\n    options.render = template.render;\n    options.staticRenderFns = template.staticRenderFns;\n    options._compiled = true; // functional template\n\n    if (isFunctionalTemplate) {\n      options.functional = true;\n    }\n  } // scopedId\n\n\n  if (scopeId) {\n    options._scopeId = scopeId;\n  }\n\n  var hook;\n\n  if (moduleIdentifier) {\n    // server build\n    hook = function hook(context) {\n      // 2.3 injection\n      context = context || // cached call\n      this.$vnode && this.$vnode.ssrContext || // stateful\n      this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional\n      // 2.2 with runInNewContext: true\n\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__;\n      } // inject component styles\n\n\n      if (style) {\n        style.call(this, createInjectorSSR(context));\n      } // register component module identifier for async chunk inference\n\n\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier);\n      }\n    }; // used by ssr in case component is cached and beforeCreate\n    // never gets called\n\n\n    options._ssrRegister = hook;\n  } else if (style) {\n    hook = shadowMode ? function () {\n      style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));\n    } : function (context) {\n      style.call(this, createInjector(context));\n    };\n  }\n\n  if (hook) {\n    if (options.functional) {\n      // register for functional component in vue file\n      var originalRender = options.render;\n\n      options.render = function renderWithStyleInjection(h, context) {\n        hook.call(context);\n        return originalRender(h, context);\n      };\n    } else {\n      // inject component registration as beforeCreate hook\n      var existing = options.beforeCreate;\n      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];\n    }\n  }\n\n  return script;\n}\n\nvar normalizeComponent_1 = normalizeComponent;\n\n/* script */\nvar __vue_script__ = HotTable;\n/* template */\n\nvar __vue_render__ = function __vue_render__() {\n  var _vm = this;\n\n  var _h = _vm.$createElement;\n\n  var _c = _vm._self._c || _h;\n\n  return _c('div', {\n    attrs: {\n      \"id\": _vm.id\n    }\n  }, [_vm._t(\"default\")], 2);\n};\n\nvar __vue_staticRenderFns__ = [];\n/* style */\n\nvar __vue_inject_styles__ = undefined;\n/* scoped */\n\nvar __vue_scope_id__ = undefined;\n/* module identifier */\n\nvar __vue_module_identifier__ = undefined;\n/* functional template */\n\nvar __vue_is_functional_template__ = false;\n/* style inject */\n\n/* style inject SSR */\n\nvar HotTable$1 = normalizeComponent_1({\n  render: __vue_render__,\n  staticRenderFns: __vue_staticRenderFns__\n}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, undefined, undefined);\n\nvar HotColumn = {\n  name: 'HotColumn',\n  props: propFactory('HotColumn'),\n  methods: {\n    /**\r\n     * Create the column settings based on the data provided to the `hot-column` component and it's child components.\r\n     */\n    createColumnSettings: function createColumnSettings() {\n      var hotColumnSlots = this.$slots[\"default\"] || [];\n      var rendererVNode = findVNodeByType(hotColumnSlots, 'hot-renderer');\n      var editorVNode = findVNodeByType(hotColumnSlots, 'hot-editor');\n      var assignedProps = filterPassedProps(this.$props);\n\n      if (rendererVNode && this.usesRendererComponent === void 0) {\n        this.usesRendererComponent = true;\n      }\n\n      this.columnSettings = _objectSpread2({}, assignedProps);\n\n      if (rendererVNode !== null) {\n        this.columnSettings.renderer = this.$parent.getRendererWrapper(rendererVNode, this);\n      } else if (assignedProps.renderer) {\n        this.columnSettings.renderer = assignedProps.renderer;\n      }\n\n      if (editorVNode !== null) {\n        this.columnSettings.editor = this.$parent.getEditorClass(editorVNode, this);\n      } else if (assignedProps.editor) {\n        this.columnSettings.editor = assignedProps.editor;\n      }\n    }\n  },\n  mounted: function mounted() {\n    this.createColumnSettings();\n  },\n  render: function render() {\n    return null;\n  }\n};\n\n/* script */\nvar __vue_script__$1 = HotColumn;\n/* template */\n\n/* style */\n\nvar __vue_inject_styles__$1 = undefined;\n/* scoped */\n\nvar __vue_scope_id__$1 = undefined;\n/* module identifier */\n\nvar __vue_module_identifier__$1 = undefined;\n/* functional template */\n\nvar __vue_is_functional_template__$1 = undefined;\n/* style inject */\n\n/* style inject SSR */\n\nnormalizeComponent_1({}, __vue_inject_styles__$1, __vue_script__$1, __vue_scope_id__$1, __vue_is_functional_template__$1, __vue_module_identifier__$1, undefined, undefined);\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n\r\nfunction __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\n\n/**\n  * vue-class-component v7.1.0\n  * (c) 2015-present Evan You\n  * @license MIT\n  */\n\n// The rational behind the verbose Reflect-feature check below is the fact that there are polyfills\n// which add an implementation for Reflect.defineMetadata but not for Reflect.getOwnMetadataKeys.\n// Without this check consumers will encounter hard to track down runtime errors.\nvar reflectionIsSupported = typeof Reflect !== 'undefined' && Reflect.defineMetadata && Reflect.getOwnMetadataKeys;\nfunction copyReflectionMetadata(to, from) {\n    forwardMetadata(to, from);\n    Object.getOwnPropertyNames(from.prototype).forEach(function (key) {\n        forwardMetadata(to.prototype, from.prototype, key);\n    });\n    Object.getOwnPropertyNames(from).forEach(function (key) {\n        forwardMetadata(to, from, key);\n    });\n}\nfunction forwardMetadata(to, from, propertyKey) {\n    var metaKeys = propertyKey\n        ? Reflect.getOwnMetadataKeys(from, propertyKey)\n        : Reflect.getOwnMetadataKeys(from);\n    metaKeys.forEach(function (metaKey) {\n        var metadata = propertyKey\n            ? Reflect.getOwnMetadata(metaKey, from, propertyKey)\n            : Reflect.getOwnMetadata(metaKey, from);\n        if (propertyKey) {\n            Reflect.defineMetadata(metaKey, metadata, to, propertyKey);\n        }\n        else {\n            Reflect.defineMetadata(metaKey, metadata, to);\n        }\n    });\n}\n\nvar fakeArray = { __proto__: [] };\nvar hasProto = fakeArray instanceof Array;\nfunction isPrimitive(value) {\n    var type = typeof value;\n    return value == null || (type !== 'object' && type !== 'function');\n}\n\nfunction collectDataFromConstructor(vm, Component) {\n    // override _init to prevent to init as Vue instance\n    var originalInit = Component.prototype._init;\n    Component.prototype._init = function () {\n        var _this = this;\n        // proxy to actual vm\n        var keys = Object.getOwnPropertyNames(vm);\n        // 2.2.0 compat (props are no longer exposed as self properties)\n        if (vm.$options.props) {\n            for (var key in vm.$options.props) {\n                if (!vm.hasOwnProperty(key)) {\n                    keys.push(key);\n                }\n            }\n        }\n        keys.forEach(function (key) {\n            if (key.charAt(0) !== '_') {\n                Object.defineProperty(_this, key, {\n                    get: function () { return vm[key]; },\n                    set: function (value) { vm[key] = value; },\n                    configurable: true\n                });\n            }\n        });\n    };\n    // should be acquired class property values\n    var data = new Component();\n    // restore original _init to avoid memory leak (#209)\n    Component.prototype._init = originalInit;\n    // create plain data object\n    var plainData = {};\n    Object.keys(data).forEach(function (key) {\n        if (data[key] !== undefined) {\n            plainData[key] = data[key];\n        }\n    });\n    return plainData;\n}\n\nvar $internalHooks = [\n    'data',\n    'beforeCreate',\n    'created',\n    'beforeMount',\n    'mounted',\n    'beforeDestroy',\n    'destroyed',\n    'beforeUpdate',\n    'updated',\n    'activated',\n    'deactivated',\n    'render',\n    'errorCaptured',\n    'serverPrefetch' // 2.6\n];\nfunction componentFactory(Component, options) {\n    if (options === void 0) { options = {}; }\n    options.name = options.name || Component._componentTag || Component.name;\n    // prototype props.\n    var proto = Component.prototype;\n    Object.getOwnPropertyNames(proto).forEach(function (key) {\n        if (key === 'constructor') {\n            return;\n        }\n        // hooks\n        if ($internalHooks.indexOf(key) > -1) {\n            options[key] = proto[key];\n            return;\n        }\n        var descriptor = Object.getOwnPropertyDescriptor(proto, key);\n        if (descriptor.value !== void 0) {\n            // methods\n            if (typeof descriptor.value === 'function') {\n                (options.methods || (options.methods = {}))[key] = descriptor.value;\n            }\n            else {\n                // typescript decorated data\n                (options.mixins || (options.mixins = [])).push({\n                    data: function () {\n                        var _a;\n                        return _a = {}, _a[key] = descriptor.value, _a;\n                    }\n                });\n            }\n        }\n        else if (descriptor.get || descriptor.set) {\n            // computed properties\n            (options.computed || (options.computed = {}))[key] = {\n                get: descriptor.get,\n                set: descriptor.set\n            };\n        }\n    });\n    (options.mixins || (options.mixins = [])).push({\n        data: function () {\n            return collectDataFromConstructor(this, Component);\n        }\n    });\n    // decorate options\n    var decorators = Component.__decorators__;\n    if (decorators) {\n        decorators.forEach(function (fn) { return fn(options); });\n        delete Component.__decorators__;\n    }\n    // find super\n    var superProto = Object.getPrototypeOf(Component.prototype);\n    var Super = superProto instanceof Vue\n        ? superProto.constructor\n        : Vue;\n    var Extended = Super.extend(options);\n    forwardStaticMembers(Extended, Component, Super);\n    if (reflectionIsSupported) {\n        copyReflectionMetadata(Extended, Component);\n    }\n    return Extended;\n}\nvar shouldIgnore = {\n    prototype: true,\n    arguments: true,\n    callee: true,\n    caller: true\n};\nfunction forwardStaticMembers(Extended, Original, Super) {\n    // We have to use getOwnPropertyNames since Babel registers methods as non-enumerable\n    Object.getOwnPropertyNames(Original).forEach(function (key) {\n        // Skip the properties that should not be overwritten\n        if (shouldIgnore[key]) {\n            return;\n        }\n        // Some browsers does not allow reconfigure built-in properties\n        var extendedDescriptor = Object.getOwnPropertyDescriptor(Extended, key);\n        if (extendedDescriptor && !extendedDescriptor.configurable) {\n            return;\n        }\n        var descriptor = Object.getOwnPropertyDescriptor(Original, key);\n        // If the user agent does not support `__proto__` or its family (IE <= 10),\n        // the sub class properties may be inherited properties from the super class in TypeScript.\n        // We need to exclude such properties to prevent to overwrite\n        // the component options object which stored on the extended constructor (See #192).\n        // If the value is a referenced value (object or function),\n        // we can check equality of them and exclude it if they have the same reference.\n        // If it is a primitive value, it will be forwarded for safety.\n        if (!hasProto) {\n            // Only `cid` is explicitly exluded from property forwarding\n            // because we cannot detect whether it is a inherited property or not\n            // on the no `__proto__` environment even though the property is reserved.\n            if (key === 'cid') {\n                return;\n            }\n            var superDescriptor = Object.getOwnPropertyDescriptor(Super, key);\n            if (!isPrimitive(descriptor.value) &&\n                superDescriptor &&\n                superDescriptor.value === descriptor.value) {\n                return;\n            }\n        }\n        Object.defineProperty(Extended, key, descriptor);\n    });\n}\n\nfunction Component(options) {\n    if (typeof options === 'function') {\n        return componentFactory(options);\n    }\n    return function (Component) {\n        return componentFactory(Component, options);\n    };\n}\nComponent.registerHooks = function registerHooks(keys) {\n    $internalHooks.push.apply($internalHooks, keys);\n};\n\nvar BaseEditorComponent =\n/*#__PURE__*/\nfunction (_Vue) {\n  _inherits(BaseEditorComponent, _Vue);\n\n  function BaseEditorComponent() {\n    var _this2;\n\n    _classCallCheck(this, BaseEditorComponent);\n\n    _this2 = _possibleConstructorReturn(this, _getPrototypeOf(BaseEditorComponent).apply(this, arguments));\n    _this2.name = 'BaseEditorComponent';\n    _this2.instance = null;\n    _this2.row = null;\n    _this2.col = null;\n    _this2.prop = null;\n    _this2.TD = null;\n    _this2.originalValue = null;\n    _this2.cellProperties = null;\n    _this2.state = null;\n    _this2.hot = null;\n    return _this2;\n  }\n\n  _createClass(BaseEditorComponent, [{\n    key: \"mounted\",\n    value: function mounted() {\n      var _this = this;\n\n      this.$data.hotCustomEditorClass = function () {\n        var customEditorClass =\n        /*#__PURE__*/\n        function (_Handsontable$editors) {\n          _inherits(CustomEditor, _Handsontable$editors);\n\n          function CustomEditor(hotInstance, row, col, prop, TD, cellProperties) {\n            var _this3;\n\n            _classCallCheck(this, CustomEditor);\n\n            _this3 = _possibleConstructorReturn(this, _getPrototypeOf(CustomEditor).call(this, hotInstance, row, col, prop, TD, cellProperties));\n            _this.$data.hotCustomEditorInstance = _assertThisInitialized(_this3);\n            return _this3;\n          }\n\n          _createClass(CustomEditor, [{\n            key: \"focus\",\n            value: function focus() {}\n          }, {\n            key: \"getValue\",\n            value: function getValue() {}\n          }, {\n            key: \"setValue\",\n            value: function setValue() {}\n          }, {\n            key: \"open\",\n            value: function open() {}\n          }, {\n            key: \"close\",\n            value: function close() {}\n          }]);\n\n          return CustomEditor;\n        }(Handsontable.editors.BaseEditor); // Fill with the rest of the BaseEditorComponent methods\n\n\n        Object.getOwnPropertyNames(Handsontable.editors.BaseEditor.prototype).forEach(function (propName) {\n          if (propName === 'constructor') {\n            return;\n          }\n\n          customEditorClass.prototype[propName] = function () {\n            var _this$propName;\n\n            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n              args[_key] = arguments[_key];\n            }\n\n            return (_this$propName = _this[propName]).call.apply(_this$propName, [this].concat(args));\n          };\n        });\n        return customEditorClass;\n      }();\n    } // BaseEditorComponent methods:\n\n  }, {\n    key: \"_fireCallbacks\",\n    value: function _fireCallbacks() {\n      var _Handsontable$editors2;\n\n      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        args[_key2] = arguments[_key2];\n      }\n\n      (_Handsontable$editors2 = Handsontable.editors.BaseEditor.prototype._fireCallbacks).call.apply(_Handsontable$editors2, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"beginEditing\",\n    value: function beginEditing() {\n      var _Handsontable$editors3;\n\n      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n        args[_key3] = arguments[_key3];\n      }\n\n      return (_Handsontable$editors3 = Handsontable.editors.BaseEditor.prototype.beginEditing).call.apply(_Handsontable$editors3, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"cancelChanges\",\n    value: function cancelChanges() {\n      var _Handsontable$editors4;\n\n      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n        args[_key4] = arguments[_key4];\n      }\n\n      return (_Handsontable$editors4 = Handsontable.editors.BaseEditor.prototype.cancelChanges).call.apply(_Handsontable$editors4, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"checkEditorSection\",\n    value: function checkEditorSection() {\n      var _Handsontable$editors5;\n\n      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {\n        args[_key5] = arguments[_key5];\n      }\n\n      return (_Handsontable$editors5 = Handsontable.editors.BaseEditor.prototype.checkEditorSection).call.apply(_Handsontable$editors5, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"close\",\n    value: function close() {\n      var _Handsontable$editors6;\n\n      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {\n        args[_key6] = arguments[_key6];\n      }\n\n      return (_Handsontable$editors6 = Handsontable.editors.BaseEditor.prototype.close).call.apply(_Handsontable$editors6, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"discardEditor\",\n    value: function discardEditor() {\n      var _Handsontable$editors7;\n\n      for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {\n        args[_key7] = arguments[_key7];\n      }\n\n      return (_Handsontable$editors7 = Handsontable.editors.BaseEditor.prototype.discardEditor).call.apply(_Handsontable$editors7, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"enableFullEditMode\",\n    value: function enableFullEditMode() {\n      var _Handsontable$editors8;\n\n      for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {\n        args[_key8] = arguments[_key8];\n      }\n\n      return (_Handsontable$editors8 = Handsontable.editors.BaseEditor.prototype.enableFullEditMode).call.apply(_Handsontable$editors8, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"extend\",\n    value: function extend() {\n      var _Handsontable$editors9;\n\n      for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {\n        args[_key9] = arguments[_key9];\n      }\n\n      return (_Handsontable$editors9 = Handsontable.editors.BaseEditor.prototype.extend).call.apply(_Handsontable$editors9, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"finishEditing\",\n    value: function finishEditing() {\n      var _Handsontable$editors10;\n\n      for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {\n        args[_key10] = arguments[_key10];\n      }\n\n      return (_Handsontable$editors10 = Handsontable.editors.BaseEditor.prototype.finishEditing).call.apply(_Handsontable$editors10, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"focus\",\n    value: function focus() {\n      var _Handsontable$editors11;\n\n      for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {\n        args[_key11] = arguments[_key11];\n      }\n\n      return (_Handsontable$editors11 = Handsontable.editors.BaseEditor.prototype.focus).call.apply(_Handsontable$editors11, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"getValue\",\n    value: function getValue() {\n      var _Handsontable$editors12;\n\n      for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {\n        args[_key12] = arguments[_key12];\n      }\n\n      return (_Handsontable$editors12 = Handsontable.editors.BaseEditor.prototype.getValue).call.apply(_Handsontable$editors12, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"init\",\n    value: function init() {\n      var _Handsontable$editors13;\n\n      for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {\n        args[_key13] = arguments[_key13];\n      }\n\n      return (_Handsontable$editors13 = Handsontable.editors.BaseEditor.prototype.init).call.apply(_Handsontable$editors13, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"isInFullEditMode\",\n    value: function isInFullEditMode() {\n      var _Handsontable$editors14;\n\n      for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {\n        args[_key14] = arguments[_key14];\n      }\n\n      return (_Handsontable$editors14 = Handsontable.editors.BaseEditor.prototype.isInFullEditMode).call.apply(_Handsontable$editors14, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"isOpened\",\n    value: function isOpened() {\n      var _Handsontable$editors15;\n\n      for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {\n        args[_key15] = arguments[_key15];\n      }\n\n      return (_Handsontable$editors15 = Handsontable.editors.BaseEditor.prototype.isOpened).call.apply(_Handsontable$editors15, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"isWaiting\",\n    value: function isWaiting() {\n      var _Handsontable$editors16;\n\n      for (var _len16 = arguments.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {\n        args[_key16] = arguments[_key16];\n      }\n\n      return (_Handsontable$editors16 = Handsontable.editors.BaseEditor.prototype.isWaiting).call.apply(_Handsontable$editors16, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"open\",\n    value: function open() {\n      var _Handsontable$editors17;\n\n      for (var _len17 = arguments.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {\n        args[_key17] = arguments[_key17];\n      }\n\n      return (_Handsontable$editors17 = Handsontable.editors.BaseEditor.prototype.open).call.apply(_Handsontable$editors17, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"prepare\",\n    value: function prepare(row, col, prop, TD, originalValue, cellProperties) {\n      this.$data.hotInstance = cellProperties.instance;\n      this.$data.row = row;\n      this.$data.col = col;\n      this.$data.prop = prop;\n      this.$data.TD = TD;\n      this.$data.originalValue = originalValue;\n      this.$data.cellProperties = cellProperties;\n      return Handsontable.editors.BaseEditor.prototype.prepare.call(this.$data.hotCustomEditorInstance, row, col, prop, TD, originalValue, cellProperties);\n    }\n  }, {\n    key: \"saveValue\",\n    value: function saveValue() {\n      var _Handsontable$editors18;\n\n      for (var _len18 = arguments.length, args = new Array(_len18), _key18 = 0; _key18 < _len18; _key18++) {\n        args[_key18] = arguments[_key18];\n      }\n\n      return (_Handsontable$editors18 = Handsontable.editors.BaseEditor.prototype.saveValue).call.apply(_Handsontable$editors18, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"setValue\",\n    value: function setValue() {\n      var _Handsontable$editors19;\n\n      for (var _len19 = arguments.length, args = new Array(_len19), _key19 = 0; _key19 < _len19; _key19++) {\n        args[_key19] = arguments[_key19];\n      }\n\n      return (_Handsontable$editors19 = Handsontable.editors.BaseEditor.prototype.setValue).call.apply(_Handsontable$editors19, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"addHook\",\n    value: function addHook() {\n      var _Handsontable$editors20;\n\n      for (var _len20 = arguments.length, args = new Array(_len20), _key20 = 0; _key20 < _len20; _key20++) {\n        args[_key20] = arguments[_key20];\n      }\n\n      return (_Handsontable$editors20 = Handsontable.editors.BaseEditor.prototype.addHook).call.apply(_Handsontable$editors20, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"removeHooksByKey\",\n    value: function removeHooksByKey() {\n      var _Handsontable$editors21;\n\n      for (var _len21 = arguments.length, args = new Array(_len21), _key21 = 0; _key21 < _len21; _key21++) {\n        args[_key21] = arguments[_key21];\n      }\n\n      return (_Handsontable$editors21 = Handsontable.editors.BaseEditor.prototype.removeHooksByKey).call.apply(_Handsontable$editors21, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"clearHooks\",\n    value: function clearHooks() {\n      var _Handsontable$editors22;\n\n      for (var _len22 = arguments.length, args = new Array(_len22), _key22 = 0; _key22 < _len22; _key22++) {\n        args[_key22] = arguments[_key22];\n      }\n\n      return (_Handsontable$editors22 = Handsontable.editors.BaseEditor.prototype.clearHooks).call.apply(_Handsontable$editors22, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"getEditedCell\",\n    value: function getEditedCell() {\n      var _Handsontable$editors23;\n\n      for (var _len23 = arguments.length, args = new Array(_len23), _key23 = 0; _key23 < _len23; _key23++) {\n        args[_key23] = arguments[_key23];\n      }\n\n      return (_Handsontable$editors23 = Handsontable.editors.BaseEditor.prototype.getEditedCell).call.apply(_Handsontable$editors23, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"getEditedCellsZIndex\",\n    value: function getEditedCellsZIndex() {\n      var _Handsontable$editors24;\n\n      for (var _len24 = arguments.length, args = new Array(_len24), _key24 = 0; _key24 < _len24; _key24++) {\n        args[_key24] = arguments[_key24];\n      }\n\n      return (_Handsontable$editors24 = Handsontable.editors.BaseEditor.prototype.getEditedCellsZIndex).call.apply(_Handsontable$editors24, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }, {\n    key: \"getEditedCellsLayerClass\",\n    value: function getEditedCellsLayerClass() {\n      var _Handsontable$editors25;\n\n      for (var _len25 = arguments.length, args = new Array(_len25), _key25 = 0; _key25 < _len25; _key25++) {\n        args[_key25] = arguments[_key25];\n      }\n\n      return (_Handsontable$editors25 = Handsontable.editors.BaseEditor.prototype.getEditedCellsLayerClass).call.apply(_Handsontable$editors25, [this.$data.hotCustomEditorInstance].concat(args));\n    }\n  }]);\n\n  return BaseEditorComponent;\n}(Vue);\n\nBaseEditorComponent = __decorate([Component({})], BaseEditorComponent);\nvar script = BaseEditorComponent;\n\n/* script */\nvar __vue_script__$2 = script;\n/* template */\n\n/* style */\n\nvar __vue_inject_styles__$2 = undefined;\n/* scoped */\n\nvar __vue_scope_id__$2 = undefined;\n/* module identifier */\n\nvar __vue_module_identifier__$2 = undefined;\n/* functional template */\n\nvar __vue_is_functional_template__$2 = undefined;\n/* style inject */\n\n/* style inject SSR */\n\nnormalizeComponent_1({}, __vue_inject_styles__$2, __vue_script__$2, __vue_scope_id__$2, __vue_is_functional_template__$2, __vue_module_identifier__$2, undefined, undefined);\n\nexport default HotTable$1;\nexport { BaseEditorComponent, HotColumn, HotTable };\n"],"sourceRoot":""}