text: (function (global, factory) {
      typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('@angular/core'),exports, require('@angular/core'), require('@angular/forms'), require('flatpickr')) :
      typeof define === 'function' && define.amd ? define('angularx-flatpickr', ['@angular/core','exports', '@angular/core', '@angular/forms', 'flatpickr'], factory) :
      (factory(global.ng.core,(global['angularx-flatpickr'] = {}),global.ng.core,global.ng.forms,null));
  }(this, (function (ɵngcc0,exports,core,forms,flatpickr) { 'use strict';
  
      flatpickr = flatpickr && flatpickr.hasOwnProperty('default') ? flatpickr['default'] : flatpickr;
  
      /*! *****************************************************************************
      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.
      ***************************************************************************** */
      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;
      }
  
      /**
       * @fileoverview added by tsickle
       * @suppress {checkTypes} checked by tsc
       */
      var FlatpickrDefaults = (function () {
          function FlatpickrDefaults() {
              /**
               * Exactly the same as date format, but for the altInput field.
               */
              this.altFormat = 'F j, Y';
              /**
               * 	Show the user a readable date (as per altFormat), but return something totally different to the server.
               */
              this.altInput = false;
              /**
               * This class will be added to the input element created by the altInput option.
               * Note that `altInput` already inherits classes from the original input.
               */
              this.altInputClass = '';
              /**
               * Allows the user to enter a date directly input the input field. By default, direct entry is disabled.
               */
              this.allowInput = false;
              /**
               * Instead of `body`, appends the calendar to the specified node instead.
               */
              this.appendTo = undefined;
              /**
               * Defines how the date will be formatted in the aria-label for calendar days, using the same tokens as dateFormat. If you change this, you should choose a value that will make sense if a screen reader reads it out loud.
               */
              this.ariaDateFormat = 'F j, Y';
              /**
               * Whether clicking on the input should open the picker.
               * You could disable this if you wish to open the calendar manually `with.open()`.
               */
              this.clickOpens = true;
              /**
               * A string of characters which are used to define how the date will be displayed in the input box.
               * The supported characters are defined in the table below.
               */
              this.dateFormat = 'Y-m-d';
              /**
               * Initial value of the hour element.
               */
              this.defaultHour = 12;
              /**
               * Initial value of the minute element.
               */
              this.defaultMinute = 0;
              /**
               * Initial value of the seconds element.
               */
              this.defaultSeconds = 0;
              /**
               * See <a href="https://chmln.github.io/flatpickr/examples/#disabling-specific-dates">disabling dates</a>.
               */
              this.disable = [];
              /**
               * Set disableMobile to true to always use the non-native picker.
               * By default, Flatpickr utilizes native datetime widgets unless certain options (e.g. disable) are used.
               */
              this.disableMobile = false;
              /**
               * See <a href="https://chmln.github.io/flatpickr/examples/#disabling-all-dates-except-select-few">enabling dates</a>.
               */
              this.enable = [];
              /**
               * Enables time picker.
               */
              this.enableTime = false;
              /**
               * Enables seconds in the time picker.
               */
              this.enableSeconds = false;
              /**
               * Allows using a custom date formatting function instead of the built-in handling for date formats using dateFormat, altFormat, etc.
               */
              this.formatDate = undefined;
              /**
               * Adjusts the step for the hour input (incl. scrolling).
               */
              this.hourIncrement = 1;
              /**
               * Displays the calendar inline.
               */
              this.inline = false;
              /**
               * The maximum date that a user can pick to (inclusive).
               */
              this.maxDate = undefined;
              /**
               * The minimum date that a user can start picking from (inclusive).
               */
              this.minDate = undefined;
              /**
               * Adjusts the step for the minute input (incl. scrolling).
               */
              this.minuteIncrement = 5;
              /**
               * Select a single date, multiple dates or a date range.
               */
              this.mode = 'single';
              /**
               * HTML for the arrow icon, used to switch months.
               */
              this.nextArrow = '>';
              /**
               * Hides the day selection in calendar. Use it along with `enableTime` to create a time picker.
               */
              this.noCalendar = false;
              /**
               * Default now to the current date
               */
              this.now = new Date();
              /**
               * HTML for the left arrow icon.
               */
              this.prevArrow = '<';
              /**
               * Show the month using the shorthand version (ie, Sep instead of September).
               */
              this.shorthandCurrentMonth = false;
              /**
               * Position the calendar inside the wrapper and next to the input element. (Leave `false` unless you know what you're doing).
               */
              this.static = false;
              /**
               * Displays time picker in 24 hour mode without AM/PM selection when enabled.
               */
              this.time24hr = false;
              /**
               * When true, dates will parsed, formatted, and displayed in UTC.
               * It's recommended that date strings contain the timezone, but not necessary.
               */
              this.utc = false;
              /**
               * Enables display of week numbers in calendar.
               */
              this.weekNumbers = false;
              /**
               * Custom elements and input groups.
               */
              this.wrap = false;
              /**
               * Array of plugin instances to use.
               */
              this.plugins = [];
              /**
               * The locale object or string to use for the locale.
               */
              this.locale = 'default';
              /**
               * Auto convert the ngModel value from a string to a date / array of dates / from - to date object depending on the `mode`
               */
              this.convertModelValue = false;
              /**
               * The number of months shown.
               */
              this.showMonths = 1;
              /**
               * How the month should be displayed in the header of the calendar.
               */
              this.monthSelectorType = 'static';
          }
  FlatpickrDefaults.ɵfac = function FlatpickrDefaults_Factory(t) { return new (t || FlatpickrDefaults)(); };
  FlatpickrDefaults.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: FlatpickrDefaults, factory: function (t) { return FlatpickrDefaults.ɵfac(t); } });
  /*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(FlatpickrDefaults, [{
          type: core.Injectable
      }], function () { return []; }, null); })();
          return FlatpickrDefaults;
      }());
  
      /**
       * @fileoverview added by tsickle
       * @suppress {checkTypes} checked by tsc
       */
      var /** @type {?} */ FLATPICKR_CONTROL_VALUE_ACCESSOR = {
          provide: forms.NG_VALUE_ACCESSOR,
          useExisting: core.forwardRef(function () { return FlatpickrDirective; }),
          //tslint:disable-line
          multi: true
      };
      var FlatpickrDirective = (function () {
          function FlatpickrDirective(elm, defaults, renderer) {
              this.elm = elm;
              this.defaults = defaults;
              this.renderer = renderer;
              /**
               * Object-options that can be user for multiple instances of Flatpickr.
               * Option from this object is applied only if specific option is not specified.
               * Example:
               * ```typescript
               * options: FlatpickrDefaultsInterface = {
               *      altFormat: 'd/m/Y',   // will be ignored since altFormat is provided via specific attribute
               *      altInput: true        // will be used since specific attribute is not provided
               * };
               * ```
               * ```html
               * <input
               *   class="form-control"
               *   type="text"
               *   mwlFlatpickr
               *   [options]="options"
               *   altFormat="d/m/Y">
               * ```
               */
              this.options = {};
              /**
               * Gets triggered once the calendar is in a ready state
               */
              this.flatpickrReady = new core.EventEmitter();
              /**
               * Gets triggered when the user selects a date, or changes the time on a selected date.
               */
              this.flatpickrChange = new core.EventEmitter();
              /**
               * Gets triggered when the input value is updated with a new date string.
               */
              this.flatpickrValueUpdate = new core.EventEmitter();
              /**
               * Gets triggered when the calendar is opened.
               */
              this.flatpickrOpen = new core.EventEmitter();
              /**
               * Gets triggered when the calendar is closed.
               */
              this.flatpickrClose = new core.EventEmitter();
              /**
               * Gets triggered when the month is changed, either by the user or programmatically.
               */
              this.flatpickrMonthChange = new core.EventEmitter();
              /**
               * Gets triggered when the year is changed, either by the user or programmatically.
               */
              this.flatpickrYearChange = new core.EventEmitter();
              /**
               * Take full control of every date cell with this output
               */
              this.flatpickrDayCreate = new core.EventEmitter();
              this.isDisabled = false;
              this.onChangeFn = function () { };
              this.onTouchedFn = function () { };
          }
          /**
           * @return {?}
           */
          FlatpickrDirective.prototype.ngAfterViewInit = /**
           * @return {?}
           */
              function () {
                  var _this = this;
                  var /** @type {?} */ options = {
                      altFormat: this.altFormat,
                      altInput: this.altInput,
                      altInputClass: this.altInputClass,
                      allowInput: this.allowInput,
                      appendTo: this.appendTo,
                      ariaDateFormat: this.ariaDateFormat,
                      clickOpens: this.clickOpens,
                      dateFormat: this.dateFormat,
                      defaultHour: this.defaultHour,
                      defaultMinute: this.defaultMinute,
                      defaultSeconds: this.defaultSeconds,
                      disable: this.disable,
                      disableMobile: this.disableMobile,
                      enable: this.enable,
                      enableTime: this.enableTime,
                      enableSeconds: this.enableSeconds,
                      formatDate: this.formatDate,
                      hourIncrement: this.hourIncrement,
                      defaultDate: this.initialValue,
                      inline: this.inline,
                      maxDate: this.maxDate,
                      minDate: this.minDate,
                      minuteIncrement: this.minuteIncrement,
                      mode: this.mode,
                      nextArrow: this.nextArrow,
                      noCalendar: this.noCalendar,
                      now: this.now,
                      parseDate: this.parseDate,
                      prevArrow: this.prevArrow,
                      shorthandCurrentMonth: this.shorthandCurrentMonth,
                      showMonths: this.showMonths,
                      monthSelectorType: this.monthSelectorType,
                      static: this.static,
                      time24hr: this.time24hr,
                      weekNumbers: this.weekNumbers,
                      getWeek: this.getWeek,
                      wrap: this.wrap,
                      plugins: this.plugins,
                      locale: this.locale,
                      onChange: function (selectedDates, dateString, instance) {
                          _this.flatpickrChange.emit({ selectedDates: selectedDates, dateString: dateString, instance: instance });
                      },
                      onOpen: function (selectedDates, dateString, instance) {
                          _this.flatpickrOpen.emit({ selectedDates: selectedDates, dateString: dateString, instance: instance });
                      },
                      onClose: function (selectedDates, dateString, instance) {
                          _this.flatpickrClose.emit({ selectedDates: selectedDates, dateString: dateString, instance: instance });
                      },
                      onMonthChange: function (selectedDates, dateString, instance) {
                          _this.flatpickrMonthChange.emit({ selectedDates: selectedDates, dateString: dateString, instance: instance });
                      },
                      onYearChange: function (selectedDates, dateString, instance) {
                          _this.flatpickrYearChange.emit({ selectedDates: selectedDates, dateString: dateString, instance: instance });
                      },
                      onReady: function (selectedDates, dateString, instance) {
                          _this.flatpickrReady.emit({ selectedDates: selectedDates, dateString: dateString, instance: instance });
                      },
                      onValueUpdate: function (selectedDates, dateString, instance) {
                          _this.flatpickrValueUpdate.emit({ selectedDates: selectedDates, dateString: dateString, instance: instance });
                      },
                      onDayCreate: function (selectedDates, dateString, instance, dayElement) {
                          _this.flatpickrDayCreate.emit({
                              selectedDates: selectedDates,
                              dateString: dateString,
                              instance: instance,
                              dayElement: dayElement
                          });
                      }
                  };
                  Object.keys(options).forEach(function (key) {
                      if (typeof options[key] === 'undefined') {
                          if (typeof _this.options[key] !== 'undefined') {
                              options[key] = ((_this.options))[key];
                          }
                          else {
                              options[key] = ((_this.defaults))[key];
                          }
                      }
                  });
                  options.time_24hr = options.time24hr;
                  // workaround bug in flatpickr 4.6 where it doesn't copy the classes across
                  // TODO - remove once fix in https://github.com/flatpickr/flatpickr/issues/1860 is released
                  options.altInputClass =
                      (options.altInputClass || '') + ' ' + this.elm.nativeElement.className;
                  this.instance = /** @type {?} */ (flatpickr(this.elm.nativeElement, options));
                  this.setDisabledState(this.isDisabled);
              };
          /**
           * @param {?} changes
           * @return {?}
           */
          FlatpickrDirective.prototype.ngOnChanges = /**
           * @param {?} changes
           * @return {?}
           */
              function (changes) {
                  var _this = this;
                  if (this.instance) {
                      Object.keys(changes).forEach(function (inputKey) {
                          _this.instance.set(/** @type {?} */ (inputKey), ((_this))[inputKey]);
                      });
                  }
              };
          /**
           * @return {?}
           */
          FlatpickrDirective.prototype.ngOnDestroy = /**
           * @return {?}
           */
              function () {
                  if (this.instance) {
                      this.instance.destroy();
                  }
              };
          /**
           * @param {?} value
           * @return {?}
           */
          FlatpickrDirective.prototype.writeValue = /**
           * @param {?} value
           * @return {?}
           */
              function (value) {
                  var /** @type {?} */ convertedValue = value;
                  if (this.convertModelValue && this.mode === 'range' && value) {
                      convertedValue = [value.from, value.to];
                  }
                  if (this.instance) {
                      this.instance.setDate(convertedValue);
                  }
                  else {
                      // flatpickr hasn't been initialised yet, store the value for later use
                      this.initialValue = convertedValue;
                  }
              };
          /**
           * @param {?} fn
           * @return {?}
           */
          FlatpickrDirective.prototype.registerOnChange = /**
           * @param {?} fn
           * @return {?}
           */
              function (fn) {
                  this.onChangeFn = fn;
              };
          /**
           * @param {?} fn
           * @return {?}
           */
          FlatpickrDirective.prototype.registerOnTouched = /**
           * @param {?} fn
           * @return {?}
           */
              function (fn) {
                  this.onTouchedFn = fn;
              };
          /**
           * @param {?} isDisabled
           * @return {?}
           */
          FlatpickrDirective.prototype.setDisabledState = /**
           * @param {?} isDisabled
           * @return {?}
           */
              function (isDisabled) {
                  this.isDisabled = isDisabled;
                  if (this.instance) {
                      if (this.isDisabled) {
                          this.renderer.setProperty(this.instance._input, 'disabled', 'disabled');
                      }
                      else {
                          this.renderer.removeAttribute(this.instance._input, 'disabled');
                      }
                  }
              };
          /**
           * @return {?}
           */
          FlatpickrDirective.prototype.inputChanged = /**
           * @return {?}
           */
              function () {
                  var _this = this;
                  var /** @type {?} */ value = this.elm.nativeElement.value;
                  if (this.convertModelValue && typeof value === 'string') {
                      switch (this.mode) {
                          case 'multiple':
                              var /** @type {?} */ dates = value
                                  .split('; ')
                                  .map(function (str) {
                                  return _this.instance.parseDate(str, _this.instance.config.dateFormat, !_this.instance.config.enableTime);
                              });
                              this.onChangeFn(dates);
                              break;
                          case 'range':
                              var _a = __read(value
                                  .split(this.instance.l10n.rangeSeparator)
                                  .map(function (str) {
                                  return _this.instance.parseDate(str, _this.instance.config.dateFormat, !_this.instance.config.enableTime);
                              }), 2), from = _a[0], to = _a[1];
                              this.onChangeFn({ from: from, to: to });
                              break;
                          case 'single':
                          default:
                              this.onChangeFn(this.instance.parseDate(value, this.instance.config.dateFormat, !this.instance.config.enableTime));
                      }
                  }
                  else {
                      this.onChangeFn(value);
                  }
              };
          /** @nocollapse */
          FlatpickrDirective.ctorParameters = function () {
              return [
                  { type: core.ElementRef },
                  { type: FlatpickrDefaults },
                  { type: core.Renderer2 }
              ];
          };
          FlatpickrDirective.propDecorators = {
              options: [{ type: core.Input }],
              altFormat: [{ type: core.Input }],
              altInput: [{ type: core.Input }],
              altInputClass: [{ type: core.Input }],
              allowInput: [{ type: core.Input }],
              appendTo: [{ type: core.Input }],
              ariaDateFormat: [{ type: core.Input }],
              clickOpens: [{ type: core.Input }],
              dateFormat: [{ type: core.Input }],
              defaultHour: [{ type: core.Input }],
              defaultMinute: [{ type: core.Input }],
              defaultSeconds: [{ type: core.Input }],
              disable: [{ type: core.Input }],
              disableMobile: [{ type: core.Input }],
              enable: [{ type: core.Input }],
              enableTime: [{ type: core.Input }],
              enableSeconds: [{ type: core.Input }],
              formatDate: [{ type: core.Input }],
              hourIncrement: [{ type: core.Input }],
              inline: [{ type: core.Input }],
              maxDate: [{ type: core.Input }],
              minDate: [{ type: core.Input }],
              minuteIncrement: [{ type: core.Input }],
              mode: [{ type: core.Input }],
              nextArrow: [{ type: core.Input }],
              noCalendar: [{ type: core.Input }],
              now: [{ type: core.Input }],
              parseDate: [{ type: core.Input }],
              prevArrow: [{ type: core.Input }],
              shorthandCurrentMonth: [{ type: core.Input }],
              showMonths: [{ type: core.Input }],
              static: [{ type: core.Input }],
              time24hr: [{ type: core.Input }],
              weekNumbers: [{ type: core.Input }],
              getWeek: [{ type: core.Input }],
              wrap: [{ type: core.Input }],
              plugins: [{ type: core.Input }],
              locale: [{ type: core.Input }],
              convertModelValue: [{ type: core.Input }],
              monthSelectorType: [{ type: core.Input }],
              flatpickrReady: [{ type: core.Output }],
              flatpickrChange: [{ type: core.Output }],
              flatpickrValueUpdate: [{ type: core.Output }],
              flatpickrOpen: [{ type: core.Output }],
              flatpickrClose: [{ type: core.Output }],
              flatpickrMonthChange: [{ type: core.Output }],
              flatpickrYearChange: [{ type: core.Output }],
              flatpickrDayCreate: [{ type: core.Output }],
              inputChanged: [{ type: core.HostListener, args: ['input',] }]
          };
  FlatpickrDirective.ɵfac = function FlatpickrDirective_Factory(t) { return new (t || FlatpickrDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(FlatpickrDefaults), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Renderer2)); };
  FlatpickrDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: FlatpickrDirective, selectors: [["", "mwlFlatpickr", ""]], hostBindings: function FlatpickrDirective_HostBindings(rf, ctx) { if (rf & 1) {
          ɵngcc0.ɵɵlistener("blur", function FlatpickrDirective_blur_HostBindingHandler() { return ctx.onTouchedFn(); })("input", function FlatpickrDirective_input_HostBindingHandler() { return ctx.inputChanged(); });
      } }, inputs: { options: "options", altFormat: "altFormat", altInput: "altInput", altInputClass: "altInputClass", allowInput: "allowInput", appendTo: "appendTo", ariaDateFormat: "ariaDateFormat", clickOpens: "clickOpens", dateFormat: "dateFormat", defaultHour: "defaultHour", defaultMinute: "defaultMinute", defaultSeconds: "defaultSeconds", disable: "disable", disableMobile: "disableMobile", enable: "enable", enableTime: "enableTime", enableSeconds: "enableSeconds", formatDate: "formatDate", hourIncrement: "hourIncrement", inline: "inline", maxDate: "maxDate", minDate: "minDate", minuteIncrement: "minuteIncrement", mode: "mode", nextArrow: "nextArrow", noCalendar: "noCalendar", now: "now", parseDate: "parseDate", prevArrow: "prevArrow", shorthandCurrentMonth: "shorthandCurrentMonth", showMonths: "showMonths", static: "static", time24hr: "time24hr", weekNumbers: "weekNumbers", getWeek: "getWeek", wrap: "wrap", plugins: "plugins", locale: "locale", convertModelValue: "convertModelValue", monthSelectorType: "monthSelectorType" }, outputs: { flatpickrReady: "flatpickrReady", flatpickrChange: "flatpickrChange", flatpickrValueUpdate: "flatpickrValueUpdate", flatpickrOpen: "flatpickrOpen", flatpickrClose: "flatpickrClose", flatpickrMonthChange: "flatpickrMonthChange", flatpickrYearChange: "flatpickrYearChange", flatpickrDayCreate: "flatpickrDayCreate" }, features: [ɵngcc0.ɵɵProvidersFeature([FLATPICKR_CONTROL_VALUE_ACCESSOR]), ɵngcc0.ɵɵNgOnChangesFeature] });
  /*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(FlatpickrDirective, [{
          type: core.Directive,
          args: [{
                  selector: '[mwlFlatpickr]',
                  providers: [FLATPICKR_CONTROL_VALUE_ACCESSOR],
                  host: {
                      // tslint:disable-line use-host-property-decorator
                      '(blur)': 'onTouchedFn()'
                  }
              }]
      }], function () { return [{ type: ɵngcc0.ElementRef }, { type: FlatpickrDefaults }, { type: ɵngcc0.Renderer2 }]; }, { options: [{
              type: core.Input
          }], flatpickrReady: [{
              type: core.Output
          }], flatpickrChange: [{
              type: core.Output
          }], flatpickrValueUpdate: [{
              type: core.Output
          }], flatpickrOpen: [{
              type: core.Output
          }], flatpickrClose: [{
              type: core.Output
          }], flatpickrMonthChange: [{
              type: core.Output
          }], flatpickrYearChange: [{
              type: core.Output
          }], flatpickrDayCreate: [{
              type: core.Output
          }], inputChanged: [{
              type: core.HostListener,
              args: ['input']
          }], altFormat: [{
              type: core.Input
          }], altInput: [{
              type: core.Input
          }], altInputClass: [{
              type: core.Input
          }], allowInput: [{
              type: core.Input
          }], appendTo: [{
              type: core.Input
          }], ariaDateFormat: [{
              type: core.Input
          }], clickOpens: [{
              type: core.Input
          }], dateFormat: [{
              type: core.Input
          }], defaultHour: [{
              type: core.Input
          }], defaultMinute: [{
              type: core.Input
          }], defaultSeconds: [{
              type: core.Input
          }], disable: [{
              type: core.Input
          }], disableMobile: [{
              type: core.Input
          }], enable: [{
              type: core.Input
          }], enableTime: [{
              type: core.Input
          }], enableSeconds: [{
              type: core.Input
          }], formatDate: [{
              type: core.Input
          }], hourIncrement: [{
              type: core.Input
          }], inline: [{
              type: core.Input
          }], maxDate: [{
              type: core.Input
          }], minDate: [{
              type: core.Input
          }], minuteIncrement: [{
              type: core.Input
          }], mode: [{
              type: core.Input
          }], nextArrow: [{
              type: core.Input
          }], noCalendar: [{
              type: core.Input
          }], now: [{
              type: core.Input
          }], parseDate: [{
              type: core.Input
          }], prevArrow: [{
              type: core.Input
          }], shorthandCurrentMonth: [{
              type: core.Input
          }], showMonths: [{
              type: core.Input
          }], static: [{
              type: core.Input
          }], time24hr: [{
              type: core.Input
          }], weekNumbers: [{
              type: core.Input
          }], getWeek: [{
              type: core.Input
          }], wrap: [{
              type: core.Input
          }], plugins: [{
              type: core.Input
          }], locale: [{
              type: core.Input
          }], convertModelValue: [{
              type: core.Input
          }], monthSelectorType: [{
              type: core.Input
          }] }); })();
          return FlatpickrDirective;
      }());
  
      /**
       * @fileoverview added by tsickle
       * @suppress {checkTypes} checked by tsc
       */
      var /** @type {?} */ USER_DEFAULTS = new core.InjectionToken('flatpickr defaults');
      /**
       * @param {?} userDefaults
       * @return {?}
       */
      function defaultsFactory(userDefaults) {
          var /** @type {?} */ defaults = new FlatpickrDefaults();
          Object.assign(defaults, userDefaults);
          return defaults;
      }
      var FlatpickrModule = (function () {
          function FlatpickrModule() {
          }
          /**
           * @param {?=} userDefaults
           * @return {?}
           */
          FlatpickrModule.forRoot = /**
           * @param {?=} userDefaults
           * @return {?}
           */
              function (userDefaults) {
                  if (userDefaults === void 0) {
                      userDefaults = {};
                  }
                  return {
                      ngModule: FlatpickrModule,
                      providers: [
                          {
                              provide: USER_DEFAULTS,
                              useValue: userDefaults
                          },
                          {
                              provide: FlatpickrDefaults,
                              useFactory: defaultsFactory,
                              deps: [USER_DEFAULTS]
                          }
                      ]
                  };
              };
  FlatpickrModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: FlatpickrModule });
  FlatpickrModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function FlatpickrModule_Factory(t) { return new (t || FlatpickrModule)(); } });
  (function () { (typeof ngJitMode === "undefined" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(FlatpickrModule, { declarations: [FlatpickrDirective], exports: [FlatpickrDirective] }); })();
  /*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(FlatpickrModule, [{
          type: core.NgModule,
          args: [{
                  declarations: [FlatpickrDirective],
                  exports: [FlatpickrDirective]
              }]
      }], function () { return []; }, null); })();
          return FlatpickrModule;
      }());
  
      /**
       * @fileoverview added by tsickle
       * @suppress {checkTypes} checked by tsc
       */
  
      /**
       * @fileoverview added by tsickle
       * @suppress {checkTypes} checked by tsc
       */
  
      exports.FlatpickrDefaults = FlatpickrDefaults;
      exports.FlatpickrDirective = FlatpickrDirective;
      exports.USER_DEFAULTS = USER_DEFAULTS;
      exports.defaultsFactory = defaultsFactory;
      exports.FlatpickrModule = FlatpickrModule;
      exports.ɵa = FLATPICKR_CONTROL_VALUE_ACCESSOR;
  
      Object.defineProperty(exports, '__esModule', { value: true });
  
  })));
  //# sourceMappingURL=angularx-flatpickr.umd.js.map