text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory(require("vue"), require("agGrid"));
  	else if(typeof define === 'function' && define.amd)
  		define([, "agGrid"], factory);
  	else if(typeof exports === 'object')
  		exports["ag-grid-vue"] = factory(require("vue"), require("agGrid"));
  	else
  		root["ag-grid-vue"] = factory(root["Vue"], root["agGrid"]);
  })((typeof self !== 'undefined' ? self : this), function(__WEBPACK_EXTERNAL_MODULE__8bbf__, __WEBPACK_EXTERNAL_MODULE__8bd4__) {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = "fae3");
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ "65d9":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /**
    * vue-class-component v6.3.2
    * (c) 2015-present Evan You
    * @license MIT
    */
  
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var Vue = _interopDefault(__webpack_require__("8bbf"));
  
  var reflectionIsSupported = typeof Reflect !== 'undefined' && Reflect.defineMetadata;
  function copyReflectionMetadata(to, from) {
      forwardMetadata(to, from);
      Object.getOwnPropertyNames(from.prototype).forEach(function (key) {
          forwardMetadata(to.prototype, from.prototype, key);
      });
      Object.getOwnPropertyNames(from).forEach(function (key) {
          forwardMetadata(to, from, key);
      });
  }
  function forwardMetadata(to, from, propertyKey) {
      var metaKeys = propertyKey
          ? Reflect.getOwnMetadataKeys(from, propertyKey)
          : Reflect.getOwnMetadataKeys(from);
      metaKeys.forEach(function (metaKey) {
          var metadata = propertyKey
              ? Reflect.getOwnMetadata(metaKey, from, propertyKey)
              : Reflect.getOwnMetadata(metaKey, from);
          if (propertyKey) {
              Reflect.defineMetadata(metaKey, metadata, to, propertyKey);
          }
          else {
              Reflect.defineMetadata(metaKey, metadata, to);
          }
      });
  }
  
  var fakeArray = { __proto__: [] };
  var hasProto = fakeArray instanceof Array;
  function createDecorator(factory) {
      return function (target, key, index) {
          var Ctor = typeof target === 'function'
              ? target
              : target.constructor;
          if (!Ctor.__decorators__) {
              Ctor.__decorators__ = [];
          }
          if (typeof index !== 'number') {
              index = undefined;
          }
          Ctor.__decorators__.push(function (options) { return factory(options, key, index); });
      };
  }
  function mixins() {
      var Ctors = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          Ctors[_i] = arguments[_i];
      }
      return Vue.extend({ mixins: Ctors });
  }
  function isPrimitive(value) {
      var type = typeof value;
      return value == null || (type !== 'object' && type !== 'function');
  }
  function warn(message) {
      if (typeof console !== 'undefined') {
          console.warn('[vue-class-component] ' + message);
      }
  }
  
  function collectDataFromConstructor(vm, Component) {
      // override _init to prevent to init as Vue instance
      var originalInit = Component.prototype._init;
      Component.prototype._init = function () {
          var _this = this;
          // proxy to actual vm
          var keys = Object.getOwnPropertyNames(vm);
          // 2.2.0 compat (props are no longer exposed as self properties)
          if (vm.$options.props) {
              for (var key in vm.$options.props) {
                  if (!vm.hasOwnProperty(key)) {
                      keys.push(key);
                  }
              }
          }
          keys.forEach(function (key) {
              if (key.charAt(0) !== '_') {
                  Object.defineProperty(_this, key, {
                      get: function () { return vm[key]; },
                      set: function (value) { vm[key] = value; },
                      configurable: true
                  });
              }
          });
      };
      // should be acquired class property values
      var data = new Component();
      // restore original _init to avoid memory leak (#209)
      Component.prototype._init = originalInit;
      // create plain data object
      var plainData = {};
      Object.keys(data).forEach(function (key) {
          if (data[key] !== undefined) {
              plainData[key] = data[key];
          }
      });
      if (false) {}
      return plainData;
  }
  
  var $internalHooks = [
      'data',
      'beforeCreate',
      'created',
      'beforeMount',
      'mounted',
      'beforeDestroy',
      'destroyed',
      'beforeUpdate',
      'updated',
      'activated',
      'deactivated',
      'render',
      'errorCaptured' // 2.5
  ];
  function componentFactory(Component, options) {
      if (options === void 0) { options = {}; }
      options.name = options.name || Component._componentTag || Component.name;
      // prototype props.
      var proto = Component.prototype;
      Object.getOwnPropertyNames(proto).forEach(function (key) {
          if (key === 'constructor') {
              return;
          }
          // hooks
          if ($internalHooks.indexOf(key) > -1) {
              options[key] = proto[key];
              return;
          }
          var descriptor = Object.getOwnPropertyDescriptor(proto, key);
          if (descriptor.value !== void 0) {
              // methods
              if (typeof descriptor.value === 'function') {
                  (options.methods || (options.methods = {}))[key] = descriptor.value;
              }
              else {
                  // typescript decorated data
                  (options.mixins || (options.mixins = [])).push({
                      data: function () {
                          var _a;
                          return _a = {}, _a[key] = descriptor.value, _a;
                      }
                  });
              }
          }
          else if (descriptor.get || descriptor.set) {
              // computed properties
              (options.computed || (options.computed = {}))[key] = {
                  get: descriptor.get,
                  set: descriptor.set
              };
          }
      });
      (options.mixins || (options.mixins = [])).push({
          data: function () {
              return collectDataFromConstructor(this, Component);
          }
      });
      // decorate options
      var decorators = Component.__decorators__;
      if (decorators) {
          decorators.forEach(function (fn) { return fn(options); });
          delete Component.__decorators__;
      }
      // find super
      var superProto = Object.getPrototypeOf(Component.prototype);
      var Super = superProto instanceof Vue
          ? superProto.constructor
          : Vue;
      var Extended = Super.extend(options);
      forwardStaticMembers(Extended, Component, Super);
      if (reflectionIsSupported) {
          copyReflectionMetadata(Extended, Component);
      }
      return Extended;
  }
  var reservedPropertyNames = [
      // Unique id
      'cid',
      // Super Vue constructor
      'super',
      // Component options that will be used by the component
      'options',
      'superOptions',
      'extendOptions',
      'sealedOptions',
      // Private assets
      'component',
      'directive',
      'filter'
  ];
  function forwardStaticMembers(Extended, Original, Super) {
      // We have to use getOwnPropertyNames since Babel registers methods as non-enumerable
      Object.getOwnPropertyNames(Original).forEach(function (key) {
          // `prototype` should not be overwritten
          if (key === 'prototype') {
              return;
          }
          // Some browsers does not allow reconfigure built-in properties
          var extendedDescriptor = Object.getOwnPropertyDescriptor(Extended, key);
          if (extendedDescriptor && !extendedDescriptor.configurable) {
              return;
          }
          var descriptor = Object.getOwnPropertyDescriptor(Original, key);
          // If the user agent does not support `__proto__` or its family (IE <= 10),
          // the sub class properties may be inherited properties from the super class in TypeScript.
          // We need to exclude such properties to prevent to overwrite
          // the component options object which stored on the extended constructor (See #192).
          // If the value is a referenced value (object or function),
          // we can check equality of them and exclude it if they have the same reference.
          // If it is a primitive value, it will be forwarded for safety.
          if (!hasProto) {
              // Only `cid` is explicitly exluded from property forwarding
              // because we cannot detect whether it is a inherited property or not
              // on the no `__proto__` environment even though the property is reserved.
              if (key === 'cid') {
                  return;
              }
              var superDescriptor = Object.getOwnPropertyDescriptor(Super, key);
              if (!isPrimitive(descriptor.value) &&
                  superDescriptor &&
                  superDescriptor.value === descriptor.value) {
                  return;
              }
          }
          // Warn if the users manually declare reserved properties
          if (false) {}
          Object.defineProperty(Extended, key, descriptor);
      });
  }
  
  function Component(options) {
      if (typeof options === 'function') {
          return componentFactory(options);
      }
      return function (Component) {
          return componentFactory(Component, options);
      };
  }
  Component.registerHooks = function registerHooks(keys) {
      $internalHooks.push.apply($internalHooks, keys);
  };
  
  exports.default = Component;
  exports.createDecorator = createDecorator;
  exports.mixins = mixins;
  
  
  /***/ }),
  
  /***/ "8bbf":
  /***/ (function(module, exports) {
  
  module.exports = __WEBPACK_EXTERNAL_MODULE__8bbf__;
  
  /***/ }),
  
  /***/ "8bd4":
  /***/ (function(module, exports) {
  
  module.exports = __WEBPACK_EXTERNAL_MODULE__8bd4__;
  
  /***/ }),
  
  /***/ "fae3":
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  
  // CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/setPublicPath.js
  // This file is imported into lib/wc client bundles.
  
  if (typeof window !== 'undefined') {
    var i
    if ((i = window.document.currentScript) && (i = i.src.match(/(.+\/)[^/]+\.js(\?.*)?$/))) {
      __webpack_require__.p = i[1] // eslint-disable-line
    }
  }
  
  // Indicate to webpack that this file can be concatenated
  /* harmony default export */ var setPublicPath = (null);
  
  // CONCATENATED MODULE: ./node_modules/tslib/tslib.es6.js
  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation. All rights reserved.
  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this file except in compliance with the License. You may obtain a copy of the
  License at http://www.apache.org/licenses/LICENSE-2.0
  
  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
  MERCHANTABLITY OR NON-INFRINGEMENT.
  
  See the Apache Version 2.0 License for specific language governing permissions
  and limitations under the License.
  ***************************************************************************** */
  /* global Reflect, Promise */
  
  var extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return extendStatics(d, b);
  };
  
  function __extends(d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }
  
  var __assign = function() {
      __assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      }
      return __assign.apply(this, arguments);
  }
  
  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)
              t[p[i]] = s[p[i]];
      return t;
  }
  
  function __decorate(decorators, target, key, desc) {
      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
      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;
      return c > 3 && r && Object.defineProperty(target, key, r), r;
  }
  
  function __param(paramIndex, decorator) {
      return function (target, key) { decorator(target, key, paramIndex); }
  }
  
  function __metadata(metadataKey, metadataValue) {
      if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
  }
  
  function __awaiter(thisArg, _arguments, P, generator) {
      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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  }
  
  function __generator(thisArg, body) {
      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
      function verb(n) { return function (v) { return step([n, v]); }; }
      function step(op) {
          if (f) throw new TypeError("Generator is already executing.");
          while (_) try {
              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
              if (y = 0, t) op = [op[0] & 2, t.value];
              switch (op[0]) {
                  case 0: case 1: t = op; break;
                  case 4: _.label++; return { value: op[1], done: false };
                  case 5: _.label++; y = op[1]; op = [0]; continue;
                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
                  default:
                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                      if (t[2]) _.ops.pop();
                      _.trys.pop(); continue;
              }
              op = body.call(thisArg, _);
          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
      }
  }
  
  function __exportStar(m, exports) {
      for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  
  function __values(o) {
      var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
      if (m) return m.call(o);
      return {
          next: function () {
              if (o && i >= o.length) o = void 0;
              return { value: o && o[i++], done: !o };
          }
      };
  }
  
  function __read(o, n) {
      var m = typeof Symbol === "function" && o[Symbol.iterator];
      if (!m) return o;
      var i = m.call(o), r, ar = [], e;
      try {
          while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
      }
      catch (error) { e = { error: error }; }
      finally {
          try {
              if (r && !r.done && (m = i["return"])) m.call(i);
          }
          finally { if (e) throw e.error; }
      }
      return ar;
  }
  
  function __spread() {
      for (var ar = [], i = 0; i < arguments.length; i++)
          ar = ar.concat(__read(arguments[i]));
      return ar;
  }
  
  function __await(v) {
      return this instanceof __await ? (this.v = v, this) : new __await(v);
  }
  
  function __asyncGenerator(thisArg, _arguments, generator) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var g = generator.apply(thisArg, _arguments || []), i, q = [];
      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
      function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
      function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
      function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
      function fulfill(value) { resume("next", value); }
      function reject(value) { resume("throw", value); }
      function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
  }
  
  function __asyncDelegator(o) {
      var i, p;
      return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
      function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
  }
  
  function __asyncValues(o) {
      if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
      var m = o[Symbol.asyncIterator], i;
      return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
      function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
      function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
  }
  
  function __makeTemplateObject(cooked, raw) {
      if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
      return cooked;
  };
  
  function __importStar(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result.default = mod;
      return result;
  }
  
  function __importDefault(mod) {
      return (mod && mod.__esModule) ? mod : { default: mod };
  }
  
  // EXTERNAL MODULE: external {"commonjs":"vue","commonjs2":"vue","root":"Vue"}
  var external_commonjs_vue_commonjs2_vue_root_Vue_ = __webpack_require__("8bbf");
  var external_commonjs_vue_commonjs2_vue_root_Vue_default = /*#__PURE__*/__webpack_require__.n(external_commonjs_vue_commonjs2_vue_root_Vue_);
  
  // EXTERNAL MODULE: ./node_modules/vue-class-component/dist/vue-class-component.common.js
  var vue_class_component_common = __webpack_require__("65d9");
  var vue_class_component_common_default = /*#__PURE__*/__webpack_require__.n(vue_class_component_common);
  
  // CONCATENATED MODULE: ./node_modules/vue-property-decorator/lib/vue-property-decorator.js
  /** vue-property-decorator verson 7.2.0 MIT LICENSE copyright 2018 kaorun343 */
  
  
  
  
  /**
   * decorator of an inject
   * @param from key
   * @return PropertyDecorator
   */
  function Inject(options) {
      return Object(vue_class_component_common["createDecorator"])(function (componentOptions, key) {
          if (typeof componentOptions.inject === 'undefined') {
              componentOptions.inject = {};
          }
          if (!Array.isArray(componentOptions.inject)) {
              componentOptions.inject[key] = options || key;
          }
      });
  }
  /**
   * decorator of a provide
   * @param key key
   * @return PropertyDecorator | void
   */
  function Provide(key) {
      return Object(vue_class_component_common["createDecorator"])(function (componentOptions, k) {
          var provide = componentOptions.provide;
          if (typeof provide !== 'function' || !provide.managed) {
              var original_1 = componentOptions.provide;
              provide = componentOptions.provide = function () {
                  var rv = Object.create((typeof original_1 === 'function' ? original_1.call(this) : original_1) || null);
                  for (var i in provide.managed)
                      rv[provide.managed[i]] = this[i];
                  return rv;
              };
              provide.managed = {};
          }
          provide.managed[k] = key || k;
      });
  }
  /**
   * decorator of model
   * @param  event event name
   * @param options options
   * @return PropertyDecorator
   */
  function Model(event, options) {
      if (options === void 0) { options = {}; }
      return Object(vue_class_component_common["createDecorator"])(function (componentOptions, k) {
          (componentOptions.props || (componentOptions.props = {}))[k] = options;
          componentOptions.model = { prop: k, event: event || k };
      });
  }
  /**
   * decorator of a prop
   * @param  options the options for the prop
   * @return PropertyDecorator | void
   */
  function Prop(options) {
      if (options === void 0) { options = {}; }
      return Object(vue_class_component_common["createDecorator"])(function (componentOptions, k) {
          (componentOptions.props || (componentOptions.props = {}))[k] = options;
      });
  }
  /**
   * decorator of a watch function
   * @param  path the path or the expression to observe
   * @param  WatchOption
   * @return MethodDecorator
   */
  function Watch(path, options) {
      if (options === void 0) { options = {}; }
      var _a = options.deep, deep = _a === void 0 ? false : _a, _b = options.immediate, immediate = _b === void 0 ? false : _b;
      return Object(vue_class_component_common["createDecorator"])(function (componentOptions, handler) {
          if (typeof componentOptions.watch !== 'object') {
              componentOptions.watch = Object.create(null);
          }
          componentOptions.watch[path] = { handler: handler, deep: deep, immediate: immediate };
      });
  }
  // Code copied from Vue/src/shared/util.js
  var hyphenateRE = /\B([A-Z])/g;
  var hyphenate = function (str) { return str.replace(hyphenateRE, '-$1').toLowerCase(); };
  /**
   * decorator of an event-emitter function
   * @param  event The name of the event
   * @return MethodDecorator
   */
  function Emit(event) {
      return function (_target, key, descriptor) {
          key = hyphenate(key);
          var original = descriptor.value;
          descriptor.value = function emitter() {
              var _this = this;
              var args = [];
              for (var _i = 0; _i < arguments.length; _i++) {
                  args[_i] = arguments[_i];
              }
              var emit = function (returnValue) {
                  if (returnValue !== undefined)
                      args.unshift(returnValue);
                  _this.$emit.apply(_this, [event || key].concat(args));
              };
              var returnValue = original.apply(this, args);
              if (isPromise(returnValue)) {
                  returnValue.then(function (returnValue) {
                      emit(returnValue);
                  });
              }
              else {
                  emit(returnValue);
              }
          };
      };
  }
  function isPromise(obj) {
      return obj instanceof Promise || (obj && typeof obj.then === 'function');
  }
  
  // EXTERNAL MODULE: external "agGrid"
  var external_agGrid_ = __webpack_require__("8bd4");
  
  // CONCATENATED MODULE: ./src/VueComponentFactory.ts
  
  var VueComponentFactory_VueComponentFactory = /** @class */ (function () {
      function VueComponentFactory() {
      }
      VueComponentFactory.getComponentType = function (parent, component) {
          if (typeof component === 'string') {
              var componentInstance = parent.$parent.$options.components[component];
              if (!componentInstance) {
                  console.error("Could not find component with name of " + component + ". Is it in Vue.components?");
                  return null;
              }
              return external_commonjs_vue_commonjs2_vue_root_Vue_default.a.extend(componentInstance);
          }
          else {
              // assume a type
              return component;
          }
      };
      VueComponentFactory.createAndMountComponent = function (params, componentType, parent) {
          var details = {
              data: {
                  params: Object.freeze(params),
              },
              parent: parent,
          };
          if (parent.componentDependencies) {
              parent.componentDependencies.forEach(function (dependency) {
                  return details[dependency] = parent[dependency];
              });
          }
          var component = new componentType(details);
          component.$mount();
          return component;
      };
      return VueComponentFactory;
  }());
  
  
  // CONCATENATED MODULE: ./src/VueFrameworkComponentWrapper.ts
  
  
  
  var VueFrameworkComponentWrapper_VueFrameworkComponentWrapper = /** @class */ (function (_super) {
      __extends(VueFrameworkComponentWrapper, _super);
      function VueFrameworkComponentWrapper(parent) {
          var _this = _super.call(this) || this;
          _this.parent = parent;
          return _this;
      }
      VueFrameworkComponentWrapper.prototype.createWrapper = function (component) {
          var that = this;
          var DynamicComponent = /** @class */ (function (_super) {
              __extends(DynamicComponent, _super);
              function DynamicComponent() {
                  return _super !== null && _super.apply(this, arguments) || this;
              }
              DynamicComponent.prototype.init = function (params) {
                  _super.prototype.init.call(this, params);
              };
              DynamicComponent.prototype.hasMethod = function (name) {
                  return wrapper.getFrameworkComponentInstance()[name] != null;
              };
              DynamicComponent.prototype.callMethod = function (name, args) {
                  var componentInstance = this.getFrameworkComponentInstance();
                  var frameworkComponentInstance = wrapper.getFrameworkComponentInstance();
                  return frameworkComponentInstance[name].apply(componentInstance, args);
              };
              DynamicComponent.prototype.addMethod = function (name, callback) {
                  wrapper[name] = callback;
              };
              DynamicComponent.prototype.overrideProcessing = function (methodName) {
                  return that.parent.autoParamsRefresh && methodName === 'refresh';
              };
              DynamicComponent.prototype.processMethod = function (methodName, args) {
                  if (methodName === 'refresh') {
                      this.getFrameworkComponentInstance().params = args[0];
                  }
                  if (this.hasMethod(methodName)) {
                      return this.callMethod(methodName, args);
                  }
                  return methodName === 'refresh';
              };
              DynamicComponent.prototype.createComponent = function (params) {
                  return that.createComponent(component, params);
              };
              return DynamicComponent;
          }(VueComponent));
          var wrapper = new DynamicComponent();
          return wrapper;
      };
      VueFrameworkComponentWrapper.prototype.createComponent = function (component, params) {
          var componentType = VueComponentFactory_VueComponentFactory.getComponentType(this.parent, component);
          if (!componentType) {
              return;
          }
          return VueComponentFactory_VueComponentFactory.createAndMountComponent(params, componentType, this.parent);
      };
      VueFrameworkComponentWrapper.prototype.createMethodProxy = function (wrapper, methodName, mandatory) {
          return function () {
              if (wrapper.overrideProcessing(methodName)) {
                  return wrapper.processMethod(methodName, arguments);
              }
              if (wrapper.hasMethod(methodName)) {
                  return wrapper.callMethod(methodName, arguments);
              }
              if (mandatory) {
                  console.warn('ag-Grid: Framework component is missing the method ' + methodName + '()');
              }
              return null;
          };
      };
      VueFrameworkComponentWrapper.prototype.destroy = function () {
          this.parent = null;
      };
      VueFrameworkComponentWrapper = __decorate([
          Object(external_agGrid_["Bean"])('frameworkComponentWrapper')
      ], VueFrameworkComponentWrapper);
      return VueFrameworkComponentWrapper;
  }(external_agGrid_["BaseComponentWrapper"]));
  
  var VueComponent = /** @class */ (function () {
      function VueComponent() {
      }
      VueComponent.prototype.getGui = function () {
          return this.component.$el;
      };
      VueComponent.prototype.destroy = function () {
          this.component.$destroy();
      };
      VueComponent.prototype.getFrameworkComponentInstance = function () {
          return this.component;
      };
      VueComponent.prototype.init = function (params) {
          this.component = this.createComponent(params);
      };
      return VueComponent;
  }());
  
  // CONCATENATED MODULE: ./src/Utils.ts
  
  var getAgGridProperties = function () {
      var props = {
          gridOptions: {
              default: function () {
                  return {};
              },
          },
          rowDataModel: undefined,
      };
      var watch = {
          rowDataModel: function (currentValue, previousValue) {
              this.processChanges('rowData', currentValue, previousValue);
          },
      };
      external_agGrid_["ComponentUtil"].ALL_PROPERTIES.forEach(function (propertyName) {
          props[propertyName] = {};
          watch[propertyName] = function (currentValue, previousValue) {
              this.processChanges(propertyName, currentValue, previousValue);
          };
      });
      var model = {
          prop: 'rowDataModel',
          event: 'data-model-changed',
      };
      return [props, watch, model];
  };
  
  // CONCATENATED MODULE: ./src/AgGridColumn.ts
  
  var AgGridColumn_AgGridColumn = /** @class */ (function () {
      function AgGridColumn() {
      }
      AgGridColumn.hasChildColumns = function (slots) {
          return slots && slots.default && slots.default.length > 0;
      };
      AgGridColumn.mapChildColumnDefs = function (slots) {
          return slots.default.map(function (column) {
              return AgGridColumn.toColDef(column);
          });
      };
      AgGridColumn.toColDef = function (column) {
          var colDef = AgGridColumn.createColDefFromGridColumn(column);
          if (column.children && column.children.length > 0) {
              colDef.children = AgGridColumn.getChildColDefs(column.children);
          }
          return colDef;
      };
      AgGridColumn.getChildColDefs = function (columnChildren) {
          return columnChildren.map(function (column) {
              return AgGridColumn.createColDefFromGridColumn(column);
          });
      };
      AgGridColumn.createColDefFromGridColumn = function (column) {
          var colDef = {};
          AgGridColumn.assign(colDef, column.data.attrs);
          delete colDef.children;
          // booleans passed down just as is are here as property=""
          // convert boolean props to a boolean here
          external_agGrid_["ColDefUtil"].BOOLEAN_PROPERTIES.forEach(function (property) {
              var colDefAsAny = colDef;
              if (colDefAsAny[property] === '') {
                  colDefAsAny[property] = true;
              }
          });
          return colDef;
      };
      AgGridColumn.assign = function (colDef, from) {
          // effectively Object.assign - here for IE compatibility
          return [from].reduce(function (r, o) {
              Object.keys(o).forEach(function (k) {
                  r[k] = o[k];
              });
              return r;
          }, colDef);
      };
      return AgGridColumn;
  }());
  
  
  // CONCATENATED MODULE: ./src/AgGridVue.ts
  
  
  
  
  
  
  var AgGridVue_a = getAgGridProperties(), AgGridVue_props = AgGridVue_a[0], AgGridVue_watch = AgGridVue_a[1], AgGridVue_model = AgGridVue_a[2];
  var AgGridVue_AgGridVue = /** @class */ (function (_super) {
      __extends(AgGridVue, _super);
      function AgGridVue() {
          var _this = _super !== null && _super.apply(this, arguments) || this;
          _this.gridCreated = false;
          _this.isDestroyed = false;
          _this.gridReadyFired = false;
          _this.emitRowModel = null;
          return _this;
      }
      AgGridVue_1 = AgGridVue;
      AgGridVue.kebabProperty = function (property) {
          return property.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
      };
      // noinspection JSUnusedGlobalSymbols, JSMethodCanBeStatic
      AgGridVue.prototype.render = function (h) {
          return h('div');
      };
      AgGridVue.prototype.globalEventListener = function (eventType, event) {
          if (this.isDestroyed) {
              return;
          }
          if (eventType === 'gridReady') {
              this.gridReadyFired = true;
          }
          this.updateModelIfUsed(eventType);
          // only emit if someone is listening
          // we allow both kebab and camelCase event listeners, so check for both
          var kebabName = AgGridVue_1.kebabProperty(eventType);
          if (this.$listeners[kebabName]) {
              this.$emit(kebabName, event);
          }
          else if (this.$listeners[eventType]) {
              this.$emit(eventType, event);
          }
      };
      AgGridVue.prototype.processChanges = function (propertyName, currentValue, previousValue) {
          if (this.gridCreated) {
              if (this.skipChange(propertyName, currentValue, previousValue)) {
                  return;
              }
              var changes = {};
              changes[propertyName] = {
                  currentValue: currentValue,
                  previousValue: previousValue,
              };
              external_agGrid_["ComponentUtil"].processOnChange(changes, this.gridOptions, this.gridOptions.api, this.gridOptions.columnApi);
          }
      };
      // noinspection JSUnusedGlobalSymbols
      AgGridVue.prototype.mounted = function () {
          var _this = this;
          // we debounce the model update to prevent a flood of updates in the event there are many individual
          // cell/row updates
          this.emitRowModel = this.debounce(function () {
              _this.$emit('data-model-changed', Object.freeze(_this.getRowData()));
          }, 20);
          var frameworkComponentWrapper = new VueFrameworkComponentWrapper_VueFrameworkComponentWrapper(this);
          var gridOptions = external_agGrid_["ComponentUtil"].copyAttributesToGridOptions(this.gridOptions, this);
          this.checkForBindingConflicts();
          gridOptions.rowData = this.getRowDataBasedOnBindings();
          if (AgGridColumn_AgGridColumn.hasChildColumns(this.$slots)) {
              gridOptions.columnDefs = AgGridColumn_AgGridColumn.mapChildColumnDefs(this.$slots);
          }
          var gridParams = {
              globalEventListener: this.globalEventListener.bind(this),
              seedBeanInstances: {
                  frameworkComponentWrapper: frameworkComponentWrapper,
              },
          };
          new external_agGrid_["Grid"](this.$el, gridOptions, gridParams);
          this.gridCreated = true;
      };
      // noinspection JSUnusedGlobalSymbols
      AgGridVue.prototype.destroyed = function () {
          if (this.gridCreated) {
              if (this.gridOptions.api) {
                  this.gridOptions.api.destroy();
              }
              this.isDestroyed = true;
          }
      };
      AgGridVue.prototype.checkForBindingConflicts = function () {
          var thisAsAny = this;
          if ((thisAsAny.rowData || this.gridOptions.rowData) &&
              thisAsAny.rowDataModel) {
              console.warn('ag-grid: Using both rowData and rowDataModel. rowData will be ignored.');
          }
      };
      AgGridVue.prototype.getRowData = function () {
          var rowData = [];
          this.gridOptions.api.forEachNode(function (rowNode) {
              rowData.push(rowNode.data);
          });
          return rowData;
      };
      AgGridVue.prototype.updateModelIfUsed = function (eventType) {
          if (this.gridReadyFired &&
              this.$listeners['data-model-changed'] &&
              AgGridVue_1.ROW_DATA_EVENTS.indexOf(eventType) !== -1) {
              if (this.emitRowModel) {
                  this.emitRowModel();
              }
          }
      };
      AgGridVue.prototype.getRowDataBasedOnBindings = function () {
          var thisAsAny = this;
          var rowDataModel = thisAsAny.rowDataModel;
          return rowDataModel ? rowDataModel :
              thisAsAny.rowData ? thisAsAny.rowData : thisAsAny.gridOptions.rowData;
      };
      /*
       * Prevents an infinite loop when using v-model for the rowData
       */
      AgGridVue.prototype.skipChange = function (propertyName, currentValue, previousValue) {
          if (this.gridReadyFired &&
              propertyName === 'rowData' &&
              this.$listeners['data-model-changed']) {
              if (currentValue === previousValue) {
                  return true;
              }
              if (currentValue && previousValue) {
                  var currentRowData = currentValue;
                  var previousRowData = previousValue;
                  if (currentRowData.length === previousRowData.length) {
                      for (var i = 0; i < currentRowData.length; i++) {
                          if (currentRowData[i] !== previousRowData[i]) {
                              return false;
                          }
                      }
                      return true;
                  }
              }
          }
          return false;
      };
      AgGridVue.prototype.debounce = function (func, delay) {
          var timeout;
          return function () {
              var later = function () {
                  func();
              };
              window.clearTimeout(timeout);
              timeout = window.setTimeout(later, delay);
          };
      };
      var AgGridVue_1;
      AgGridVue.ROW_DATA_EVENTS = ['rowDataChanged', 'rowDataUpdated', 'cellValueChanged', 'rowValueChanged'];
      __decorate([
          Prop(Boolean)
      ], AgGridVue.prototype, "autoParamsRefresh", void 0);
      __decorate([
          Prop({ default: function () { return []; } })
      ], AgGridVue.prototype, "componentDependencies", void 0);
      AgGridVue = AgGridVue_1 = __decorate([
          Object(external_agGrid_["Bean"])('agGridVue'),
          vue_class_component_common_default()({
              props: AgGridVue_props,
              watch: AgGridVue_watch,
              model: AgGridVue_model,
          })
      ], AgGridVue);
      return AgGridVue;
  }(external_commonjs_vue_commonjs2_vue_root_Vue_default.a));
  
  
  // CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/entry-lib-no-default.js
  /* concated harmony reexport AgGridVue */__webpack_require__.d(__webpack_exports__, "AgGridVue", function() { return AgGridVue_AgGridVue; });
  
  
  
  
  /***/ })
  
  /******/ });
  });
  //# sourceMappingURL=ag-grid-vue.umd.js.map