"use strict";

var _typeof = typeof symbol === "function" && typeof symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof symbol === "function" && obj.constructor === symbol ? "symbol" : typeof obj; };

/*! flatpickr v2.0, @license mit */
function flatpickr(element, config) {
	var self = this;

	function init() {
		self.element = element;
		self.instanceconfig = config || {};

		self.ismobile = /android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(navigator.useragent);

		setupformats();

		parseconfig();
		setupinputs();
		setupdates();

		setuphelperfunctions();

		self.changemonth = changemonth;
		self.clear = clear;
		self.close = close;
		self.destroy = destroy;
		self.formatdate = formatdate;
		self.jumptodate = jumptodate;
		self.open = open;
		self.parsedate = parsedate;
		self.redraw = redraw;
		self.set = set;
		self.setdate = setdate;
		self.toggle = toggle;

		if (self.ismobile && !self.config.disablemobile) {
			bind();
			setupmobile();
		} else {
			build();
			bind();
		}

		if (self.selecteddateobj) updatevalue();

		triggerevent("ready");
	}

	function updatetime(e) {
		timewrapper(e);
		updatevalue(e);
	}

	function bind() {
		if (self.config.wrap) {
			["open", "close", "toggle", "clear"].foreach(function (el) {
				try {
					self.element.queryselector("[data-" + el + "]").addeventlistener("click", self[el]);
				} catch (e) {
					//
				}
			});
		}

		if (self.ismobile) return;

		document.addeventlistener("keydown", onkeydown);
		window.addeventlistener("resize", debounce(onresize, 300));

		document.addeventlistener("click", documentclick);
		document.addeventlistener("blur", documentclick);

		if (self.config.clickopens) (self.altinput || self.input).addeventlistener("focus", open);

		if (!self.config.nocalendar) {
			self.prevmonthnav.addeventlistener("click", function () {
				return changemonth(-1);
			});
			self.nextmonthnav.addeventlistener("click", function () {
				return changemonth(1);
			});

			self.currentyearelement.addeventlistener("wheel", yearscroll);
			self.currentyearelement.addeventlistener("focus", function () {
				self.currentyearelement.select();
			});

			self.currentyearelement.addeventlistener("input", function (event) {
				if (event.target.value.length === 4) self.currentyearelement.blur();

				self.currentyear = parseint(event.target.value, 10) || self.currentyear;
				self.redraw();
			});

			self.days.addeventlistener("click", selectdate);
		}

		if (self.config.enabletime) {
			self.timecontainer.addeventlistener("wheel", updatetime);
			self.timecontainer.addeventlistener("wheel", debounce(function () {
				return triggerevent("change");
			}, 1000));
			self.timecontainer.addeventlistener("input", updatetime);

			self.hourelement.addeventlistener("focus", function () {
				return self.hourelement.select();
			});
			self.minuteelement.addeventlistener("focus", function () {
				return self.minuteelement.select();
			});

			if (self.secondelement) self.secondelement.addeventlistener("focus", function () {
				return self.secondelement.select();
			});

			if (self.ampm) self.ampm.addeventlistener("click", updatetime);
		}
	}

	function jumptodate(jumpdate) {
		jumpdate = jumpdate ? parsedate(jumpdate) : self.selecteddateobj || self.config.defaultdate || self.config.mindate || self.now;

		self.currentyear = jumpdate.getfullyear();
		self.currentmonth = jumpdate.getmonth();
		self.redraw();
	}

	function build() {
		var fragment = document.createdocumentfragment();
		self.calendarcontainer = createelement("div", "flatpickr-calendar");

		if (!self.config.nocalendar) {
			fragment.appendchild(buildmonthnav());

			if (self.config.weeknumbers) fragment.appendchild(buildweeks());

			self.rcontainer = createelement("div", "flatpickr-rcontainer");
			self.rcontainer.appendchild(buildweekdays());
			self.rcontainer.appendchild(builddays());
			fragment.appendchild(self.rcontainer);
		}

		if (self.config.enabletime) fragment.appendchild(buildtime());

		self.calendarcontainer.appendchild(fragment);

		if (self.config.inline || self.config.static) {
			self.calendarcontainer.classlist.add(self.config.inline ? "inline" : "static");
			positioncalendar();
			self.element.parentnode.appendchild(self.calendarcontainer);
		} else document.body.appendchild(self.calendarcontainer);
	}

	function builddays() {
		if (!self.days) {
			self.days = createelement("div", "flatpickr-days");
			self.days.tabindex = -1;
		}

		var firstofmonth = (new date(self.currentyear, self.currentmonth, 1).getday() - flatpickr.l10n.firstdayofweek + 7) % 7,
		    daysinmonth = self.utils.getdaysinmonth(),
		    prevmonthdays = self.utils.getdaysinmonth((self.currentmonth - 1 + 12) % 12),
		    days = document.createdocumentfragment();

		var daynumber = prevmonthdays + 1 - firstofmonth,
		    currentdate = void 0,
		    dateisdisabled = void 0;

		if (self.config.weeknumbers) self.weeknumbers.innerhtml = "";

		self.days.innerhtml = "";

		// prepend days from the ending of previous month
		for (; daynumber <= prevmonthdays; daynumber++) {
			var curdate = new date(self.currentyear, self.currentmonth - 1, daynumber, 0, 0, 0, 0, 0),
			    dateisenabled = isenabled(curdate),
			    dayelem = createelement("span", "flatpickr-day prevmonthday" + (dateisenabled ? "" : " disabled"), daynumber);

			if (dateisenabled) dayelem.tabindex = 0;

			days.appendchild(dayelem);
		}

		// start at 1 since there is no 0th day
		for (daynumber = 1; daynumber <= daysinmonth; daynumber++) {
			currentdate = new date(self.currentyear, self.currentmonth, daynumber, 0, 0, 0, 0, 0);

			if (self.config.weeknumbers && daynumber % 7 === 1) {
				self.weeknumbers.insertadjacenthtml("beforeend", "<span class='disabled flatpickr-day'>" + self.getweek(currentdate) + "</span>");
			}

			dateisdisabled = !isenabled(currentdate);

			var dayelement = createelement("span", dateisdisabled ? "flatpickr-day disabled" : "flatpickr-day", daynumber);

			if (!dateisdisabled) {
				dayelement.tabindex = 0;

				if (equaldates(currentdate, new date())) dayelement.classlist.add("today");

				if (self.selecteddateobj && equaldates(currentdate, self.selecteddateobj)) {
					dayelement.classlist.add("selected");
					self.selecteddateelem = dayelement;
				}
			}

			days.appendchild(dayelement);
		}

		// append days from the next month
		for (var daynum = daysinmonth + 1; daynum <= 42 - firstofmonth; daynum++) {
			var _curdate = new date(self.currentyear, self.currentmonth + 1, daynum % daysinmonth, 0, 0, 0, 0, 0),
			    _dateisenabled = isenabled(_curdate),
			    _dayelement = createelement("span", "flatpickr-day nextmonthday" + (_dateisenabled ? "" : " disabled"), daynum % daysinmonth);

			if (self.config.weeknumbers && daynum % 7 === 1) {
				self.weeknumbers.insertadjacenthtml("beforeend", "<span class='disabled flatpickr-day'>" + self.getweek(_curdate) + "</span>");
			}

			if (_dateisenabled) _dayelement.tabindex = 0;

			days.appendchild(_dayelement);
		}
		self.days.appendchild(days);
		return self.days;
	}

	function buildmonthnav() {
		var monthnavfragment = document.createdocumentfragment();
		self.monthnav = createelement("div", "flatpickr-month");

		self.prevmonthnav = createelement("span", "flatpickr-prev-month");
		self.prevmonthnav.innerhtml = self.config.prevarrow;

		self.currentmonthelement = createelement("span", "cur_month");

		self.currentyearelement = createelement("input", "cur_year");
		self.currentyearelement.type = "number";
		self.currentyearelement.title = flatpickr.l10n.scrolltitle;

		self.nextmonthnav = createelement("span", "flatpickr-next-month");
		self.nextmonthnav.innerhtml = self.config.nextarrow;

		self.navigationcurrentmonth = createelement("span", "flatpickr-current-month");
		self.navigationcurrentmonth.appendchild(self.currentmonthelement);
		self.navigationcurrentmonth.appendchild(self.currentyearelement);

		monthnavfragment.appendchild(self.prevmonthnav);
		monthnavfragment.appendchild(self.navigationcurrentmonth);
		monthnavfragment.appendchild(self.nextmonthnav);
		self.monthnav.appendchild(monthnavfragment);

		updatenavigationcurrentmonth();

		return self.monthnav;
	}

	function buildtime() {
		self.calendarcontainer.classlist.add("hastime");
		self.timecontainer = createelement("div", "flatpickr-time");
		self.timecontainer.tabindex = -1;
		var separator = createelement("span", "flatpickr-time-separator", ":");

		self.hourelement = createelement("input", "flatpickr-hour");
		self.minuteelement = createelement("input", "flatpickr-minute");

		self.hourelement.tabindex = self.minuteelement.tabindex = 0;
		self.hourelement.type = self.minuteelement.type = "number";

		self.hourelement.value = self.selecteddateobj ? pad(self.selecteddateobj.gethours()) : 12;

		self.minuteelement.value = self.selecteddateobj ? pad(self.selecteddateobj.getminutes()) : "00";

		self.hourelement.step = self.config.hourincrement;
		self.minuteelement.step = self.config.minuteincrement;

		self.hourelement.min = -(self.config.time_24hr ? 1 : 0);
		self.hourelement.max = self.config.time_24hr ? 24 : 13;

		self.minuteelement.min = -self.minuteelement.step;
		self.minuteelement.max = 60;

		self.hourelement.title = self.minuteelement.title = flatpickr.l10n.scrolltitle;

		self.timecontainer.appendchild(self.hourelement);
		self.timecontainer.appendchild(separator);
		self.timecontainer.appendchild(self.minuteelement);

		if (self.config.enableseconds) {
			self.timecontainer.classlist.add("has-seconds");

			self.secondelement = createelement("input", "flatpickr-second");
			self.secondelement.type = "number";
			self.secondelement.value = self.selecteddateobj ? pad(self.selecteddateobj.getseconds()) : "00";

			self.secondelement.step = self.minuteelement.step;
			self.secondelement.min = self.minuteelement.min;
			self.secondelement.max = self.minuteelement.max;

			self.timecontainer.appendchild(createelement("span", "flatpickr-time-separator", ":"));
			self.timecontainer.appendchild(self.secondelement);
		}

		if (!self.config.time_24hr) {
			// add self.ampm if appropriate
			self.ampm = createelement("span", "flatpickr-am-pm", ["am", "pm"][self.hourelement.value > 11 | 0]);
			self.ampm.title = flatpickr.l10n.toggletitle;
			self.ampm.tabindex = 0;
			self.timecontainer.appendchild(self.ampm);
		}

		return self.timecontainer;
	}

	function buildweekdays() {
		if (!self.weekdaycontainer) self.weekdaycontainer = createelement("div", "flatpickr-weekdays");

		var firstdayofweek = flatpickr.l10n.firstdayofweek;
		var weekdays = flatpickr.l10n.weekdays.shorthand.slice();

		if (firstdayofweek > 0 && firstdayofweek < weekdays.length) {
			weekdays = [].concat(weekdays.splice(firstdayofweek, weekdays.length), weekdays.splice(0, firstdayofweek));
		}

		self.weekdaycontainer.innerhtml = "<span class=flatpickr-weekday>" + weekdays.join("</span><span class=flatpickr-weekday>") + "</span>";

		return self.weekdaycontainer;
	}

	function buildweeks() {
		self.calendarcontainer.classlist.add("hasweeks");
		self.weekwrapper = createelement("div", "flatpickr-weekwrapper");
		self.weekwrapper.appendchild(createelement("span", "flatpickr-weekday", flatpickr.l10n.weekabbreviation));
		self.weeknumbers = createelement("div", "flatpickr-weeks");
		self.weekwrapper.appendchild(self.weeknumbers);
		return self.weekwrapper;
	}

	function changemonth(offset) {
		self.currentmonth += offset;

		handleyearchange();
		updatenavigationcurrentmonth();
		builddays();
		(self.config.nocalendar ? self.timecontainer : self.days).focus();
	}

	function clear() {
		self.input.value = "";

		if (self.altinput) self.altinput.value = "";

		self.selecteddateobj = null;

		triggerevent("change");
		jumptodate(self.now);
	}

	function close() {
		self.isopen = false;
		self.calendarcontainer.classlist.remove("open");
		(self.altinput || self.input).classlist.remove("active");

		triggerevent("close");
	}

	function destroy() {
		self.calendarcontainer.parentnode.removechild(self.calendarcontainer);
		self.input.value = "";
		if (self.altinput) {
			self.input.type = "text";
			self.altinput.parentnode.removechild(self.altinput);
		}

		document.removeeventlistener("keydown", onkeydown);
		window.removeeventlistener("resize", onresize);

		document.removeeventlistener("click", documentclick);
		document.removeeventlistener("blur", documentclick);

		delete self.input._flatpickr;
	}

	function documentclick(e) {
		var iscalendarelement = self.calendarcontainer.contains(e.target),
		    isinput = self.element.contains(e.target) || e.target === self.altinput;

		if (self.isopen && !iscalendarelement && !isinput) self.close();
	}

	function formatdate(frmt, dateobj) {
		var chars = frmt.split("");
		return chars.map(function (c, i) {
			return self.formats[c] && chars[i - 1] !== "\\" ? self.formats[c](dateobj) : c !== "\\" ? c : "";
		}).join("");
	}

	function handleyearchange() {
		if (self.currentmonth < 0 || self.currentmonth > 11) {
			self.currentyear += self.currentmonth % 11;
			self.currentmonth = (self.currentmonth + 12) % 12;
		}
	}

	function isenabled(datetocheck) {
		if (self.config.mindate && datetocheck < self.config.mindate || self.config.maxdate && datetocheck > self.config.maxdate) return false;

		if (!self.config.enable.length && !self.config.disable.length) return true;

		datetocheck = parsedate(datetocheck, true); // timeless

		var bool = self.config.enable.length > 0,
		    array = bool ? self.config.enable : self.config.disable;

		var d = void 0;

		for (var i = 0; i < array.length; i++) {
			d = array[i];

			if (d instanceof function && d(datetocheck)) // disabled by function
				return bool;else if ((d instanceof date || typeof d === "string") && parsedate(d, true).gettime() === datetocheck.gettime())
				// disabled by date string
				return bool;else if ( // disabled by range
			(typeof d === "undefined" ? "undefined" : _typeof(d)) === "object" && d.hasownproperty("from") && datetocheck >= parsedate(d.from) && datetocheck <= parsedate(d.to)) return bool;
		}

		return !bool;
	}

	function onkeydown(e) {
		if (!self.isopen) return;

		switch (e.which) {
			case 13:
				if (self.timecontainer && self.timecontainer.contains(e.target)) updatevalue(e);else selectdate(e);

				break;

			case 27:
				self.close();
				break;

			case 37:
				if (e.target !== self.input & e.target !== self.altinput) changemonth(-1);
				break;

			case 38:
				e.preventdefault();

				if (self.timecontainer.contains(e.target)) updatetime(e);else {
					self.currentyear++;
					self.redraw();
				}

				break;

			case 39:
				if (e.target !== self.input & e.target !== self.altinput) changemonth(1);
				break;

			case 40:
				e.preventdefault();
				if (self.timecontainer.contains(e.target)) updatetime(e);else {
					self.currentyear--;
					self.redraw();
				}

				break;

			default:
				break;
		}
	}

	function onresize() {
		if (self.isopen && !self.config.inline && !self.config.static) positioncalendar();
	}

	function open(e) {
		if (self.ismobile) {
			e.preventdefault();
			e.target.blur();

			settimeout(function () {
				self.mobileinput.click();
			}, 0);

			triggerevent("open");
			return;
		} else if (self.isopen || (self.altinput || self.input).disabled || self.config.inline) return;

		self.calendarcontainer.classlist.add("open");

		if (!self.config.static) positioncalendar();

		self.isopen = true;

		if (!self.config.allowinput) {
			(self.altinput || self.input).blur();
			(self.config.nocalendar ? self.timecontainer : self.selecteddateobj ? self.selecteddateelem : self.days).focus();
		}

		(self.altinput || self.input).classlist.add("active");
		triggerevent("open");
	}

	function pad(number) {
		return ("0" + number).slice(-2);
	}

	function parseconfig() {
		self.config = self.instanceconfig;

		object.keys(self.element.dataset).foreach(function (k) {
			return self.config[k] = typeof flatpickr.defaultconfig[k] === "boolean" ? self.element.dataset[k] !== "false" : self.element.dataset[k];
		});

		if (!self.config.dateformat && self.config.enabletime) {
			self.config.dateformat = flatpickr.defaultconfig.dateformat;
			if (self.config.nocalendar) {
				// time picker
				self.config.dateformat = "h:i" + (self.config.enableseconds ? ":s" : "");
				self.config.altformat = "h:i" + (self.config.enableseconds ? ":s k" : " k");
			} else {
				self.config.dateformat += " h:i" + (self.config.enableseconds ? ":s" : "");
				self.config.altformat = "h:i" + (self.config.enableseconds ? ":s" : "") + " k";
			}
		}
		object.keys(flatpickr.defaultconfig).foreach(function (k) {
			return self.config[k] = typeof self.config[k] !== "undefined" ? self.config[k] : flatpickr.defaultconfig[k];
		});
	}

	function parsedate(date) {
		var timeless = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];

		if (typeof date === "string") {
			date = date.trim();

			if (date === "today") {
				date = new date();
				timeless = true;
			} else if (self.config.parsedate) date = self.config.parsedate(date);else if (/^\d\d:\d\d/.test(date)) {
				// time picker
				var m = date.match(/^(\d{1,2})[:\s]?(\d\d)?[:\s]?(\d\d)?/);
				date = new date();
				date.sethours(m[1], m[2] || 0, m[2] || 0);
			} else if (/z$/.test(date) || /gmt$/.test(date)) // datestrings w/ timezone
				date = new date(date);else if (/(\d+)/g.test(date)) {
				var d = date.match(/(\d+)/g);
				date = new date(d[0] + "/" + (d[1] || 1) + "/" + (d[2] || 1) + " " + (d[3] || 0) + ":" + (d[4] || 0) + ":" + (d[5] || 0));
			}
		}

		if (!(date instanceof date) || !date.gettime()) {
			console.warn("flatpickr: invalid date " + date);
			console.info(self.element);
			return null;
		}

		if (self.config.utc && !date.fp_isutc) date = date.fp_toutc();

		if (timeless) date.sethours(0, 0, 0, 0);

		return date;
	}

	function positioncalendar() {
		var calendarheight = self.calendarcontainer.offsetheight,
		    input = self.altinput || self.input,
		    inputbounds = input.getboundingclientrect(),
		    distancefrombottom = window.innerheight - inputbounds.bottom + input.offsetheight;

		var top = void 0,
		    left = window.pagexoffset + inputbounds.left;

		if (distancefrombottom < calendarheight) {
			top = window.pageyoffset - calendarheight + inputbounds.top - 2;
			self.calendarcontainer.classlist.remove("arrowtop");
			self.calendarcontainer.classlist.add("arrowbottom");
		} else {
			top = window.pageyoffset + input.offsetheight + inputbounds.top + 10;
			self.calendarcontainer.classlist.remove("arrowbottom");
			self.calendarcontainer.classlist.add("arrowtop");
		}

		if (!self.config.inline) {
			self.calendarcontainer.style.top = top + "px";
			self.calendarcontainer.style.left = left + "px";
		}
	}

	function redraw() {
		if (self.config.nocalendar || self.ismobile) return;

		buildweekdays();
		updatenavigationcurrentmonth();
		builddays();
	}

	function selectdate(e) {
		e.preventdefault();
		e.stoppropagation();

		if (self.config.allowinput && (e.target === self.altinput || e.target === self.input) && e.which === 13) self.setdate((self.altinput || self.input).value);else if (e.target.classlist.contains("flatpickr-day") && !e.target.classlist.contains("disabled")) {
			var isprevmonthday = e.target.classlist.contains("prevmonthday"),
			    isnextmonthday = e.target.classlist.contains("nextmonthday");

			if (isprevmonthday || isnextmonthday) changemonth(+isnextmonthday - isprevmonthday);

			self.selecteddateobj = parsedate(new date(self.currentyear, self.currentmonth, e.target.innerhtml));

			updatevalue(e);
			builddays();
			triggerevent("change");

			if (!self.config.enabletime) self.close();
		}
	}

	function set(option, value) {
		self.config[option] = value;
		jumptodate();
	}

	function setdate(date, triggerchange) {
		date = parsedate(date);
		if (date instanceof date && date.gettime()) {
			self.selecteddateobj = date;
			jumptodate(self.selecteddateobj);
			updatevalue(false);

			if (triggerchange) triggerevent("change");
		} else (self.altinput || self.input).value = "";
	}

	function setupdates() {
		self.now = new date();

		if (self.config.defaultdate || self.input.value) self.selecteddateobj = parsedate(self.config.defaultdate || self.input.value);

		if (self.config.mindate) self.config.mindate = parsedate(self.config.mindate, true);

		if (self.config.maxdate) self.config.maxdate = parsedate(self.config.maxdate, true);

		var initialdate = self.selecteddateobj || self.config.defaultdate || self.config.mindate || new date();

		self.currentyear = initialdate.getfullyear();
		self.currentmonth = initialdate.getmonth();
	}

	function setupformats() {
		self.formats = {
			// weekday name, short, e.g. thu
			d: function d(date) {
				return flatpickr.l10n.weekdays.shorthand[self.formats.w(date)];
			},

			// full month name e.g. january
			f: function f(date) {
				return self.utils.monthtostr(self.formats.n(date) - 1, false);
			},

			// hours with leading zero e.g. 03
			h: function h(date) {
				return pad(date.gethours());
			},

			// day (1-30) with ordinal suffix e.g. 1st, 2nd
			j: function j(date) {
				return date.getdate() + flatpickr.l10n.ordinal(date.getdate());
			},

			// am/pm
			k: function k(date) {
				return date.gethours() > 11 ? "pm" : "am";
			},

			// shorthand month e.g. jan, sep, oct, etc
			m: function m(date) {
				return self.utils.monthtostr(date.getmonth(), true);
			},

			// seconds 00-59
			s: function s(date) {
				return pad(date.getseconds());
			},

			// unix timestamp
			u: function u(date) {
				return date.gettime() / 1000;
			},

			// full year e.g. 2016
			y: function y(date) {
				return date.getfullyear();
			},

			// day in month, padded (01-30)
			d: function d(date) {
				return pad(self.formats.j(date));
			},

			// hour from 1-12 (am/pm)
			h: function h(date) {
				return date.gethours() % 12 ? date.gethours() % 12 : 12;
			},

			// minutes, padded with leading zero e.g. 09
			i: function i(date) {
				return pad(date.getminutes());
			},

			// day in month (1-30)
			j: function j(date) {
				return date.getdate();
			},

			// weekday name, full, e.g. thursday
			l: function l(date) {
				return flatpickr.l10n.weekdays.longhand[self.formats.w(date)];
			},

			// padded month number (01-12)
			m: function m(date) {
				return pad(self.formats.n(date));
			},

			// the month number (1-12)
			n: function n(date) {
				return date.getmonth() + 1;
			},

			// seconds 0-59
			s: function s(date) {
				return date.getseconds();
			},

			// number of the day of the week
			w: function w(date) {
				return date.getday();
			},

			// last two digits of year e.g. 16 for 2016
			y: function y(date) {
				return string(self.formats.y(date)).substring(2);
			}
		};
	}

	function setuphelperfunctions() {
		self.utils = {
			getdaysinmonth: function getdaysinmonth() {
				var month = arguments.length <= 0 || arguments[0] === undefined ? self.currentmonth : arguments[0];
				var yr = arguments.length <= 1 || arguments[1] === undefined ? self.currentyear : arguments[1];

				if (month === 1 && yr % 4 === 0 && yr % 100 !== 0 || yr % 400 === 0) return 29;
				return flatpickr.l10n.daysinmonth[month];
			},

			monthtostr: function monthtostr(monthnumber) {
				var short = arguments.length <= 1 || arguments[1] === undefined ? self.config.shorthandcurrentmonth : arguments[1];
				return flatpickr.l10n.months[(short ? "short" : "long") + "hand"][monthnumber];
			}
		};
	}

	function setupinputs() {
		self.input = self.config.wrap ? self.element.queryselector("[data-input]") : self.element;

		self.input.classlist.add("flatpickr-input");
		if (self.config.altinput) {
			// replicate self.element
			self.altinput = createelement(self.input.nodename, "flatpickr-input " + self.config.altinputclass);
			self.altinput.placeholder = self.input.placeholder;
			self.altinput.type = "text";

			self.input.type = "hidden";
			self.input.parentnode.insertbefore(self.altinput, self.input.nextsibling);
		}

		if (!self.config.allowinput) (self.altinput || self.input).setattribute("readonly", "readonly");
	}

	function setupmobile() {
		var inputtype = self.config.enabletime ? self.config.nocalendar ? "time" : "datetime-local" : "date";

		self.mobileinput = createelement("input", "flatpickr-input");
		self.mobileinput.step = "any";
		self.mobileinput.tabindex = -1;
		self.mobileinput.type = inputtype;

		if (self.selecteddateobj) {
			var formatstr = inputtype === "datetime-local" ? "y-m-d\\th:i:s" : inputtype === "date" ? "y-m-d" : "h:i:s";
			var mobileformatteddate = formatdate(formatstr, self.selecteddateobj);
			self.mobileinput.defaultvalue = self.mobileinput.value = mobileformatteddate;
		}

		if (self.config.mindate) self.mobileinput.min = formatdate("y-m-d", self.config.mindate);

		if (self.config.maxdate) self.mobileinput.max = formatdate("y-m-d", self.config.maxdate);

		self.input.type = "hidden";
		if (self.config.altinput) self.altinput.type = "hidden";

		try {
			self.input.parentnode.insertbefore(self.mobileinput, self.input.nextsibling);
		} catch (e) {
			//
		}

		self.mobileinput.addeventlistener("change", function (e) {
			self.setdate(e.target.value);
			triggerevent("change");
			triggerevent("close");
		});
	}

	function toggle() {
		if (self.isopen) self.close();else self.open();
	}

	function triggerevent(event) {
		if (self.config["on" + event]) self.config["on" + event](self.selecteddateobj, self.input.value, self);
	}

	function updatenavigationcurrentmonth() {
		self.currentmonthelement.textcontent = self.utils.monthtostr(self.currentmonth) + " ";
		self.currentyearelement.value = self.currentyear;
	}

	function updatevalue() {
		var readtimeinput = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];

		if (self.config.nocalendar && !self.selecteddateobj)
			// picking time only and method triggered from picker
			self.selecteddateobj = new date();else if (!self.selecteddateobj) return;

		if (self.config.enabletime && !self.ismobile) {
			var hours = void 0,
			    minutes = void 0,
			    seconds = void 0;

			if (readtimeinput) {
				// update time
				hours = parseint(self.hourelement.value, 10) || 0;

				minutes = (60 + (parseint(self.minuteelement.value, 10) || 0)) % 60;

				if (self.config.enableseconds) seconds = (60 + parseint(self.secondelement.value, 10) || 0) % 60;

				if (!self.config.time_24hr)
					// the real number of hours for the date object
					hours = hours % 12 + 12 * (self.ampm.innerhtml === "pm");

				self.selecteddateobj.sethours(hours, minutes, seconds || 0, 0);
			} else {
				hours = self.selecteddateobj.gethours();
				minutes = self.selecteddateobj.getminutes();
				seconds = self.selecteddateobj.getseconds();
			}

			self.hourelement.value = pad(!self.config.time_24hr ? (12 + hours) % 12 + 12 * (hours % 12 === 0) : hours);
			self.minuteelement.value = pad(minutes);

			if (self.secondelement !== undefined) self.secondelement.value = pad(seconds);
		}

		self.input.value = formatdate(self.config.dateformat, self.selecteddateobj);

		if (self.altinput) self.altinput.value = formatdate(self.config.altformat, self.selecteddateobj);

		triggerevent("valueupdate");
	}

	function yearscroll(e) {
		e.preventdefault();

		var delta = math.max(-1, math.min(1, e.wheeldelta || -e.deltay));
		self.currentyear = e.target.value = parseint(e.target.value, 10) + delta;
		self.redraw();
	}

	function createelement(tag) {
		var classname = arguments.length <= 1 || arguments[1] === undefined ? "" : arguments[1];
		var content = arguments.length <= 2 || arguments[2] === undefined ? "" : arguments[2];

		var e = document.createelement(tag);
		e.classname = classname;

		if (content) e.textcontent = content;

		return e;
	}

	function debounce(func, wait, immediate) {
		var timeout = void 0;
		return function () {
			for (var _len = arguments.length, args = array(_len), _key = 0; _key < _len; _key++) {
				args[_key] = arguments[_key];
			}

			var context = this;
			var later = function later() {
				timeout = null;
				if (!immediate) func.apply(context, args);
			};

			cleartimeout(timeout);
			timeout = settimeout(later, wait);
			if (immediate && !timeout) func.apply(context, args);
		};
	}

	function equaldates(date1, date2) {
		return date1.getdate() === date2.getdate() && date1.getmonth() === date2.getmonth() && date1.getfullyear() === date2.getfullyear();
	}

	function timewrapper(e) {
		e.preventdefault();

		if (e && e.type !== "keydown") e.target.blur();

		if (e.target.classname === "flatpickr-am-pm") {
			e.target.textcontent = ["am", "pm"][e.target.textcontent === "am" | 0];
			e.stoppropagation();
			return;
		}

		var min = parseint(e.target.min, 10),
		    max = parseint(e.target.max, 10),
		    step = parseint(e.target.step, 10),
		    value = parseint(e.target.value, 10);

		var newvalue = value;

		if (e.type === "wheel") newvalue = value + step * math.max(-1, math.min(1, e.wheeldelta || -e.deltay));else if (e.type === "keydown") newvalue = value + step * (e.which === 38 ? 1 : -1);

		if (newvalue <= min) newvalue = max - step;else if (newvalue >= max) newvalue = min + step;

		e.target.value = pad(newvalue);
	}

	init();
	return self;
}

flatpickr.defaultconfig = {
	/* if true, dates will be parsed, formatted, and displayed in utc.
 preloading date strings w/ timezones is recommended but not necessary */
	utc: false,

	// wrap: see https://chmln.github.io/flatpickr/#strap
	wrap: false,

	// enables week numbers
	weeknumbers: false,

	allowinput: false,

	/*
 	clicking on input opens the date(time)picker.
 	disable if you wish to open the calendar manually with .open()
 */
	clickopens: true,

	// display time picker in 24 hour mode
	time_24hr: false,

	// enables the time picker functionality
	enabletime: false,

	// nocalendar: true will hide the calendar. use for a time picker along w/ enabletime
	nocalendar: false,

	// more date format chars at https://chmln.github.io/flatpickr/#dateformat
	dateformat: "y-m-d",

	// altinput - see https://chmln.github.io/flatpickr/#altinput
	altinput: null,

	// the created altinput element will have this class.
	altinputclass: "",

	// same as dateformat, but for altinput
	altformat: "f j, y", // defaults to e.g. june 10, 2016

	// defaultdate - either a datestring or a date object. used for datetimepicker"s initial value
	defaultdate: null,

	// the minimum date that user can pick (inclusive)
	mindate: null,

	// the maximum date that user can pick (inclusive)
	maxdate: null,

	// dateparser that transforms a given string to a date object
	parsedate: null,

	// see https://chmln.github.io/flatpickr/#disable
	enable: [],

	// see https://chmln.github.io/flatpickr/#disable
	disable: [],

	// display the short version of month names - e.g. sep instead of september
	shorthandcurrentmonth: false,

	// displays calendar inline. see https://chmln.github.io/flatpickr/#inline-calendar
	inline: false,

	// position calendar inside wrapper and next to the input element
	// leave at false unless you know what you"re doing
	static: false,

	// code for previous/next icons. this is where you put your custom icon code e.g. fontawesome
	prevarrow: "<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' viewbox='0 0 17 17'><g></g><path d='m5.207 8.471l7.146 7.147-0.707 0.707-7.853-7.854 7.854-7.853 0.707 0.707-7.147 7.146z' /></svg>",
	nextarrow: "<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' viewbox='0 0 17 17'><g></g><path d='m13.207 8.472l-7.854 7.854-0.707-0.707 7.146-7.146-7.146-7.148 0.707-0.707 7.854 7.854z' /></svg>",

	// enables seconds in the time picker
	enableseconds: false,

	// step size used when scrolling/incrementing the hour element
	hourincrement: 1,

	// step size used when scrolling/incrementing the minute element
	minuteincrement: 5,

	// disable native mobile datetime input support
	disablemobile: false,

	// onchange callback when user selects a date or time
	onchange: null, // function (dateobj, datestr) {}

	// called every time calendar is opened
	onopen: null, // function (dateobj, datestr) {}

	// called every time calendar is closed
	onclose: null, // function (dateobj, datestr) {}

	// called after calendar is ready
	onready: null, // function (dateobj, datestr) {}

	onvalueupdate: null
};

flatpickr.l10n = {
	weekdays: {
		shorthand: ["sun", "mon", "tue", "wed", "thu", "fri", "sat"],
		longhand: ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"]
	},
	months: {
		shorthand: ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"],
		longhand: ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"]
	},
	daysinmonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
	firstdayofweek: 0,
	ordinal: function ordinal(nth) {
		var s = nth % 100;
		if (s > 3 && s < 21) return "th";
		switch (s % 10) {
			case 1:
				return "st";
			case 2:
				return "nd";
			case 3:
				return "rd";
			default:
				return "th";
		}
	},
	weekabbreviation: "wk",
	scrolltitle: "scroll to increment",
	toggletitle: "click to toggle"
};

flatpickr.localize = function (l10n) {
	object.keys(l10n).foreach(function (k) {
		return flatpickr.l10n[k] = l10n[k];
	});
};

function _flatpickr(nodelist, config) {
	var instances = [];
	for (var i = 0; i < nodelist.length; i++) {
		if (nodelist[i]._flatpickr) nodelist[i]._flatpickr.destroy();

		try {
			nodelist[i]._flatpickr = new flatpickr(nodelist[i], config || {});
			instances.push(nodelist[i]._flatpickr);
		} catch (e) {
			console.warn(e, e.stack);
		}
	}

	return instances.length === 1 ? instances[0] : instances;
}

htmlcollection.prototype.flatpickr = nodelist.prototype.flatpickr = function (config) {
	return _flatpickr(this, config);
};

htmlelement.prototype.flatpickr = function (config) {
	return _flatpickr([this], config);
};

if (typeof jquery !== "undefined") {
	jquery.fn.flatpickr = function (config) {
		return _flatpickr(this, config);
	};
}

date.prototype.fp_incr = function (days) {
	return new date(this.getfullyear(), this.getmonth(), this.getdate() + parseint(days, 10));
};

date.prototype.fp_isutc = false;
date.prototype.fp_toutc = function () {
	var newdate = new date(this.gettime() + this.gettimezoneoffset() * 60000);
	newdate.fp_isutc = true;

	return newdate;
};

flatpickr.prototype.getweek = function (givendate) {
	var date = new date(givendate.gettime());
	date.sethours(0, 0, 0, 0);

	// thursday in current week decides the year.
	date.setdate(date.getdate() + 3 - (date.getday() + 6) % 7);
	// january 4 is always in week 1.
	var week1 = new date(date.getfullyear(), 0, 4);
	// adjust to thursday in week 1 and count number of weeks from date to week1.
	return 1 + math.round(((date.gettime() - week1.gettime()) / 86400000 - 3 + (week1.getday() + 6) % 7) / 7);
};

// ie9 classlist polyfill
if (!("classlist" in document.documentelement) && object.defineproperty && typeof htmlelement !== "undefined") {
	object.defineproperty(htmlelement.prototype, "classlist", {
		get: function get() {
			var self = this;
			function update(fn) {
				return function (value) {
					var classes = self.classname.split(/\s+/),
					    index = classes.indexof(value);

					fn(classes, index, value);
					self.classname = classes.join(" ");
				};
			}

			var ret = {
				add: update(function (classes, index, value) {
					~index || classes.push(value);
				}),

				remove: update(function (classes, index) {
					~index && classes.splice(index, 1);
				}),

				toggle: update(function (classes, index, value) {
					~index ? classes.splice(index, 1) : classes.push(value);
				}),

				contains: function contains(value) {
					return !!~self.classname.split(/\s+/).indexof(value);
				},

				item: function item(i) {
					return self.classname.split(/\s+/)[i] || null;
				}
			};

			object.defineproperty(ret, "length", {
				get: function get() {
					return self.classname.split(/\s+/).length;
				}
			});

			return ret;
		}
	});
}

if (typeof module !== "undefined") module.exports = flatpickr;