SellKit – Funnel builder and checkout optimizer for WooCommerce to sell more, faster / 2.7.0

SellKit – Funnel builder and checkout optimizer for WooCommerce to sell more, faster v2.7.0

sellkit / assets / lib / flatpickr / flatpickr.js

flatpickr.js in SellKit – Funnel builder and checkout optimizer for WooCommerce to sell more, faster 2.7.0, at assets/lib/flatpickr/flatpickr.js

2,143 lines 73.2 KB

Raw Download Zip

1	/* flatpickr v4.1.4, @license MIT */
2	(function (global, factory) {
3	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
4	typeof define === 'function' && define.amd ? define(factory) :
5	(global.flatpickr = factory());
6	}(this, (function () { 'use strict';
7
8	/! ****************************************************************************
9	Copyright (c) Microsoft Corporation. All rights reserved.
10	Licensed under the Apache License, Version 2.0 (the "License"); you may not use
11	this file except in compliance with the License. You may obtain a copy of the
12	License at http://www.apache.org/licenses/LICENSE-2.0
13
14	THIS CODE IS PROVIDED ON AN AS IS BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15	KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16	WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17	MERCHANTABLITY OR NON-INFRINGEMENT.
18
19	See the Apache Version 2.0 License for specific language governing permissions
20	and limitations under the License.
21	***************************************************************************** */
22	/* global Reflect, Promise */
23
24
25
26	var __assign = Object.assign \|\| function __assign(t) {
27	for (var s, i = 1, n = arguments.length; i < n; i++) {
28	s = arguments[i];
29	for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
30	}
31	return t;
32	};
33
34	function compareDates(date1, date2, timeless) {
35	if (timeless !== false) {
36	return (new Date(date1.getTime()).setHours(0, 0, 0, 0) -
37	new Date(date2.getTime()).setHours(0, 0, 0, 0));
38	}
39	return date1.getTime() - date2.getTime();
40	}
41	var monthToStr = function (monthNumber, shorthand, locale) { return locale.months[shorthand ? "shorthand" : "longhand"][monthNumber]; };
42	var getWeek = function (givenDate) {
43	var onejan = new Date(givenDate.getFullYear(), 0, 1);
44	return Math.ceil(((givenDate.getTime() - onejan.getTime()) / 86400000 +
45	onejan.getDay() +
46	1) /
47	7);
48	};
49	var duration = {
50	DAY: 86400000,
51	};
52
53	var defaults = {
54	_disable: [],
55	_enable: [],
56	allowInput: false,
57	altFormat: "F j, Y",
58	altInput: false,
59	altInputClass: "form-control input",
60	animate: typeof window === "object" &&
61	window.navigator.userAgent.indexOf("MSIE") === -1,
62	ariaDateFormat: "F j, Y",
63	clickOpens: true,
64	closeOnSelect: true,
65	conjunction: ", ",
66	dateFormat: "Y-m-d",
67	defaultHour: 12,
68	defaultMinute: 0,
69	defaultSeconds: 0,
70	disable: [],
71	disableMobile: false,
72	enable: [],
73	enableSeconds: false,
74	enableTime: false,
75	errorHandler: console.warn,
76	getWeek: getWeek,
77	hourIncrement: 1,
78	ignoredFocusElements: [],
79	inline: false,
80	locale: "default",
81	minuteIncrement: 5,
82	mode: "single",
83	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>",
84	noCalendar: false,
85	onChange: [],
86	onClose: [],
87	onDayCreate: [],
88	onDestroy: [],
89	onKeyDown: [],
90	onMonthChange: [],
91	onOpen: [],
92	onParseConfig: [],
93	onReady: [],
94	onValueUpdate: [],
95	onYearChange: [],
96	plugins: [],
97	position: "auto",
98	positionElement: undefined,
99	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>",
100	shorthandCurrentMonth: false,
101	static: false,
102	time_24hr: false,
103	weekNumbers: false,
104	wrap: false,
105	};
106
107	var english = {
108	weekdays: {
109	shorthand: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
110	longhand: [
111	"Sunday",
112	"Monday",
113	"Tuesday",
114	"Wednesday",
115	"Thursday",
116	"Friday",
117	"Saturday",
118	],
119	},
120	months: {
121	shorthand: [
122	"Jan",
123	"Feb",
124	"Mar",
125	"Apr",
126	"May",
127	"Jun",
128	"Jul",
129	"Aug",
130	"Sep",
131	"Oct",
132	"Nov",
133	"Dec",
134	],
135	longhand: [
136	"January",
137	"February",
138	"March",
139	"April",
140	"May",
141	"June",
142	"July",
143	"August",
144	"September",
145	"October",
146	"November",
147	"December",
148	],
149	},
150	daysInMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
151	firstDayOfWeek: 0,
152	ordinal: function (nth) {
153	var s = nth % 100;
154	if (s > 3 && s < 21)
155	return "th";
156	switch (s % 10) {
157	case 1:
158	return "st";
159	case 2:
160	return "nd";
161	case 3:
162	return "rd";
163	default:
164	return "th";
165	}
166	},
167	rangeSeparator: " to ",
168	weekAbbreviation: "Wk",
169	scrollTitle: "Scroll to increment",
170	toggleTitle: "Click to toggle",
171	amPM: ["AM", "PM"],
172	};
173
174	var pad = function (number) { return ("0" + number).slice(-2); };
175	var int = function (bool) { return (bool === true ? 1 : 0); };
176	function debounce(func, wait, immediate) {
177	if (immediate === void 0) { immediate = false; }
178	var timeout;
179	return function () {
180	var context = this, args = arguments;
181	timeout !== null && clearTimeout(timeout);
182	timeout = window.setTimeout(function () {
183	timeout = null;
184	if (!immediate)
185	func.apply(context, args);
186	}, wait);
187	if (immediate && !timeout)
188	func.apply(context, args);
189	};
190	}
191	var arrayify = function (obj) {
192	return obj instanceof Array ? obj : [obj];
193	};
194	function mouseDelta(e) {
195	var delta = e.wheelDelta \|\| -e.deltaY;
196	return delta >= 0 ? 1 : -1;
197	}
198
199	function toggleClass(elem, className, bool) {
200	if (bool === true)
201	return elem.classList.add(className);
202	elem.classList.remove(className);
203	}
204	function createElement(tag, className, content) {
205	var e = window.document.createElement(tag);
206	className = className \|\| "";
207	content = content \|\| "";
208	e.className = className;
209	if (content !== undefined)
210	e.textContent = content;
211	return e;
212	}
213	function clearNode(node) {
214	while (node.firstChild)
215	node.removeChild(node.firstChild);
216	}
217	function findParent(node, condition) {
218	if (condition(node))
219	return node;
220	else if (node.parentNode)
221	return findParent(node.parentNode, condition);
222	return undefined;
223	}
224	function createNumberInput(inputClassName) {
225	var wrapper = createElement("div", "numInputWrapper"), numInput = createElement("input", "numInput " + inputClassName), arrowUp = createElement("span", "arrowUp"), arrowDown = createElement("span", "arrowDown");
226	numInput.type = "text";
227	numInput.pattern = "\\d*";
228	wrapper.appendChild(numInput);
229	wrapper.appendChild(arrowUp);
230	wrapper.appendChild(arrowDown);
231	return wrapper;
232	}
233
234	var do_nothing = function () { return undefined; };
235	var revFormat = {
236	D: do_nothing,
237	F: function (dateObj, monthName, locale) {
238	dateObj.setMonth(locale.months.longhand.indexOf(monthName));
239	},
240	G: function (dateObj, hour) {
241	dateObj.setHours(parseFloat(hour));
242	},
243	H: function (dateObj, hour) {
244	dateObj.setHours(parseFloat(hour));
245	},
246	J: function (dateObj, day) {
247	dateObj.setDate(parseFloat(day));
248	},
249	K: function (dateObj, amPM, locale) {
250	dateObj.setHours(dateObj.getHours() % 12 +
251	12 * int(new RegExp(locale.amPM[1], "i").test(amPM)));
252	},
253	M: function (dateObj, shortMonth, locale) {
254	dateObj.setMonth(locale.months.shorthand.indexOf(shortMonth));
255	},
256	S: function (dateObj, seconds) {
257	dateObj.setSeconds(parseFloat(seconds));
258	},
259	U: function (_, unixSeconds) { return new Date(parseFloat(unixSeconds) * 1000); },
260	W: function (dateObj, weekNum) {
261	var weekNumber = parseInt(weekNum);
262	return new Date(dateObj.getFullYear(), 0, 2 + (weekNumber - 1) * 7, 0, 0, 0, 0);
263	},
264	Y: function (dateObj, year) {
265	dateObj.setFullYear(parseFloat(year));
266	},
267	Z: function (_, ISODate) { return new Date(ISODate); },
268	d: function (dateObj, day) {
269	dateObj.setDate(parseFloat(day));
270	},
271	h: function (dateObj, hour) {
272	dateObj.setHours(parseFloat(hour));
273	},
274	i: function (dateObj, minutes) {
275	dateObj.setMinutes(parseFloat(minutes));
276	},
277	j: function (dateObj, day) {
278	dateObj.setDate(parseFloat(day));
279	},
280	l: do_nothing,
281	m: function (dateObj, month) {
282	dateObj.setMonth(parseFloat(month) - 1);
283	},
284	n: function (dateObj, month) {
285	dateObj.setMonth(parseFloat(month) - 1);
286	},
287	s: function (dateObj, seconds) {
288	dateObj.setSeconds(parseFloat(seconds));
289	},
290	w: do_nothing,
291	y: function (dateObj, year) {
292	dateObj.setFullYear(2000 + parseFloat(year));
293	},
294	};
295	var tokenRegex = {
296	D: "(\\w+)",
297	F: "(\\w+)",
298	G: "(\\d\\d\|\\d)",
299	H: "(\\d\\d\|\\d)",
300	J: "(\\d\\d\|\\d)\\w+",
301	K: "",
302	M: "(\\w+)",
303	S: "(\\d\\d\|\\d)",
304	U: "(.+)",
305	W: "(\\d\\d\|\\d)",
306	Y: "(\\d{4})",
307	Z: "(.+)",
308	d: "(\\d\\d\|\\d)",
309	h: "(\\d\\d\|\\d)",
310	i: "(\\d\\d\|\\d)",
311	j: "(\\d\\d\|\\d)",
312	l: "(\\w+)",
313	m: "(\\d\\d\|\\d)",
314	n: "(\\d\\d\|\\d)",
315	s: "(\\d\\d\|\\d)",
316	w: "(\\d\\d\|\\d)",
317	y: "(\\d{2})",
318	};
319	var formats = {
320	Z: function (date) { return date.toISOString(); },
321	D: function (date, locale, options) {
322	return locale.weekdays.shorthand[formats.w(date, locale, options)];
323	},
324	F: function (date, locale, options) {
325	return monthToStr(formats.n(date, locale, options) - 1, false, locale);
326	},
327	G: function (date, locale, options) {
328	return pad(formats.h(date, locale, options));
329	},
330	H: function (date) { return pad(date.getHours()); },
331	J: function (date, locale) {
332	return locale.ordinal !== undefined
333	? date.getDate() + locale.ordinal(date.getDate())
334	: date.getDate();
335	},
336	K: function (date, locale) { return locale.amPM[int(date.getHours() > 11)]; },
337	M: function (date, locale) {
338	return monthToStr(date.getMonth(), true, locale);
339	},
340	S: function (date) { return pad(date.getSeconds()); },
341	U: function (date) { return date.getTime() / 1000; },
342	W: function (date, _, options) {
343	return options.getWeek(date);
344	},
345	Y: function (date) { return date.getFullYear(); },
346	d: function (date) { return pad(date.getDate()); },
347	h: function (date) { return (date.getHours() % 12 ? date.getHours() % 12 : 12); },
348	i: function (date) { return pad(date.getMinutes()); },
349	j: function (date) { return date.getDate(); },
350	l: function (date, locale) {
351	return locale.weekdays.longhand[date.getDay()];
352	},
353	m: function (date) { return pad(date.getMonth() + 1); },
354	n: function (date) { return date.getMonth() + 1; },
355	s: function (date) { return date.getSeconds(); },
356	w: function (date) { return date.getDay(); },
357	y: function (date) { return String(date.getFullYear()).substring(2); },
358	};
359
360	if (typeof Object.assign !== "function") {
361	Object.assign = function (target) {
362	var args = [];
363	for (var _i = 1; _i < arguments.length; _i++) {
364	args[_i - 1] = arguments[_i];
365	}
366	if (!target) {
367	throw TypeError("Cannot convert undefined or null to object");
368	}
369	var _loop_1 = function (source) {
370	if (source) {
371	Object.keys(source).forEach(function (key) { return (target[key] = source[key]); });
372	}
373	};
374	for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
375	var source = args_1[_a];
376	_loop_1(source);
377	}
378	return target;
379	};
380	}
381
382	function FlatpickrInstance(element, instanceConfig) {
383	var self = {};
384	self.parseDate = parseDate;
385	self.formatDate = formatDate;
386	self._animationLoop = [];
387	self._handlers = [];
388	self._bind = bind;
389	self._setHoursFromDate = setHoursFromDate;
390	self.changeMonth = changeMonth;
391	self.changeYear = changeYear;
392	self.clear = clear;
393	self.close = close;
394	self._createElement = createElement;
395	self.destroy = destroy;
396	self.isEnabled = isEnabled;
397	self.jumpToDate = jumpToDate;
398	self.open = open;
399	self.redraw = redraw;
400	self.set = set;
401	self.setDate = setDate;
402	self.toggle = toggle;
403	function setupHelperFunctions() {
404	self.utils = {
405	getDaysInMonth: function (month, yr) {
406	if (month === void 0) { month = self.currentMonth; }
407	if (yr === void 0) { yr = self.currentYear; }
408	if (month === 1 && ((yr % 4 === 0 && yr % 100 !== 0) \|\| yr % 400 === 0))
409	return 29;
410	return self.l10n.daysInMonth[month];
411	},
412	};
413	}
414	function init() {
415	self.element = self.input = element;
416	self.isOpen = false;
417	parseConfig();
418	setupLocale();
419	setupInputs();
420	setupDates();
421	setupHelperFunctions();
422	if (!self.isMobile)
423	build();
424	bindEvents();
425	if (self.selectedDates.length \|\| self.config.noCalendar) {
426	if (self.config.enableTime) {
427	setHoursFromDate(self.config.noCalendar
428	? self.latestSelectedDateObj \|\| self.config.minDate
429	: undefined);
430	}
431	updateValue(false);
432	}
433	self.showTimeInput =
434	self.selectedDates.length > 0 \|\| self.config.noCalendar;
435	if (self.weekWrapper !== undefined && self.daysContainer !== undefined) {
436	self.calendarContainer.style.width =
437	self.daysContainer.offsetWidth + self.weekWrapper.offsetWidth + "px";
438	}
439	if (!self.isMobile)
440	positionCalendar();
441	triggerEvent("onReady");
442	}
443	function bindToInstance(fn) {
444	return fn.bind(self);
445	}
446	function updateTime(e) {
447	if (self.config.noCalendar && self.selectedDates.length === 0) {
448	var minDate = self.config.minDate;
449	self.setDate(new Date().setHours(!minDate ? self.config.defaultHour : minDate.getHours(), !minDate ? self.config.defaultMinute : minDate.getMinutes(), !minDate \|\| !self.config.enableSeconds
450	? self.config.defaultSeconds
451	: minDate.getSeconds()), false);
452	setHoursFromInputs();
453	updateValue();
454	}
455	timeWrapper(e);
456	if (self.selectedDates.length === 0)
457	return;
458	if (!self.minDateHasTime \|\|
459	e.type !== "input" \|\|
460	e.target.value.length >= 2) {
461	setHoursFromInputs();
462	updateValue();
463	}
464	else {
465	setTimeout(function () {
466	setHoursFromInputs();
467	updateValue();
468	}, 1000);
469	}
470	}
471	function ampm2military(hour, amPM) {
472	return hour % 12 + 12 * int(amPM === self.l10n.amPM[1]);
473	}
474	function military2ampm(hour) {
475	switch (hour % 24) {
476	case 0:
477	case 12:
478	return 12;
479	default:
480	return hour % 12;
481	}
482	}
483	function setHoursFromInputs() {
484	if (self.hourElement === undefined \|\| self.minuteElement === undefined)
485	return;
486	var hours = (parseInt(self.hourElement.value.slice(-2), 10) \|\| 0) % 24, minutes = (parseInt(self.minuteElement.value, 10) \|\| 0) % 60, seconds = self.secondElement !== undefined
487	? (parseInt(self.secondElement.value, 10) \|\| 0) % 60
488	: 0;
489	if (self.amPM !== undefined)
490	hours = ampm2military(hours, self.amPM.textContent);
491	if (self.config.minDate &&
492	self.minDateHasTime &&
493	self.latestSelectedDateObj &&
494	compareDates(self.latestSelectedDateObj, self.config.minDate) === 0) {
495	hours = Math.max(hours, self.config.minDate.getHours());
496	if (hours === self.config.minDate.getHours())
497	minutes = Math.max(minutes, self.config.minDate.getMinutes());
498	}
499	if (self.config.maxDate &&
500	self.maxDateHasTime &&
501	self.latestSelectedDateObj &&
502	compareDates(self.latestSelectedDateObj, self.config.maxDate) === 0) {
503	hours = Math.min(hours, self.config.maxDate.getHours());
504	if (hours === self.config.maxDate.getHours())
505	minutes = Math.min(minutes, self.config.maxDate.getMinutes());
506	}
507	setHours(hours, minutes, seconds);
508	}
509	function setHoursFromDate(dateObj) {
510	var date = dateObj \|\| self.latestSelectedDateObj;
511	if (date)
512	setHours(date.getHours(), date.getMinutes(), date.getSeconds());
513	}
514	function setHours(hours, minutes, seconds) {
515	if (self.latestSelectedDateObj !== undefined) {
516	self.latestSelectedDateObj.setHours(hours % 24, minutes, seconds \|\| 0, 0);
517	}
518	if (!self.hourElement \|\| !self.minuteElement \|\| self.isMobile)
519	return;
520	self.hourElement.value = pad(!self.config.time_24hr
521	? (12 + hours) % 12 + 12 * int(hours % 12 === 0)
522	: hours);
523	self.minuteElement.value = pad(minutes);
524	if (self.amPM !== undefined)
525	self.amPM.textContent = self.l10n.amPM[int(hours >= 12)];
526	if (self.secondElement !== undefined)
527	self.secondElement.value = pad(seconds);
528	}
529	function onYearInput(event) {
530	var year = parseInt(event.target.value) + (event.delta \|\| 0);
531	if (year.toString().length === 4 \|\| event.key === "Enter") {
532	self.currentYearElement.blur();
533	if (!/[^\d]/.test(year.toString()))
534	changeYear(year);
535	}
536	}
537	function bind(element, event, handler) {
538	if (event instanceof Array)
539	return event.forEach(function (ev) { return bind(element, ev, handler); });
540	if (element instanceof Array)
541	return element.forEach(function (el) { return bind(el, event, handler); });
542	element.addEventListener(event, handler);
543	self._handlers.push({ element: element, event: event, handler: handler });
544	}
545	function onClick(handler) {
546	return function (evt) {
547	evt.which === 1 && handler(evt);
548	};
549	}
550	function triggerChange() {
551	triggerEvent("onChange");
552	}
553	function bindEvents() {
554	if (self.config.wrap) {
555	["open", "close", "toggle", "clear"].forEach(function (evt) {
556	Array.prototype.forEach.call(self.element.querySelectorAll("[data-" + evt + "]"), function (el) {
557	return bind(el, "click", self[evt]);
558	});
559	});
560	}
561	if (self.isMobile) {
562	setupMobile();
563	return;
564	}
565	var debouncedResize = debounce(onResize, 50);
566	self._debouncedChange = debounce(triggerChange, 300);
567	if (self.config.mode === "range" &&
568	self.daysContainer &&
569	!/iPhone\|iPad\|iPod/i.test(navigator.userAgent))
570	bind(self.daysContainer, "mouseover", function (e) {
571	return onMouseOver(e.target);
572	});
573	bind(window.document.body, "keydown", onKeyDown);
574	if (!self.config.static)
575	bind(self._input, "keydown", onKeyDown);
576	if (!self.config.inline && !self.config.static)
577	bind(window, "resize", debouncedResize);
578	if (window.ontouchstart !== undefined)
579	bind(window.document.body, "touchstart", documentClick);
580	bind(window.document.body, "mousedown", onClick(documentClick));
581	bind(self._input, "blur", documentClick);
582	if (self.config.clickOpens === true) {
583	bind(self._input, "focus", self.open);
584	bind(self._input, "mousedown", onClick(self.open));
585	}
586	if (self.daysContainer !== undefined) {
587	self.monthNav.addEventListener("wheel", function (e) { return e.preventDefault(); });
588	bind(self.monthNav, "wheel", debounce(onMonthNavScroll, 10));
589	bind(self.monthNav, "mousedown", onClick(onMonthNavClick));
590	bind(self.monthNav, ["keyup", "increment"], onYearInput);
591	bind(self.daysContainer, "mousedown", onClick(selectDate));
592	if (self.config.animate) {
593	bind(self.daysContainer, ["webkitAnimationEnd", "animationend"], animateDays);
594	bind(self.monthNav, ["webkitAnimationEnd", "animationend"], animateMonths);
595	}
596	}
597	if (self.timeContainer !== undefined &&
598	self.minuteElement !== undefined &&
599	self.hourElement !== undefined) {
600	var selText = function (e) {
601	return e.target.select();
602	};
603	bind(self.timeContainer, ["wheel", "input", "increment"], updateTime);
604	bind(self.timeContainer, "mousedown", onClick(timeIncrement));
605	bind(self.timeContainer, ["wheel", "increment"], self._debouncedChange);
606	bind(self.timeContainer, "input", triggerChange);
607	bind([self.hourElement, self.minuteElement], ["focus", "click"], selText);
608	if (self.secondElement !== undefined)
609	bind(self.secondElement, "focus", function () { return self.secondElement && self.secondElement.select(); });
610	if (self.amPM !== undefined) {
611	bind(self.amPM, "mousedown", onClick(function (e) {
612	updateTime(e);
613	triggerChange();
614	}));
615	}
616	}
617	}
618	function processPostDayAnimation() {
619	self._animationLoop.forEach(function (f) { return f(); });
620	self._animationLoop = [];
621	}
622	function animateDays(e) {
623	if (self.daysContainer && self.daysContainer.childNodes.length > 1) {
624	switch (e.animationName) {
625	case "fpSlideLeft":
626	self.daysContainer.lastChild &&
627	self.daysContainer.lastChild.classList.remove("slideLeftNew");
628	self.daysContainer.removeChild(self.daysContainer
629	.firstChild);
630	self.days = self.daysContainer.firstChild;
631	processPostDayAnimation();
632	break;
633	case "fpSlideRight":
634	self.daysContainer.firstChild &&
635	self.daysContainer.firstChild.classList.remove("slideRightNew");
636	self.daysContainer.removeChild(self.daysContainer
637	.lastChild);
638	self.days = self.daysContainer.firstChild;
639	processPostDayAnimation();
640	break;
641	default:
642	break;
643	}
644	}
645	}
646	function animateMonths(e) {
647	switch (e.animationName) {
648	case "fpSlideLeftNew":
649	case "fpSlideRightNew":
650	self.navigationCurrentMonth.classList.remove("slideLeftNew");
651	self.navigationCurrentMonth.classList.remove("slideRightNew");
652	var nav = self.navigationCurrentMonth;
653	while (nav.nextSibling &&
654	/curr/.test(nav.nextSibling.className))
655	self.monthNav.removeChild(nav.nextSibling);
656	while (nav.previousSibling &&
657	/curr/.test(nav.previousSibling.className))
658	self.monthNav.removeChild(nav.previousSibling);
659	self.oldCurMonth = undefined;
660	break;
661	}
662	}
663	function jumpToDate(jumpDate) {
664	var jumpTo = jumpDate !== undefined
665	? parseDate(jumpDate)
666	: self.latestSelectedDateObj \|\|
667	(self.config.minDate && self.config.minDate > self.now
668	? self.config.minDate
669	: self.config.maxDate && self.config.maxDate < self.now
670	? self.config.maxDate
671	: self.now);
672	try {
673	if (jumpTo !== undefined) {
674	self.currentYear = jumpTo.getFullYear();
675	self.currentMonth = jumpTo.getMonth();
676	}
677	}
678	catch (e) {
679	e.message = "Invalid date supplied: " + jumpTo;
680	self.config.errorHandler(e);
681	}
682	self.redraw();
683	}
684	function timeIncrement(e) {
685	if (~e.target.className.indexOf("arrow"))
686	incrementNumInput(e, e.target.classList.contains("arrowUp") ? 1 : -1);
687	}
688	function incrementNumInput(e, delta, inputElem) {
689	var target = e && e.target;
690	var input = inputElem \|\|
691	(target && target.parentNode && target.parentNode.firstChild);
692	var event = createEvent("increment");
693	event.delta = delta;
694	input && input.dispatchEvent(event);
695	}
696	function build() {
697	var fragment = window.document.createDocumentFragment();
698	self.calendarContainer = createElement("div", "flatpickr-calendar");
699	self.calendarContainer.tabIndex = -1;
700	if (!self.config.noCalendar) {
701	fragment.appendChild(buildMonthNav());
702	self.innerContainer = createElement("div", "flatpickr-innerContainer");
703	if (self.config.weekNumbers) {
704	var _a = buildWeeks(), weekWrapper = _a.weekWrapper, weekNumbers = _a.weekNumbers;
705	self.innerContainer.appendChild(weekWrapper);
706	self.weekNumbers = weekNumbers;
707	self.weekWrapper = weekWrapper;
708	}
709	self.rContainer = createElement("div", "flatpickr-rContainer");
710	self.rContainer.appendChild(buildWeekdays());
711	if (!self.daysContainer) {
712	self.daysContainer = createElement("div", "flatpickr-days");
713	self.daysContainer.tabIndex = -1;
714	}
715	buildDays();
716	self.rContainer.appendChild(self.daysContainer);
717	self.innerContainer.appendChild(self.rContainer);
718	fragment.appendChild(self.innerContainer);
719	}
720	if (self.config.enableTime) {
721	fragment.appendChild(buildTime());
722	}
723	toggleClass(self.calendarContainer, "rangeMode", self.config.mode === "range");
724	toggleClass(self.calendarContainer, "animate", self.config.animate);
725	self.calendarContainer.appendChild(fragment);
726	var customAppend = self.config.appendTo !== undefined && self.config.appendTo.nodeType;
727	if (self.config.inline \|\| self.config.static) {
728	self.calendarContainer.classList.add(self.config.inline ? "inline" : "static");
729	if (self.config.inline) {
730	if (!customAppend && self.element.parentNode)
731	self.element.parentNode.insertBefore(self.calendarContainer, self._input.nextSibling);
732	else if (self.config.appendTo !== undefined)
733	self.config.appendTo.appendChild(self.calendarContainer);
734	}
735	if (self.config.static) {
736	var wrapper = createElement("div", "flatpickr-wrapper");
737	if (self.element.parentNode)
738	self.element.parentNode.insertBefore(wrapper, self.element);
739	wrapper.appendChild(self.element);
740	if (self.altInput)
741	wrapper.appendChild(self.altInput);
742	wrapper.appendChild(self.calendarContainer);
743	}
744	}
745	if (!self.config.static && !self.config.inline)
746	(self.config.appendTo !== undefined
747	? self.config.appendTo
748	: window.document.body).appendChild(self.calendarContainer);
749	}
750	function createDay(className, date, dayNumber, i) {
751	var dateIsEnabled = isEnabled(date, true), dayElement = createElement("span", "flatpickr-day " + className, date.getDate().toString());
752	dayElement.dateObj = date;
753	dayElement.$i = i;
754	dayElement.setAttribute("aria-label", self.formatDate(date, self.config.ariaDateFormat));
755	if (compareDates(date, self.now) === 0) {
756	self.todayDateElem = dayElement;
757	dayElement.classList.add("today");
758	}
759	if (dateIsEnabled) {
760	dayElement.tabIndex = -1;
761	if (isDateSelected(date)) {
762	dayElement.classList.add("selected");
763	self.selectedDateElem = dayElement;
764	if (self.config.mode === "range") {
765	toggleClass(dayElement, "startRange", self.selectedDates[0] &&
766	compareDates(date, self.selectedDates[0]) === 0);
767	toggleClass(dayElement, "endRange", self.selectedDates[1] &&
768	compareDates(date, self.selectedDates[1]) === 0);
769	}
770	}
771	}
772	else {
773	dayElement.classList.add("disabled");
774	if (self.selectedDates[0] &&
775	self.minRangeDate &&
776	date > self.minRangeDate &&
777	date < self.selectedDates[0])
778	self.minRangeDate = date;
779	else if (self.selectedDates[0] &&
780	self.maxRangeDate &&
781	date < self.maxRangeDate &&
782	date > self.selectedDates[0])
783	self.maxRangeDate = date;
784	}
785	if (self.config.mode === "range") {
786	if (isDateInRange(date) && !isDateSelected(date))
787	dayElement.classList.add("inRange");
788	if (self.selectedDates.length === 1 &&
789	self.minRangeDate !== undefined &&
790	self.maxRangeDate !== undefined &&
791	(date < self.minRangeDate \|\| date > self.maxRangeDate))
792	dayElement.classList.add("notAllowed");
793	}
794	if (self.weekNumbers &&
795	className !== "prevMonthDay" &&
796	dayNumber % 7 === 1) {
797	self.weekNumbers.insertAdjacentHTML("beforeend", "<span class='disabled flatpickr-day'>" +
798	self.config.getWeek(date) +
799	"</span>");
800	}
801	triggerEvent("onDayCreate", dayElement);
802	return dayElement;
803	}
804	function focusOnDay(currentIndex, offset) {
805	var newIndex = currentIndex + offset \|\| 0, targetNode = (currentIndex !== undefined
806	? self.days.childNodes[newIndex]
807	: self.selectedDateElem \|\|
808	self.todayDateElem \|\|
809	self.days.childNodes[0]);
810	var focus = function () {
811	targetNode = targetNode \|\| self.days.childNodes[newIndex];
812	targetNode.focus();
813	if (self.config.mode === "range")
814	onMouseOver(targetNode);
815	};
816	if (targetNode === undefined && offset !== 0) {
817	if (offset > 0) {
818	self.changeMonth(1, true, undefined, true);
819	newIndex = newIndex % 42;
820	}
821	else if (offset < 0) {
822	self.changeMonth(-1, true, undefined, true);
823	newIndex += 42;
824	}
825	return afterDayAnim(focus);
826	}
827	focus();
828	}
829	function afterDayAnim(fn) {
830	self.config.animate === true ? self._animationLoop.push(fn) : fn();
831	}
832	function buildDays(delta) {
833	if (self.daysContainer === undefined) {
834	return;
835	}
836	var firstOfMonth = (new Date(self.currentYear, self.currentMonth, 1).getDay() -
837	self.l10n.firstDayOfWeek +
838	7) %
839	7, isRangeMode = self.config.mode === "range";
840	var prevMonthDays = self.utils.getDaysInMonth((self.currentMonth - 1 + 12) % 12);
841	var daysInMonth = self.utils.getDaysInMonth(), days = window.document.createDocumentFragment();
842	var dayNumber = prevMonthDays + 1 - firstOfMonth, dayIndex = 0;
843	if (self.weekNumbers && self.weekNumbers.firstChild)
844	self.weekNumbers.textContent = "";
845	if (isRangeMode) {
846	self.minRangeDate = new Date(self.currentYear, self.currentMonth - 1, dayNumber);
847	self.maxRangeDate = new Date(self.currentYear, self.currentMonth + 1, (42 - firstOfMonth) % daysInMonth);
848	}
849	for (; dayNumber <= prevMonthDays; dayNumber++, dayIndex++) {
850	days.appendChild(createDay("prevMonthDay", new Date(self.currentYear, self.currentMonth - 1, dayNumber), dayNumber, dayIndex));
851	}
852	for (dayNumber = 1; dayNumber <= daysInMonth; dayNumber++, dayIndex++) {
853	days.appendChild(createDay("", new Date(self.currentYear, self.currentMonth, dayNumber), dayNumber, dayIndex));
854	}
855	for (var dayNum = daysInMonth + 1; dayNum <= 42 - firstOfMonth; dayNum++, dayIndex++) {
856	days.appendChild(createDay("nextMonthDay", new Date(self.currentYear, self.currentMonth + 1, dayNum % daysInMonth), dayNum, dayIndex));
857	}
858	if (isRangeMode && self.selectedDates.length === 1 && days.childNodes[0]) {
859	self._hidePrevMonthArrow =
860	self._hidePrevMonthArrow \|\|
861	(!!self.minRangeDate &&
862	self.minRangeDate > days.childNodes[0].dateObj);
863	self._hideNextMonthArrow =
864	self._hideNextMonthArrow \|\|
865	(!!self.maxRangeDate &&
866	self.maxRangeDate <
867	new Date(self.currentYear, self.currentMonth + 1, 1));
868	}
869	else
870	updateNavigationCurrentMonth();
871	var dayContainer = createElement("div", "dayContainer");
872	dayContainer.appendChild(days);
873	if (!self.config.animate \|\| delta === undefined)
874	clearNode(self.daysContainer);
875	else {
876	while (self.daysContainer.childNodes.length > 1)
877	self.daysContainer.removeChild(self.daysContainer.firstChild);
878	}
879	if (delta && delta >= 0)
880	self.daysContainer.appendChild(dayContainer);
881	else
882	self.daysContainer.insertBefore(dayContainer, self.daysContainer.firstChild);
883	self.days = self.daysContainer.childNodes[0];
884	}
885	function buildMonthNav() {
886	var monthNavFragment = window.document.createDocumentFragment();
887	self.monthNav = createElement("div", "flatpickr-month");
888	self.prevMonthNav = createElement("span", "flatpickr-prev-month");
889	self.prevMonthNav.innerHTML = self.config.prevArrow;
890	self.currentMonthElement = createElement("span", "cur-month");
891	self.currentMonthElement.title = self.l10n.scrollTitle;
892	var yearInput = createNumberInput("cur-year");
893	self.currentYearElement = yearInput.childNodes[0];
894	self.currentYearElement.title = self.l10n.scrollTitle;
895	if (self.config.minDate)
896	self.currentYearElement.min = self.config.minDate
897	.getFullYear()
898	.toString();
899	if (self.config.maxDate) {
900	self.currentYearElement.max = self.config.maxDate
901	.getFullYear()
902	.toString();
903	self.currentYearElement.disabled =
904	!!self.config.minDate &&
905	self.config.minDate.getFullYear() === self.config.maxDate.getFullYear();
906	}
907	self.nextMonthNav = createElement("span", "flatpickr-next-month");
908	self.nextMonthNav.innerHTML = self.config.nextArrow;
909	self.navigationCurrentMonth = createElement("div", "flatpickr-current-month");
910	self.navigationCurrentMonth.appendChild(self.currentMonthElement);
911	self.navigationCurrentMonth.appendChild(yearInput);
912	monthNavFragment.appendChild(self.prevMonthNav);
913	monthNavFragment.appendChild(self.navigationCurrentMonth);
914	monthNavFragment.appendChild(self.nextMonthNav);
915	self.monthNav.appendChild(monthNavFragment);
916	Object.defineProperty(self, "_hidePrevMonthArrow", {
917	get: function () { return self.__hidePrevMonthArrow; },
918	set: function (bool) {
919	if (self.__hidePrevMonthArrow !== bool)
920	self.prevMonthNav.style.display = bool ? "none" : "block";
921	self.__hidePrevMonthArrow = bool;
922	},
923	});
924	Object.defineProperty(self, "_hideNextMonthArrow", {
925	get: function () { return self.__hideNextMonthArrow; },
926	set: function (bool) {
927	if (self.__hideNextMonthArrow !== bool)
928	self.nextMonthNav.style.display = bool ? "none" : "block";
929	self.__hideNextMonthArrow = bool;
930	},
931	});
932	updateNavigationCurrentMonth();
933	return self.monthNav;
934	}
935	function buildTime() {
936	self.calendarContainer.classList.add("hasTime");
937	if (self.config.noCalendar)
938	self.calendarContainer.classList.add("noCalendar");
939	self.timeContainer = createElement("div", "flatpickr-time");
940	self.timeContainer.tabIndex = -1;
941	var separator = createElement("span", "flatpickr-time-separator", ":");
942	var hourInput = createNumberInput("flatpickr-hour");
943	self.hourElement = hourInput.childNodes[0];
944	var minuteInput = createNumberInput("flatpickr-minute");
945	self.minuteElement = minuteInput.childNodes[0];
946	self.hourElement.tabIndex = self.minuteElement.tabIndex = -1;
947	self.hourElement.value = pad(self.latestSelectedDateObj
948	? self.latestSelectedDateObj.getHours()
949	: self.config.time_24hr
950	? self.config.defaultHour
951	: military2ampm(self.config.defaultHour));
952	self.minuteElement.value = pad(self.latestSelectedDateObj
953	? self.latestSelectedDateObj.getMinutes()
954	: self.config.defaultMinute);
955	self.hourElement.step = self.config.hourIncrement.toString();
956	self.minuteElement.step = self.config.minuteIncrement.toString();
957	self.hourElement.min = self.config.time_24hr ? "0" : "1";
958	self.hourElement.max = self.config.time_24hr ? "23" : "12";
959	self.minuteElement.min = "0";
960	self.minuteElement.max = "59";
961	self.hourElement.title = self.minuteElement.title = self.l10n.scrollTitle;
962	self.timeContainer.appendChild(hourInput);
963	self.timeContainer.appendChild(separator);
964	self.timeContainer.appendChild(minuteInput);
965	if (self.config.time_24hr)
966	self.timeContainer.classList.add("time24hr");
967	if (self.config.enableSeconds) {
968	self.timeContainer.classList.add("hasSeconds");
969	var secondInput = createNumberInput("flatpickr-second");
970	self.secondElement = secondInput.childNodes[0];
971	self.secondElement.value = pad(self.latestSelectedDateObj
972	? self.latestSelectedDateObj.getSeconds()
973	: self.config.defaultSeconds);
974	self.secondElement.step = self.minuteElement.step;
975	self.secondElement.min = self.minuteElement.min;
976	self.secondElement.max = self.minuteElement.max;
977	self.timeContainer.appendChild(createElement("span", "flatpickr-time-separator", ":"));
978	self.timeContainer.appendChild(secondInput);
979	}
980	if (!self.config.time_24hr) {
981	self.amPM = createElement("span", "flatpickr-am-pm", self.l10n.amPM[int((self.latestSelectedDateObj
982	? self.hourElement.value
983	: self.config.defaultHour) > 11)]);
984	self.amPM.title = self.l10n.toggleTitle;
985	self.amPM.tabIndex = -1;
986	self.timeContainer.appendChild(self.amPM);
987	}
988	return self.timeContainer;
989	}
990	function buildWeekdays() {
991	if (!self.weekdayContainer)
992	self.weekdayContainer = createElement("div", "flatpickr-weekdays");
993	var firstDayOfWeek = self.l10n.firstDayOfWeek;
994	var weekdays = self.l10n.weekdays.shorthand.slice();
995	if (firstDayOfWeek > 0 && firstDayOfWeek < weekdays.length) {
996	weekdays = weekdays.splice(firstDayOfWeek, weekdays.length).concat(weekdays.splice(0, firstDayOfWeek));
997	}
998	self.weekdayContainer.innerHTML = "\n <span class=flatpickr-weekday>\n " + weekdays.join("</span><span class=flatpickr-weekday>") + "\n </span>\n ";
999	return self.weekdayContainer;
1000	}
1001	function buildWeeks() {
1002	self.calendarContainer.classList.add("hasWeeks");
1003	var weekWrapper = createElement("div", "flatpickr-weekwrapper");
1004	weekWrapper.appendChild(createElement("span", "flatpickr-weekday", self.l10n.weekAbbreviation));
1005	var weekNumbers = createElement("div", "flatpickr-weeks");
1006	weekWrapper.appendChild(weekNumbers);
1007	return {
1008	weekWrapper: weekWrapper,
1009	weekNumbers: weekNumbers,
1010	};
1011	}
1012	function changeMonth(value, is_offset, animate, from_keyboard) {
1013	if (is_offset === void 0) { is_offset = true; }
1014	if (animate === void 0) { animate = self.config.animate; }
1015	if (from_keyboard === void 0) { from_keyboard = false; }
1016	var delta = is_offset ? value : value - self.currentMonth;
1017	if ((delta < 0 && self._hidePrevMonthArrow) \|\|
1018	(delta > 0 && self._hideNextMonthArrow))
1019	return;
1020	self.currentMonth += delta;
1021	if (self.currentMonth < 0 \|\| self.currentMonth > 11) {
1022	self.currentYear += self.currentMonth > 11 ? 1 : -1;
1023	self.currentMonth = (self.currentMonth + 12) % 12;
1024	triggerEvent("onYearChange");
1025	}
1026	buildDays(animate ? delta : undefined);
1027	if (!animate) {
1028	triggerEvent("onMonthChange");
1029	return updateNavigationCurrentMonth();
1030	}
1031	var nav = self.navigationCurrentMonth;
1032	if (delta < 0) {
1033	while (nav.nextSibling &&
1034	/curr/.test(nav.nextSibling.className))
1035	self.monthNav.removeChild(nav.nextSibling);
1036	}
1037	else if (delta > 0) {
1038	while (nav.previousSibling &&
1039	/curr/.test(nav.previousSibling.className))
1040	self.monthNav.removeChild(nav.previousSibling);
1041	}
1042	self.oldCurMonth = self.navigationCurrentMonth;
1043	self.navigationCurrentMonth = self.monthNav.insertBefore(self.oldCurMonth.cloneNode(true), delta > 0 ? self.oldCurMonth.nextSibling : self.oldCurMonth);
1044	var daysContainer = self.daysContainer;
1045	if (daysContainer.firstChild && daysContainer.lastChild) {
1046	if (delta > 0) {
1047	daysContainer.firstChild.classList.add("slideLeft");
1048	daysContainer.lastChild.classList.add("slideLeftNew");
1049	self.oldCurMonth.classList.add("slideLeft");
1050	self.navigationCurrentMonth.classList.add("slideLeftNew");
1051	}
1052	else if (delta < 0) {
1053	daysContainer.firstChild.classList.add("slideRightNew");
1054	daysContainer.lastChild.classList.add("slideRight");
1055	self.oldCurMonth.classList.add("slideRight");
1056	self.navigationCurrentMonth.classList.add("slideRightNew");
1057	}
1058	}
1059	self.currentMonthElement = self.navigationCurrentMonth
1060	.firstChild;
1061	self.currentYearElement = self.navigationCurrentMonth.lastChild
1062	.childNodes[0];
1063	updateNavigationCurrentMonth();
1064	if (self.oldCurMonth.firstChild)
1065	self.oldCurMonth.firstChild.textContent = monthToStr(self.currentMonth - delta, self.config.shorthandCurrentMonth, self.l10n);
1066	afterDayAnim(function () { return triggerEvent("onMonthChange"); });
1067	if (from_keyboard &&
1068	document.activeElement &&
1069	document.activeElement.$i) {
1070	var index_1 = document.activeElement.$i;
1071	afterDayAnim(function () {
1072	focusOnDay(index_1, 0);
1073	});
1074	}
1075	}
1076	function clear(triggerChangeEvent) {
1077	if (triggerChangeEvent === void 0) { triggerChangeEvent = true; }
1078	self.input.value = "";
1079	if (self.altInput)
1080	self.altInput.value = "";
1081	if (self.mobileInput)
1082	self.mobileInput.value = "";
1083	self.selectedDates = [];
1084	self.latestSelectedDateObj = undefined;
1085	self.showTimeInput = false;
1086	self.redraw();
1087	if (triggerChangeEvent)
1088	triggerEvent("onChange");
1089	}
1090	function close() {
1091	self.isOpen = false;
1092	if (!self.isMobile) {
1093	self.calendarContainer.classList.remove("open");
1094	self._input.classList.remove("active");
1095	}
1096	triggerEvent("onClose");
1097	}
1098	function destroy() {
1099	if (self.config !== undefined)
1100	triggerEvent("onDestroy");
1101	for (var i = self._handlers.length; i--;) {
1102	var h = self._handlers[i];
1103	h.element.removeEventListener(h.event, h.handler);
1104	}
1105	self._handlers = [];
1106	if (self.mobileInput) {
1107	if (self.mobileInput.parentNode)
1108	self.mobileInput.parentNode.removeChild(self.mobileInput);
1109	self.mobileInput = undefined;
1110	}
1111	else if (self.calendarContainer && self.calendarContainer.parentNode)
1112	self.calendarContainer.parentNode.removeChild(self.calendarContainer);
1113	if (self.altInput) {
1114	self.input.type = "text";
1115	if (self.altInput.parentNode)
1116	self.altInput.parentNode.removeChild(self.altInput);
1117	delete self.altInput;
1118	}
1119	if (self.input) {
1120	self.input.type = self.input._type;
1121	self.input.classList.remove("flatpickr-input");
1122	self.input.removeAttribute("readonly");
1123	self.input.value = "";
1124	}
1125	[
1126	"_showTimeInput",
1127	"latestSelectedDateObj",
1128	"_hideNextMonthArrow",
1129	"_hidePrevMonthArrow",
1130	"__hideNextMonthArrow",
1131	"__hidePrevMonthArrow",
1132	"isMobile",
1133	"isOpen",
1134	"selectedDateElem",
1135	"minDateHasTime",
1136	"maxDateHasTime",
1137	"days",
1138	"daysContainer",
1139	"_input",
1140	"_positionElement",
1141	"innerContainer",
1142	"rContainer",
1143	"monthNav",
1144	"todayDateElem",
1145	"calendarContainer",
1146	"weekdayContainer",
1147	"prevMonthNav",
1148	"nextMonthNav",
1149	"currentMonthElement",
1150	"currentYearElement",
1151	"navigationCurrentMonth",
1152	"selectedDateElem",
1153	"config",
1154	].forEach(function (k) {
1155	try {
1156	delete self[k];
1157	}
1158	catch (_) { }
1159	});
1160	}
1161	function isCalendarElem(elem) {
1162	if (self.config.appendTo && self.config.appendTo.contains(elem))
1163	return true;
1164	return self.calendarContainer.contains(elem);
1165	}
1166	function documentClick(e) {
1167	if (self.isOpen && !self.config.inline) {
1168	var isCalendarElement = isCalendarElem(e.target);
1169	var isInput = e.target === self.input \|\|
1170	e.target === self.altInput \|\|
1171	self.element.contains(e.target) \|\|
1172	(e.path &&
1173	e.path.indexOf &&
1174	(~e.path.indexOf(self.input) \|\|
1175	~e.path.indexOf(self.altInput)));
1176	var lostFocus = e.type === "blur"
1177	? isInput &&
1178	e.relatedTarget &&
1179	!isCalendarElem(e.relatedTarget)
1180	: !isInput && !isCalendarElement;
1181	if (lostFocus &&
1182	self.config.ignoredFocusElements.indexOf(e.target) === -1) {
1183	self.close();
1184	if (self.config.mode === "range" && self.selectedDates.length === 1) {
1185	self.clear(false);
1186	self.redraw();
1187	}
1188	}
1189	}
1190	}
1191	function changeYear(newYear) {
1192	if (!newYear \|\|
1193	(self.currentYearElement.min &&
1194	newYear < parseInt(self.currentYearElement.min)) \|\|
1195	(self.currentYearElement.max &&
1196	newYear > parseInt(self.currentYearElement.max)))
1197	return;
1198	var newYearNum = newYear, isNewYear = self.currentYear !== newYearNum;
1199	self.currentYear = newYearNum \|\| self.currentYear;
1200	if (self.config.maxDate &&
1201	self.currentYear === self.config.maxDate.getFullYear()) {
1202	self.currentMonth = Math.min(self.config.maxDate.getMonth(), self.currentMonth);
1203	}
1204	else if (self.config.minDate &&
1205	self.currentYear === self.config.minDate.getFullYear()) {
1206	self.currentMonth = Math.max(self.config.minDate.getMonth(), self.currentMonth);
1207	}
1208	if (isNewYear) {
1209	self.redraw();
1210	triggerEvent("onYearChange");
1211	}
1212	}
1213	function isEnabled(date, timeless) {
1214	if (timeless === void 0) { timeless = true; }
1215	var dateToCheck = self.parseDate(date, undefined, timeless);
1216	if ((self.config.minDate &&
1217	dateToCheck &&
1218	compareDates(dateToCheck, self.config.minDate, timeless !== undefined ? timeless : !self.minDateHasTime) < 0) \|\|
1219	(self.config.maxDate &&
1220	dateToCheck &&
1221	compareDates(dateToCheck, self.config.maxDate, timeless !== undefined ? timeless : !self.maxDateHasTime) > 0))
1222	return false;
1223	if (!self.config.enable.length && !self.config.disable.length)
1224	return true;
1225	if (dateToCheck === undefined)
1226	return false;
1227	var bool = self.config.enable.length > 0, array = bool ? self.config.enable : self.config.disable;
1228	for (var i = 0, d = void 0; i < array.length; i++) {
1229	d = array[i];
1230	if (typeof d === "function" &&
1231	d(dateToCheck))
1232	return bool;
1233	else if (d instanceof Date &&
1234	dateToCheck !== undefined &&
1235	d.getTime() === dateToCheck.getTime())
1236	return bool;
1237	else if (typeof d === "string" && dateToCheck !== undefined) {
1238	var parsed = self.parseDate(d, undefined, true);
1239	return parsed && parsed.getTime() === dateToCheck.getTime()
1240	? bool
1241	: !bool;
1242	}
1243	else if (typeof d === "object" &&
1244	dateToCheck !== undefined &&
1245	d.from &&
1246	d.to &&
1247	dateToCheck.getTime() >= d.from.getTime() &&
1248	dateToCheck.getTime() <= d.to.getTime())
1249	return bool;
1250	}
1251	return !bool;
1252	}
1253	function onKeyDown(e) {
1254	var isInput = e.target === self._input;
1255	var calendarElem = isCalendarElem(e.target);
1256	var allowInput = self.config.allowInput;
1257	var allowKeydown = self.isOpen && (!allowInput \|\| !isInput);
1258	var allowInlineKeydown = self.config.inline && isInput && !allowInput;
1259	if (e.key === "Enter" && isInput) {
1260	if (allowInput) {
1261	self.setDate(self._input.value, true, e.target === self.altInput
1262	? self.config.altFormat
1263	: self.config.dateFormat);
1264	return e.target.blur();
1265	}
1266	else
1267	self.open();
1268	}
1269	else if (calendarElem \|\| allowKeydown \|\| allowInlineKeydown) {
1270	var isTimeObj = !!self.timeContainer &&
1271	self.timeContainer.contains(e.target);
1272	switch (e.key) {
1273	case "Enter":
1274	if (isTimeObj)
1275	updateValue();
1276	else
1277	selectDate(e);
1278	break;
1279	case "Escape":
1280	e.preventDefault();
1281	self.close();
1282	break;
1283	case "Backspace":
1284	case "Delete":
1285	if (isInput && !self.config.allowInput)
1286	self.clear();
1287	break;
1288	case "ArrowLeft":
1289	case "ArrowRight":
1290	if (!isTimeObj) {
1291	e.preventDefault();
1292	if (self.daysContainer) {
1293	var delta_1 = e.key === "ArrowRight" ? 1 : -1;
1294	if (!e.ctrlKey)
1295	focusOnDay(e.target.$i, delta_1);
1296	else
1297	changeMonth(delta_1, true, undefined, true);
1298	}
1299	}
1300	else if (self.hourElement)
1301	self.hourElement.focus();
1302	break;
1303	case "ArrowUp":
1304	case "ArrowDown":
1305	e.preventDefault();
1306	var delta = e.key === "ArrowDown" ? 1 : -1;
1307	if (self.daysContainer && e.target.$i !== undefined) {
1308	if (e.ctrlKey) {
1309	changeYear(self.currentYear - delta);
1310	focusOnDay(e.target.$i, 0);
1311	}
1312	else if (!isTimeObj)
1313	focusOnDay(e.target.$i, delta * 7);
1314	}
1315	else if (self.config.enableTime) {
1316	if (!isTimeObj && self.hourElement)
1317	self.hourElement.focus();
1318	updateTime(e);
1319	self._debouncedChange();
1320	}
1321	break;
1322	case "Tab":
1323	if (e.target === self.hourElement) {
1324	e.preventDefault();
1325	self.minuteElement.select();
1326	}
1327	else if (e.target === self.minuteElement &&
1328	(self.secondElement \|\| self.amPM)) {
1329	e.preventDefault();
1330	if (self.secondElement !== undefined)
1331	self.secondElement.focus();
1332	else if (self.amPM !== undefined)
1333	self.amPM.focus();
1334	}
1335	else if (e.target === self.secondElement && self.amPM) {
1336	e.preventDefault();
1337	self.amPM.focus();
1338	}
1339	break;
1340	case self.l10n.amPM[0].charAt(0):
1341	if (self.amPM !== undefined && e.target === self.amPM) {
1342	self.amPM.textContent = self.l10n.amPM[0];
1343	setHoursFromInputs();
1344	updateValue();
1345	}
1346	break;
1347	case self.l10n.amPM[1].charAt(0):
1348	if (self.amPM !== undefined && e.target === self.amPM) {
1349	self.amPM.textContent = self.l10n.amPM[1];
1350	setHoursFromInputs();
1351	updateValue();
1352	}
1353	break;
1354	default:
1355	break;
1356	}
1357	triggerEvent("onKeyDown", e);
1358	}
1359	}
1360	function onMouseOver(elem) {
1361	if (self.selectedDates.length !== 1 \|\|
1362	!elem.classList.contains("flatpickr-day") \|\|
1363	self.minRangeDate === undefined \|\|
1364	self.maxRangeDate === undefined)
1365	return;
1366	var hoverDate = elem.dateObj, initialDate = self.parseDate(self.selectedDates[0], undefined, true), rangeStartDate = Math.min(hoverDate.getTime(), self.selectedDates[0].getTime()), rangeEndDate = Math.max(hoverDate.getTime(), self.selectedDates[0].getTime()), containsDisabled = false;
1367	for (var t = rangeStartDate; t < rangeEndDate; t += duration.DAY) {
1368	if (!isEnabled(new Date(t))) {
1369	containsDisabled = true;
1370	break;
1371	}
1372	}
1373	var _loop_1 = function (i, date) {
1374	var timestamp = date.getTime();
1375	var outOfRange = timestamp < self.minRangeDate.getTime() \|\|
1376	timestamp > self.maxRangeDate.getTime(), dayElem = self.days.childNodes[i];
1377	if (outOfRange) {
1378	dayElem.classList.add("notAllowed");
1379	["inRange", "startRange", "endRange"].forEach(function (c) {
1380	dayElem.classList.remove(c);
1381	});
1382	return "continue";
1383	}
1384	else if (containsDisabled && !outOfRange)
1385	return "continue";
1386	["startRange", "inRange", "endRange", "notAllowed"].forEach(function (c) {
1387	dayElem.classList.remove(c);
1388	});
1389	var minRangeDate = Math.max(self.minRangeDate.getTime(), rangeStartDate), maxRangeDate = Math.min(self.maxRangeDate.getTime(), rangeEndDate);
1390	elem.classList.add(hoverDate < self.selectedDates[0] ? "startRange" : "endRange");
1391	if (initialDate < hoverDate && timestamp === initialDate.getTime())
1392	dayElem.classList.add("startRange");
1393	else if (initialDate > hoverDate && timestamp === initialDate.getTime())
1394	dayElem.classList.add("endRange");
1395	if (timestamp >= minRangeDate && timestamp <= maxRangeDate)
1396	dayElem.classList.add("inRange");
1397	};
1398	for (var i = 0, date = self.days.childNodes[i].dateObj; i < 42; i++, date =
1399	self.days.childNodes[i] &&
1400	self.days.childNodes[i].dateObj) {
1401	_loop_1(i, date);
1402	}
1403	}
1404	function onResize() {
1405	if (self.isOpen && !self.config.static && !self.config.inline)
1406	positionCalendar();
1407	}
1408	function open(e, positionElement) {
1409	if (positionElement === void 0) { positionElement = self._input; }
1410	if (self.isMobile) {
1411	if (e) {
1412	e.preventDefault();
1413	e.target && e.target.blur();
1414	}
1415	setTimeout(function () {
1416	self.mobileInput !== undefined && self.mobileInput.click();
1417	}, 0);
1418	triggerEvent("onOpen");
1419	return;
1420	}
1421	if (self._input.disabled \|\| self.config.inline)
1422	return;
1423	var wasOpen = self.isOpen;
1424	self.isOpen = true;
1425	positionCalendar(positionElement);
1426	self.calendarContainer.classList.add("open");
1427	self._input.classList.add("active");
1428	!wasOpen && triggerEvent("onOpen");
1429	}
1430	function minMaxDateSetter(type) {
1431	return function (date) {
1432	var dateObj = (self.config["_" + type + "Date"] = self.parseDate(date));
1433	var inverseDateObj = self.config["_" + (type === "min" ? "max" : "min") + "Date"];
1434	if (dateObj !== undefined) {
1435	self[type === "min" ? "minDateHasTime" : "maxDateHasTime"] =
1436	dateObj.getHours() > 0 \|\|
1437	dateObj.getMinutes() > 0 \|\|
1438	dateObj.getSeconds() > 0;
1439	}
1440	if (self.selectedDates) {
1441	self.selectedDates = self.selectedDates.filter(function (d) { return isEnabled(d); });
1442	if (!self.selectedDates.length && type === "min")
1443	setHoursFromDate(dateObj);
1444	updateValue();
1445	}
1446	if (self.daysContainer) {
1447	redraw();
1448	if (dateObj !== undefined)
1449	self.currentYearElement[type] = dateObj.getFullYear().toString();
1450	else
1451	self.currentYearElement.removeAttribute(type);
1452	self.currentYearElement.disabled =
1453	!!inverseDateObj &&
1454	dateObj !== undefined &&
1455	inverseDateObj.getFullYear() === dateObj.getFullYear();
1456	}
1457	};
1458	}
1459	function parseConfig() {
1460	var boolOpts = [
1461	"wrap",
1462	"weekNumbers",
1463	"allowInput",
1464	"clickOpens",
1465	"time_24hr",
1466	"enableTime",
1467	"noCalendar",
1468	"altInput",
1469	"shorthandCurrentMonth",
1470	"inline",
1471	"static",
1472	"enableSeconds",
1473	"disableMobile",
1474	];
1475	var hooks = [
1476	"onChange",
1477	"onClose",
1478	"onDayCreate",
1479	"onDestroy",
1480	"onKeyDown",
1481	"onMonthChange",
1482	"onOpen",
1483	"onParseConfig",
1484	"onReady",
1485	"onValueUpdate",
1486	"onYearChange",
1487	];
1488	self.config = __assign({}, flatpickr.defaultConfig);
1489	var userConfig = __assign({}, instanceConfig, JSON.parse(JSON.stringify(element.dataset \|\| {})));
1490	var formats$$1 = {};
1491	Object.defineProperty(self.config, "enable", {
1492	get: function () { return self.config._enable \|\| []; },
1493	set: function (dates) {
1494	self.config._enable = parseDateRules(dates);
1495	},
1496	});
1497	Object.defineProperty(self.config, "disable", {
1498	get: function () { return self.config._disable \|\| []; },
1499	set: function (dates) {
1500	self.config._disable = parseDateRules(dates);
1501	},
1502	});
1503	if (!userConfig.dateFormat && userConfig.enableTime) {
1504	formats$$1.dateFormat = userConfig.noCalendar
1505	? "H:i" + (userConfig.enableSeconds ? ":S" : "")
1506	: flatpickr.defaultConfig.dateFormat +
1507	" H:i" +
1508	(userConfig.enableSeconds ? ":S" : "");
1509	}
1510	if (userConfig.altInput && userConfig.enableTime && !userConfig.altFormat) {
1511	formats$$1.altFormat = userConfig.noCalendar
1512	? "h:i" + (userConfig.enableSeconds ? ":S K" : " K")
1513	: flatpickr.defaultConfig.altFormat +
1514	(" h:i" + (userConfig.enableSeconds ? ":S" : "") + " K");
1515	}
1516	Object.defineProperty(self.config, "minDate", {
1517	get: function () { return self.config._minDate; },
1518	set: minMaxDateSetter("min"),
1519	});
1520	Object.defineProperty(self.config, "maxDate", {
1521	get: function () { return self.config._maxDate; },
1522	set: minMaxDateSetter("max"),
1523	});
1524	Object.assign(self.config, formats$$1, userConfig);
1525	for (var i = 0; i < boolOpts.length; i++)
1526	self.config[boolOpts[i]] =
1527	self.config[boolOpts[i]] === true \|\|
1528	self.config[boolOpts[i]] === "true";
1529	for (var i = hooks.length; i--;) {
1530	if (self.config[hooks[i]] !== undefined) {
1531	self.config[hooks[i]] = arrayify(self.config[hooks[i]] \|\| []).map(bindToInstance);
1532	}
1533	}
1534	for (var i = 0; i < self.config.plugins.length; i++) {
1535	var pluginConf = self.config.plugins[i](self) \|\| {};
1536	for (var key in pluginConf) {
1537	if (~hooks.indexOf(key)) {
1538	self.config[key] = arrayify(pluginConf[key])
1539	.map(bindToInstance)
1540	.concat(self.config[key]);
1541	}
1542	else if (typeof userConfig[key] === "undefined")
1543	self.config[key] = pluginConf[key];
1544	}
1545	}
1546	self.isMobile =
1547	!self.config.disableMobile &&
1548	!self.config.inline &&
1549	self.config.mode === "single" &&
1550	!self.config.disable.length &&
1551	!self.config.enable.length &&
1552	!self.config.weekNumbers &&
1553	/Android\|webOS\|iPhone\|iPad\|iPod\|BlackBerry\|IEMobile\|Opera Mini/i.test(navigator.userAgent);
1554	triggerEvent("onParseConfig");
1555	}
1556	function setupLocale() {
1557	if (typeof self.config.locale !== "object" &&
1558	typeof flatpickr.l10ns[self.config.locale] === "undefined")
1559	self.config.errorHandler(new Error("flatpickr: invalid locale " + self.config.locale));
1560	self.l10n = __assign({}, flatpickr.l10ns.default, typeof self.config.locale === "object"
1561	? self.config.locale
1562	: self.config.locale !== "default"
1563	? flatpickr.l10ns[self.config.locale]
1564	: undefined);
1565	tokenRegex.K = "(" + self.l10n.amPM[0] + "\|" + self.l10n.amPM[1] + "\|" + self.l10n.amPM[0].toLowerCase() + "\|" + self.l10n.amPM[1].toLowerCase() + ")";
1566	}
1567	function positionCalendar(positionElement) {
1568	if (positionElement === void 0) { positionElement = self._positionElement; }
1569	if (self.calendarContainer === undefined)
1570	return;
1571	var calendarHeight = self.calendarContainer.offsetHeight, calendarWidth = self.calendarContainer.offsetWidth, configPos = self.config.position, inputBounds = positionElement.getBoundingClientRect(), distanceFromBottom = window.innerHeight - inputBounds.bottom, showOnTop = configPos === "above" \|\|
1572	(configPos !== "below" &&
1573	distanceFromBottom < calendarHeight &&
1574	inputBounds.top > calendarHeight);
1575	var top = window.pageYOffset +
1576	inputBounds.top +
1577	(!showOnTop ? positionElement.offsetHeight + 2 : -calendarHeight - 2);
1578	toggleClass(self.calendarContainer, "arrowTop", !showOnTop);
1579	toggleClass(self.calendarContainer, "arrowBottom", showOnTop);
1580	if (self.config.inline)
1581	return;
1582	var left = window.pageXOffset + inputBounds.left;
1583	var right = window.document.body.offsetWidth - inputBounds.right;
1584	var rightMost = left + calendarWidth > window.document.body.offsetWidth;
1585	toggleClass(self.calendarContainer, "rightMost", rightMost);
1586	if (self.config.static)
1587	return;
1588	self.calendarContainer.style.top = top + "px";
1589	if (!rightMost) {
1590	self.calendarContainer.style.left = left + "px";
1591	self.calendarContainer.style.right = "auto";
1592	}
1593	else {
1594	self.calendarContainer.style.left = "auto";
1595	self.calendarContainer.style.right = right + "px";
1596	}
1597	}
1598	function redraw() {
1599	if (self.config.noCalendar \|\| self.isMobile)
1600	return;
1601	buildWeekdays();
1602	updateNavigationCurrentMonth();
1603	buildDays();
1604	}
1605	function selectDate(e) {
1606	e.preventDefault();
1607	e.stopPropagation();
1608	var isSelectable = function (day) {
1609	return day.classList &&
1610	day.classList.contains("flatpickr-day") &&
1611	!day.classList.contains("disabled") &&
1612	!day.classList.contains("notAllowed");
1613	};
1614	var t = findParent(e.target, isSelectable);
1615	if (t === undefined)
1616	return;
1617	var target = t;
1618	var selectedDate = (self.latestSelectedDateObj = new Date(target.dateObj.getTime()));
1619	var shouldChangeMonth = selectedDate.getMonth() !== self.currentMonth &&
1620	self.config.mode !== "range";
1621	self.selectedDateElem = target;
1622	if (self.config.mode === "single")
1623	self.selectedDates = [selectedDate];
1624	else if (self.config.mode === "multiple") {
1625	var selectedIndex = isDateSelected(selectedDate);
1626	if (selectedIndex)
1627	self.selectedDates.splice(parseInt(selectedIndex), 1);
1628	else
1629	self.selectedDates.push(selectedDate);
1630	}
1631	else if (self.config.mode === "range") {
1632	if (self.selectedDates.length === 2)
1633	self.clear();
1634	self.selectedDates.push(selectedDate);
1635	if (compareDates(selectedDate, self.selectedDates[0], true) !== 0)
1636	self.selectedDates.sort(function (a, b) { return a.getTime() - b.getTime(); });
1637	}
1638	setHoursFromInputs();
1639	if (shouldChangeMonth) {
1640	var isNewYear = self.currentYear !== selectedDate.getFullYear();
1641	self.currentYear = selectedDate.getFullYear();
1642	self.currentMonth = selectedDate.getMonth();
1643	if (isNewYear)
1644	triggerEvent("onYearChange");
1645	triggerEvent("onMonthChange");
1646	}
1647	buildDays();
1648	if (self.config.minDate &&
1649	self.minDateHasTime &&
1650	self.config.enableTime &&
1651	compareDates(selectedDate, self.config.minDate) === 0)
1652	setHoursFromDate(self.config.minDate);
1653	updateValue();
1654	if (self.config.enableTime)
1655	setTimeout(function () { return (self.showTimeInput = true); }, 50);
1656	if (self.config.mode === "range") {
1657	if (self.selectedDates.length === 1) {
1658	onMouseOver(target);
1659	self._hidePrevMonthArrow =
1660	self._hidePrevMonthArrow \|\|
1661	(self.minRangeDate !== undefined &&
1662	self.minRangeDate >
1663	self.days.childNodes[0].dateObj);
1664	self._hideNextMonthArrow =
1665	self._hideNextMonthArrow \|\|
1666	(self.maxRangeDate !== undefined &&
1667	self.maxRangeDate <
1668	new Date(self.currentYear, self.currentMonth + 1, 1));
1669	}
1670	else
1671	updateNavigationCurrentMonth();
1672	}
1673	triggerEvent("onChange");
1674	if (!shouldChangeMonth)
1675	focusOnDay(target.$i, 0);
1676	else
1677	afterDayAnim(function () { return self.selectedDateElem && self.selectedDateElem.focus(); });
1678	if (self.hourElement !== undefined)
1679	setTimeout(function () { return self.hourElement !== undefined && self.hourElement.select(); }, 451);
1680	if (self.config.closeOnSelect) {
1681	var single = self.config.mode === "single" && !self.config.enableTime;
1682	var range = self.config.mode === "range" &&
1683	self.selectedDates.length === 2 &&
1684	!self.config.enableTime;
1685	if (single \|\| range)
1686	self.close();
1687	}
1688	}
1689	function set(option, value) {
1690	if (option !== null && typeof option === "object")
1691	Object.assign(self.config, option);
1692	else
1693	self.config[option] = value;
1694	self.redraw();
1695	jumpToDate();
1696	}
1697	function setSelectedDate(inputDate, format) {
1698	var dates = [];
1699	if (inputDate instanceof Array)
1700	dates = inputDate.map(function (d) { return self.parseDate(d, format); });
1701	else if (inputDate instanceof Date \|\| typeof inputDate === "number")
1702	dates = [self.parseDate(inputDate, format)];
1703	else if (typeof inputDate === "string") {
1704	switch (self.config.mode) {
1705	case "single":
1706	dates = [self.parseDate(inputDate, format)];
1707	break;
1708	case "multiple":
1709	dates = inputDate
1710	.split(self.config.conjunction)
1711	.map(function (date) { return self.parseDate(date, format); });
1712	break;
1713	case "range":
1714	dates = inputDate
1715	.split(self.l10n.rangeSeparator)
1716	.map(function (date) { return self.parseDate(date, format); });
1717	break;
1718	default:
1719	break;
1720	}
1721	}
1722	else
1723	self.config.errorHandler(new Error("Invalid date supplied: " + JSON.stringify(inputDate)));
1724	self.selectedDates = dates.filter(function (d) { return d instanceof Date && isEnabled(d, false); });
1725	self.selectedDates.sort(function (a, b) { return a.getTime() - b.getTime(); });
1726	}
1727	function setDate(date, triggerChange, format) {
1728	if (triggerChange === void 0) { triggerChange = false; }
1729	if (date !== 0 && !date)
1730	return self.clear(triggerChange);
1731	setSelectedDate(date, format);
1732	self.showTimeInput = self.selectedDates.length > 0;
1733	self.latestSelectedDateObj = self.selectedDates[0];
1734	self.redraw();
1735	jumpToDate();
1736	setHoursFromDate();
1737	updateValue(triggerChange);
1738	if (triggerChange)
1739	triggerEvent("onChange");
1740	}
1741	function parseDateRules(arr) {
1742	return arr
1743	.map(function (rule) {
1744	if (typeof rule === "string" \|\|
1745	typeof rule === "number" \|\|
1746	rule instanceof Date) {
1747	return self.parseDate(rule, undefined, true);
1748	}
1749	else if (rule &&
1750	typeof rule === "object" &&
1751	rule.from &&
1752	rule.to)
1753	return {
1754	from: self.parseDate(rule.from, undefined),
1755	to: self.parseDate(rule.to, undefined),
1756	};
1757	return rule;
1758	})
1759	.filter(function (x) { return x; });
1760	}
1761	function setupDates() {
1762	self.selectedDates = [];
1763	self.now = new Date();
1764	var preloadedDate = self.config.defaultDate \|\| self.input.value;
1765	if (preloadedDate)
1766	setSelectedDate(preloadedDate, self.config.dateFormat);
1767	var initialDate = self.selectedDates.length
1768	? self.selectedDates[0]
1769	: self.config.minDate &&
1770	self.config.minDate.getTime() > self.now.getTime()
1771	? self.config.minDate
1772	: self.config.maxDate &&
1773	self.config.maxDate.getTime() < self.now.getTime()
1774	? self.config.maxDate
1775	: self.now;
1776	self.currentYear = initialDate.getFullYear();
1777	self.currentMonth = initialDate.getMonth();
1778	if (self.selectedDates.length)
1779	self.latestSelectedDateObj = self.selectedDates[0];
1780	self.minDateHasTime =
1781	!!self.config.minDate &&
1782	(self.config.minDate.getHours() > 0 \|\|
1783	self.config.minDate.getMinutes() > 0 \|\|
1784	self.config.minDate.getSeconds() > 0);
1785	self.maxDateHasTime =
1786	!!self.config.maxDate &&
1787	(self.config.maxDate.getHours() > 0 \|\|
1788	self.config.maxDate.getMinutes() > 0 \|\|
1789	self.config.maxDate.getSeconds() > 0);
1790	Object.defineProperty(self, "showTimeInput", {
1791	get: function () { return self._showTimeInput; },
1792	set: function (bool) {
1793	self._showTimeInput = bool;
1794	if (self.calendarContainer)
1795	toggleClass(self.calendarContainer, "showTimeInput", bool);
1796	positionCalendar();
1797	},
1798	});
1799	}
1800	function formatDate(dateObj, frmt) {
1801	if (self.config !== undefined && self.config.formatDate !== undefined)
1802	return self.config.formatDate(dateObj, frmt);
1803	return frmt
1804	.split("")
1805	.map(function (c, i, arr) {
1806	return formats[c] && arr[i - 1] !== "\\"
1807	? formats[c](dateObj, self.l10n, self.config)
1808	: c !== "\\" ? c : "";
1809	})
1810	.join("");
1811	}
1812	function parseDate(date, givenFormat, timeless) {
1813	if (date !== 0 && !date)
1814	return undefined;
1815	var parsedDate;
1816	var date_orig = date;
1817	if (date instanceof Date)
1818	parsedDate = new Date(date.getTime());
1819	else if (typeof date !== "string" &&
1820	date.toFixed !== undefined)
1821	parsedDate = new Date(date);
1822	else if (typeof date === "string") {
1823	var format = givenFormat \|\| (self.config \|\| flatpickr.defaultConfig).dateFormat;
1824	var datestr = String(date).trim();
1825	if (datestr === "today") {
1826	parsedDate = new Date();
1827	timeless = true;
1828	}
1829	else if (/Z$/.test(datestr) \|\|
1830	/GMT$/.test(datestr))
1831	parsedDate = new Date(date);
1832	else if (self.config && self.config.parseDate)
1833	parsedDate = self.config.parseDate(date, format);
1834	else {
1835	parsedDate =
1836	!self.config \|\| !self.config.noCalendar
1837	? new Date(new Date().getFullYear(), 0, 1, 0, 0, 0, 0)
1838	: new Date(new Date().setHours(0, 0, 0, 0));
1839	var matched = void 0, ops = [];
1840	for (var i = 0, matchIndex = 0, regexStr = ""; i < format.length; i++) {
1841	var token = format[i];
1842	var isBackSlash = token === "\\";
1843	var escaped = format[i - 1] === "\\" \|\| isBackSlash;
1844	if (tokenRegex[token] && !escaped) {
1845	regexStr += tokenRegex[token];
1846	var match = new RegExp(regexStr).exec(date);
1847	if (match && (matched = true)) {
1848	ops[token !== "Y" ? "push" : "unshift"]({
1849	fn: revFormat[token],
1850	val: match[++matchIndex],
1851	});
1852	}
1853	}
1854	else if (!isBackSlash)
1855	regexStr += ".";
1856	ops.forEach(function (_a) {
1857	var fn = _a.fn, val = _a.val;
1858	return (parsedDate =
1859	fn(parsedDate, val, self.l10n) \|\| parsedDate);
1860	});
1861	}
1862	parsedDate = matched ? parsedDate : undefined;
1863	}
1864	}
1865	if (!(parsedDate instanceof Date)) {
1866	self.config.errorHandler(new Error("Invalid date provided: " + date_orig));
1867	return undefined;
1868	}
1869	if (timeless === true)
1870	parsedDate.setHours(0, 0, 0, 0);
1871	return parsedDate;
1872	}
1873	function setupInputs() {
1874	self.input = self.config.wrap
1875	? element.querySelector("[data-input]")
1876	: element;
1877	if (!self.input) {
1878	self.config.errorHandler(new Error("Invalid input element specified"));
1879	return;
1880	}
1881	self.input._type = self.input.type;
1882	self.input.type = "text";
1883	self.input.classList.add("flatpickr-input");
1884	self._input = self.input;
1885	if (self.config.altInput) {
1886	self.altInput = createElement(self.input.nodeName, self.input.className + " " + self.config.altInputClass);
1887	self._input = self.altInput;
1888	self.altInput.placeholder = self.input.placeholder;
1889	self.altInput.disabled = self.input.disabled;
1890	self.altInput.required = self.input.required;
1891	self.altInput.type = "text";
1892	self.input.type = "hidden";
1893	if (!self.config.static && self.input.parentNode)
1894	self.input.parentNode.insertBefore(self.altInput, self.input.nextSibling);
1895	}
1896	if (!self.config.allowInput)
1897	self._input.setAttribute("readonly", "readonly");
1898	self._positionElement = self.config.positionElement \|\| self._input;
1899	}
1900	function setupMobile() {
1901	var inputType = self.config.enableTime
1902	? self.config.noCalendar ? "time" : "datetime-local"
1903	: "date";
1904	self.mobileInput = createElement("input", self.input.className + " flatpickr-mobile");
1905	self.mobileInput.step = self.input.getAttribute("step") \|\| "any";
1906	self.mobileInput.tabIndex = 1;
1907	self.mobileInput.type = inputType;
1908	self.mobileInput.disabled = self.input.disabled;
1909	self.mobileInput.placeholder = self.input.placeholder;
1910	self.mobileFormatStr =
1911	inputType === "datetime-local"
1912	? "Y-m-d\\TH:i:S"
1913	: inputType === "date" ? "Y-m-d" : "H:i:S";
1914	if (self.selectedDates.length) {
1915	self.mobileInput.defaultValue = self.mobileInput.value = self.formatDate(self.selectedDates[0], self.mobileFormatStr);
1916	}
1917	if (self.config.minDate)
1918	self.mobileInput.min = self.formatDate(self.config.minDate, "Y-m-d");
1919	if (self.config.maxDate)
1920	self.mobileInput.max = self.formatDate(self.config.maxDate, "Y-m-d");
1921	self.input.type = "hidden";
1922	if (self.altInput !== undefined)
1923	self.altInput.type = "hidden";
1924	try {
1925	if (self.input.parentNode)
1926	self.input.parentNode.insertBefore(self.mobileInput, self.input.nextSibling);
1927	}
1928	catch (_a) { }
1929	bind(self.mobileInput, "change", function (e) {
1930	self.setDate(e.target.value, false, self.mobileFormatStr);
1931	triggerEvent("onChange");
1932	triggerEvent("onClose");
1933	});
1934	}
1935	function toggle() {
1936	if (self.isOpen)
1937	return self.close();
1938	self.open();
1939	}
1940	function triggerEvent(event, data) {
1941	var hooks = self.config[event];
1942	if (hooks !== undefined && hooks.length > 0) {
1943	for (var i = 0; hooks[i] && i < hooks.length; i++)
1944	hooks[i](self.selectedDates, self.input.value, self, data);
1945	}
1946	if (event === "onChange") {
1947	self.input.dispatchEvent(createEvent("change"));
1948	self.input.dispatchEvent(createEvent("input"));
1949	}
1950	}
1951	function createEvent(name) {
1952	var e = document.createEvent("Event");
1953	e.initEvent(name, true, true);
1954	return e;
1955	}
1956	function isDateSelected(date) {
1957	for (var i = 0; i < self.selectedDates.length; i++) {
1958	if (compareDates(self.selectedDates[i], date) === 0)
1959	return "" + i;
1960	}
1961	return false;
1962	}
1963	function isDateInRange(date) {
1964	if (self.config.mode !== "range" \|\| self.selectedDates.length < 2)
1965	return false;
1966	return (compareDates(date, self.selectedDates[0]) >= 0 &&
1967	compareDates(date, self.selectedDates[1]) <= 0);
1968	}
1969	function updateNavigationCurrentMonth() {
1970	if (self.config.noCalendar \|\| self.isMobile \|\| !self.monthNav)
1971	return;
1972	self.currentMonthElement.textContent =
1973	monthToStr(self.currentMonth, self.config.shorthandCurrentMonth, self.l10n) + " ";
1974	self.currentYearElement.value = self.currentYear.toString();
1975	self._hidePrevMonthArrow =
1976	self.config.minDate !== undefined &&
1977	(self.currentYear === self.config.minDate.getFullYear()
1978	? self.currentMonth <= self.config.minDate.getMonth()
1979	: self.currentYear < self.config.minDate.getFullYear());
1980	self._hideNextMonthArrow =
1981	self.config.maxDate !== undefined &&
1982	(self.currentYear === self.config.maxDate.getFullYear()
1983	? self.currentMonth + 1 > self.config.maxDate.getMonth()
1984	: self.currentYear > self.config.maxDate.getFullYear());
1985	}
1986	function updateValue(triggerChange) {
1987	if (triggerChange === void 0) { triggerChange = true; }
1988	if (!self.selectedDates.length)
1989	return self.clear(triggerChange);
1990	if (self.mobileInput !== undefined && self.mobileFormatStr) {
1991	self.mobileInput.value =
1992	self.latestSelectedDateObj !== undefined
1993	? self.formatDate(self.latestSelectedDateObj, self.mobileFormatStr)
1994	: "";
1995	}
1996	var joinChar = self.config.mode !== "range"
1997	? self.config.conjunction
1998	: self.l10n.rangeSeparator;
1999	self.input.value = self.selectedDates
2000	.map(function (dObj) { return self.formatDate(dObj, self.config.dateFormat); })
2001	.join(joinChar);
2002	if (self.altInput !== undefined) {
2003	self.altInput.value = self.selectedDates
2004	.map(function (dObj) { return self.formatDate(dObj, self.config.altFormat); })
2005	.join(joinChar);
2006	}
2007	if (triggerChange !== false)
2008	triggerEvent("onValueUpdate");
2009	}
2010	function onMonthNavScroll(e) {
2011	e.preventDefault();
2012	var isYear = self.currentYearElement.parentNode &&
2013	self.currentYearElement.parentNode.contains(e.target);
2014	if (e.target === self.currentMonthElement \|\| isYear) {
2015	var delta = mouseDelta(e);
2016	if (isYear) {
2017	changeYear(self.currentYear + delta);
2018	e.target.value = self.currentYear.toString();
2019	}
2020	else
2021	self.changeMonth(delta, true, false);
2022	}
2023	}
2024	function onMonthNavClick(e) {
2025	var isPrevMonth = self.prevMonthNav.contains(e.target);
2026	var isNextMonth = self.nextMonthNav.contains(e.target);
2027	if (isPrevMonth \|\| isNextMonth)
2028	changeMonth(isPrevMonth ? -1 : 1);
2029	else if (e.target === self.currentYearElement) {
2030	e.preventDefault();
2031	self.currentYearElement.select();
2032	}
2033	else if (e.target.className === "arrowUp")
2034	self.changeYear(self.currentYear + 1);
2035	else if (e.target.className === "arrowDown")
2036	self.changeYear(self.currentYear - 1);
2037	}
2038	function timeWrapper(e) {
2039	e.preventDefault();
2040	var isKeyDown = e.type === "keydown", input = e.target;
2041	if (self.amPM !== undefined && e.target === self.amPM) {
2042	self.amPM.textContent =
2043	self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])];
2044	}
2045	var min = Number(input.min), max = Number(input.max), step = Number(input.step), curValue = parseInt(input.value, 10), delta = e.delta \|\|
2046	(isKeyDown
2047	? e.which === 38 ? 1 : -1
2048	: Math.max(-1, Math.min(1, e.wheelDelta \|\| -e.deltaY)) \|\| 0);
2049	var newValue = curValue + step * delta;
2050	if (typeof input.value !== "undefined" && input.value.length === 2) {
2051	var isHourElem = input === self.hourElement, isMinuteElem = input === self.minuteElement;
2052	if (newValue < min) {
2053	newValue =
2054	max +
2055	newValue +
2056	int(!isHourElem) +
2057	(int(isHourElem) && int(!self.amPM));
2058	if (isMinuteElem)
2059	incrementNumInput(undefined, -1, self.hourElement);
2060	}
2061	else if (newValue > max) {
2062	newValue =
2063	input === self.hourElement ? newValue - max - int(!self.amPM) : min;
2064	if (isMinuteElem)
2065	incrementNumInput(undefined, 1, self.hourElement);
2066	}
2067	if (self.amPM &&
2068	isHourElem &&
2069	(step === 1
2070	? newValue + curValue === 23
2071	: Math.abs(newValue - curValue) > step)) {
2072	self.amPM.textContent =
2073	self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])];
2074	}
2075	input.value = pad(newValue);
2076	}
2077	}
2078	init();
2079	return self;
2080	}
2081	function _flatpickr(nodeList, config) {
2082	var nodes = Array.prototype.slice.call(nodeList);
2083	var instances = [];
2084	for (var i = 0; i < nodes.length; i++) {
2085	var node = nodes[i];
2086	try {
2087	if (node.getAttribute("data-fp-omit") !== null)
2088	continue;
2089	if (node._flatpickr !== undefined) {
2090	node._flatpickr.destroy();
2091	node._flatpickr = undefined;
2092	}
2093	node._flatpickr = FlatpickrInstance(node, config \|\| {});
2094	instances.push(node._flatpickr);
2095	}
2096	catch (e) {
2097	console.error(e);
2098	}
2099	}
2100	return instances.length === 1 ? instances[0] : instances;
2101	}
2102	if (typeof HTMLElement !== "undefined") {
2103	HTMLCollection.prototype.flatpickr = NodeList.prototype.flatpickr = function (config) {
2104	return _flatpickr(this, config);
2105	};
2106	HTMLElement.prototype.flatpickr = function (config) {
2107	return _flatpickr([this], config);
2108	};
2109	}
2110	var flatpickr;
2111	flatpickr = function (selector, config) {
2112	if (selector instanceof NodeList)
2113	return _flatpickr(selector, config);
2114	else if (typeof selector === "string")
2115	return _flatpickr(window.document.querySelectorAll(selector), config);
2116	return _flatpickr([selector], config);
2117	};
2118	if (typeof window === "object")
2119	window.flatpickr = flatpickr;
2120	flatpickr.defaultConfig = defaults;
2121	flatpickr.l10ns = {
2122	en: __assign({}, english),
2123	default: __assign({}, english),
2124	};
2125	flatpickr.localize = function (l10n) {
2126	flatpickr.l10ns.default = __assign({}, flatpickr.l10ns.default, l10n);
2127	};
2128	flatpickr.setDefaults = function (config) {
2129	flatpickr.defaultConfig = __assign({}, flatpickr.defaultConfig, config);
2130	};
2131	if (typeof jQuery !== "undefined") {
2132	jQuery.fn.flatpickr = function (config) {
2133	return _flatpickr(this, config);
2134	};
2135	}
2136	Date.prototype.fp_incr = function (days) {
2137	return new Date(this.getFullYear(), this.getMonth(), this.getDate() + (typeof days === "string" ? parseInt(days, 10) : days));
2138	};
2139	var flatpickr$1 = flatpickr;
2140
2141	return flatpickr$1;
2142
2143	})));