flatpickr-ce 0.0.0-stage → 4.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (273) hide show
  1. package/LICENSE.md +21 -0
  2. package/README.md +107 -2
  3. package/dist/esm/index.js +2043 -0
  4. package/dist/esm/l10n/ar-dz.js +48 -0
  5. package/dist/esm/l10n/ar.js +49 -0
  6. package/dist/esm/l10n/at.js +57 -0
  7. package/dist/esm/l10n/az.js +61 -0
  8. package/dist/esm/l10n/be.js +62 -0
  9. package/dist/esm/l10n/bg.js +53 -0
  10. package/dist/esm/l10n/bn.js +51 -0
  11. package/dist/esm/l10n/bs.js +53 -0
  12. package/dist/esm/l10n/cat.js +71 -0
  13. package/dist/esm/l10n/ckb.js +63 -0
  14. package/dist/esm/l10n/cs.js +62 -0
  15. package/dist/esm/l10n/cy.js +79 -0
  16. package/dist/esm/l10n/da.js +58 -0
  17. package/dist/esm/l10n/de.js +57 -0
  18. package/dist/esm/l10n/default.js +72 -0
  19. package/dist/esm/l10n/eo.js +60 -0
  20. package/dist/esm/l10n/es.js +57 -0
  21. package/dist/esm/l10n/et.js +60 -0
  22. package/dist/esm/l10n/fa.js +55 -0
  23. package/dist/esm/l10n/fi.js +56 -0
  24. package/dist/esm/l10n/fo.js +61 -0
  25. package/dist/esm/l10n/fr.js +62 -0
  26. package/dist/esm/l10n/ga.js +53 -0
  27. package/dist/esm/l10n/gr.js +64 -0
  28. package/dist/esm/l10n/he.js +45 -0
  29. package/dist/esm/l10n/hi.js +51 -0
  30. package/dist/esm/l10n/hr.js +53 -0
  31. package/dist/esm/l10n/hu.js +60 -0
  32. package/dist/esm/l10n/hy.js +65 -0
  33. package/dist/esm/l10n/id.js +49 -0
  34. package/dist/esm/l10n/index.js +142 -0
  35. package/dist/esm/l10n/is.js +59 -0
  36. package/dist/esm/l10n/it.js +58 -0
  37. package/dist/esm/l10n/ja.js +58 -0
  38. package/dist/esm/l10n/ka.js +62 -0
  39. package/dist/esm/l10n/km.js +61 -0
  40. package/dist/esm/l10n/ko.js +56 -0
  41. package/dist/esm/l10n/kz.js +61 -0
  42. package/dist/esm/l10n/lt.js +60 -0
  43. package/dist/esm/l10n/lv.js +54 -0
  44. package/dist/esm/l10n/mk.js +55 -0
  45. package/dist/esm/l10n/mn.js +46 -0
  46. package/dist/esm/l10n/ms.js +47 -0
  47. package/dist/esm/l10n/my.js +56 -0
  48. package/dist/esm/l10n/nl.js +62 -0
  49. package/dist/esm/l10n/nn.js +60 -0
  50. package/dist/esm/l10n/no.js +60 -0
  51. package/dist/esm/l10n/pa.js +52 -0
  52. package/dist/esm/l10n/pl.js +60 -0
  53. package/dist/esm/l10n/pt.js +53 -0
  54. package/dist/esm/l10n/ro.js +56 -0
  55. package/dist/esm/l10n/ru.js +62 -0
  56. package/dist/esm/l10n/si.js +52 -0
  57. package/dist/esm/l10n/sk.js +57 -0
  58. package/dist/esm/l10n/sl.js +57 -0
  59. package/dist/esm/l10n/sq.js +59 -0
  60. package/dist/esm/l10n/sr-cyr.js +54 -0
  61. package/dist/esm/l10n/sr.js +55 -0
  62. package/dist/esm/l10n/sv.js +58 -0
  63. package/dist/esm/l10n/th.js +59 -0
  64. package/dist/esm/l10n/tr.js +61 -0
  65. package/dist/esm/l10n/uk.js +53 -0
  66. package/dist/esm/l10n/uz.js +62 -0
  67. package/dist/esm/l10n/uz_latn.js +62 -0
  68. package/dist/esm/l10n/vn.js +53 -0
  69. package/dist/esm/l10n/zh.js +55 -0
  70. package/dist/esm/l10n/zh_tw.js +55 -0
  71. package/dist/esm/plugins/confirmDate/confirmDate.js +68 -0
  72. package/dist/esm/plugins/labelPlugin/labelPlugin.js +22 -0
  73. package/dist/esm/plugins/minMaxTimePlugin.js +77 -0
  74. package/dist/esm/plugins/momentPlugin.js +47 -0
  75. package/dist/esm/plugins/monthSelect/index.js +259 -0
  76. package/dist/esm/plugins/rangePlugin.js +154 -0
  77. package/dist/esm/plugins/scrollPlugin.js +72 -0
  78. package/dist/esm/plugins/weekSelect/weekSelect.js +78 -0
  79. package/dist/esm/types/globals.js +1 -0
  80. package/dist/esm/types/instance.js +1 -0
  81. package/dist/esm/types/locale.js +1 -0
  82. package/dist/esm/types/options.js +83 -0
  83. package/dist/esm/utils/dates.js +143 -0
  84. package/dist/esm/utils/dom.js +58 -0
  85. package/dist/esm/utils/formatting.js +134 -0
  86. package/dist/esm/utils/index.js +17 -0
  87. package/dist/esm/utils/polyfills.js +22 -0
  88. package/dist/flatpickr.css +795 -0
  89. package/dist/flatpickr.js +2724 -0
  90. package/dist/flatpickr.min.css +13 -0
  91. package/dist/flatpickr.min.js +2 -0
  92. package/dist/ie.css +13 -0
  93. package/dist/l10n/ar-dz.d.ts +72 -0
  94. package/dist/l10n/ar-dz.js +61 -0
  95. package/dist/l10n/ar.d.ts +72 -0
  96. package/dist/l10n/ar.js +62 -0
  97. package/dist/l10n/at.d.ts +72 -0
  98. package/dist/l10n/at.js +70 -0
  99. package/dist/l10n/az.d.ts +72 -0
  100. package/dist/l10n/az.js +74 -0
  101. package/dist/l10n/be.d.ts +72 -0
  102. package/dist/l10n/be.js +75 -0
  103. package/dist/l10n/bg.d.ts +72 -0
  104. package/dist/l10n/bg.js +66 -0
  105. package/dist/l10n/bn.d.ts +72 -0
  106. package/dist/l10n/bn.js +64 -0
  107. package/dist/l10n/bs.d.ts +72 -0
  108. package/dist/l10n/bs.js +66 -0
  109. package/dist/l10n/cat.d.ts +72 -0
  110. package/dist/l10n/cat.js +84 -0
  111. package/dist/l10n/ckb.d.ts +72 -0
  112. package/dist/l10n/ckb.js +76 -0
  113. package/dist/l10n/cs.d.ts +72 -0
  114. package/dist/l10n/cs.js +75 -0
  115. package/dist/l10n/cy.d.ts +72 -0
  116. package/dist/l10n/cy.js +93 -0
  117. package/dist/l10n/da.d.ts +72 -0
  118. package/dist/l10n/da.js +71 -0
  119. package/dist/l10n/de.d.ts +72 -0
  120. package/dist/l10n/de.js +70 -0
  121. package/dist/l10n/default.d.ts +3 -0
  122. package/dist/l10n/default.js +84 -0
  123. package/dist/l10n/eo.d.ts +72 -0
  124. package/dist/l10n/eo.js +73 -0
  125. package/dist/l10n/es.d.ts +72 -0
  126. package/dist/l10n/es.js +70 -0
  127. package/dist/l10n/et.d.ts +72 -0
  128. package/dist/l10n/et.js +73 -0
  129. package/dist/l10n/fa.d.ts +72 -0
  130. package/dist/l10n/fa.js +68 -0
  131. package/dist/l10n/fi.d.ts +72 -0
  132. package/dist/l10n/fi.js +69 -0
  133. package/dist/l10n/fo.d.ts +72 -0
  134. package/dist/l10n/fo.js +74 -0
  135. package/dist/l10n/fr.d.ts +72 -0
  136. package/dist/l10n/fr.js +75 -0
  137. package/dist/l10n/ga.d.ts +72 -0
  138. package/dist/l10n/ga.js +66 -0
  139. package/dist/l10n/gr.d.ts +72 -0
  140. package/dist/l10n/gr.js +77 -0
  141. package/dist/l10n/he.d.ts +72 -0
  142. package/dist/l10n/he.js +58 -0
  143. package/dist/l10n/hi.d.ts +72 -0
  144. package/dist/l10n/hi.js +64 -0
  145. package/dist/l10n/hr.d.ts +72 -0
  146. package/dist/l10n/hr.js +66 -0
  147. package/dist/l10n/hu.d.ts +72 -0
  148. package/dist/l10n/hu.js +73 -0
  149. package/dist/l10n/hy.d.ts +72 -0
  150. package/dist/l10n/hy.js +78 -0
  151. package/dist/l10n/id.d.ts +72 -0
  152. package/dist/l10n/id.js +62 -0
  153. package/dist/l10n/index.d.ts +3 -0
  154. package/dist/l10n/index.js +3810 -0
  155. package/dist/l10n/is.d.ts +72 -0
  156. package/dist/l10n/is.js +72 -0
  157. package/dist/l10n/it.d.ts +72 -0
  158. package/dist/l10n/it.js +71 -0
  159. package/dist/l10n/ja.d.ts +72 -0
  160. package/dist/l10n/ja.js +71 -0
  161. package/dist/l10n/ka.d.ts +72 -0
  162. package/dist/l10n/ka.js +75 -0
  163. package/dist/l10n/km.d.ts +72 -0
  164. package/dist/l10n/km.js +74 -0
  165. package/dist/l10n/ko.d.ts +72 -0
  166. package/dist/l10n/ko.js +69 -0
  167. package/dist/l10n/kz.d.ts +72 -0
  168. package/dist/l10n/kz.js +74 -0
  169. package/dist/l10n/lt.d.ts +72 -0
  170. package/dist/l10n/lt.js +73 -0
  171. package/dist/l10n/lv.d.ts +72 -0
  172. package/dist/l10n/lv.js +67 -0
  173. package/dist/l10n/mk.d.ts +72 -0
  174. package/dist/l10n/mk.js +68 -0
  175. package/dist/l10n/mn.d.ts +72 -0
  176. package/dist/l10n/mn.js +59 -0
  177. package/dist/l10n/ms.d.ts +72 -0
  178. package/dist/l10n/ms.js +60 -0
  179. package/dist/l10n/my.d.ts +72 -0
  180. package/dist/l10n/my.js +69 -0
  181. package/dist/l10n/nl.d.ts +72 -0
  182. package/dist/l10n/nl.js +75 -0
  183. package/dist/l10n/nn.d.ts +72 -0
  184. package/dist/l10n/nn.js +73 -0
  185. package/dist/l10n/no.d.ts +72 -0
  186. package/dist/l10n/no.js +73 -0
  187. package/dist/l10n/pa.d.ts +72 -0
  188. package/dist/l10n/pa.js +65 -0
  189. package/dist/l10n/pl.d.ts +72 -0
  190. package/dist/l10n/pl.js +73 -0
  191. package/dist/l10n/pt.d.ts +72 -0
  192. package/dist/l10n/pt.js +66 -0
  193. package/dist/l10n/ro.d.ts +72 -0
  194. package/dist/l10n/ro.js +69 -0
  195. package/dist/l10n/ru.d.ts +72 -0
  196. package/dist/l10n/ru.js +75 -0
  197. package/dist/l10n/si.d.ts +72 -0
  198. package/dist/l10n/si.js +65 -0
  199. package/dist/l10n/sk.d.ts +72 -0
  200. package/dist/l10n/sk.js +70 -0
  201. package/dist/l10n/sl.d.ts +72 -0
  202. package/dist/l10n/sl.js +70 -0
  203. package/dist/l10n/sq.d.ts +72 -0
  204. package/dist/l10n/sq.js +72 -0
  205. package/dist/l10n/sr-cyr.d.ts +72 -0
  206. package/dist/l10n/sr-cyr.js +67 -0
  207. package/dist/l10n/sr.d.ts +72 -0
  208. package/dist/l10n/sr.js +68 -0
  209. package/dist/l10n/sv.d.ts +72 -0
  210. package/dist/l10n/sv.js +71 -0
  211. package/dist/l10n/th.d.ts +72 -0
  212. package/dist/l10n/th.js +72 -0
  213. package/dist/l10n/tr.d.ts +72 -0
  214. package/dist/l10n/tr.js +74 -0
  215. package/dist/l10n/uk.d.ts +72 -0
  216. package/dist/l10n/uk.js +66 -0
  217. package/dist/l10n/uz.d.ts +72 -0
  218. package/dist/l10n/uz.js +75 -0
  219. package/dist/l10n/uz_latn.d.ts +72 -0
  220. package/dist/l10n/uz_latn.js +75 -0
  221. package/dist/l10n/vn.d.ts +72 -0
  222. package/dist/l10n/vn.js +66 -0
  223. package/dist/l10n/zh.d.ts +72 -0
  224. package/dist/l10n/zh.js +68 -0
  225. package/dist/l10n/zh_tw.d.ts +72 -0
  226. package/dist/l10n/zh_tw.js +68 -0
  227. package/dist/plugins/confirmDate/confirmDate.css +24 -0
  228. package/dist/plugins/confirmDate/confirmDate.d.ts +9 -0
  229. package/dist/plugins/confirmDate/confirmDate.js +104 -0
  230. package/dist/plugins/labelPlugin/labelPlugin.d.ts +3 -0
  231. package/dist/plugins/labelPlugin/labelPlugin.js +31 -0
  232. package/dist/plugins/minMaxTimePlugin.d.ts +17 -0
  233. package/dist/plugins/minMaxTimePlugin.js +349 -0
  234. package/dist/plugins/momentPlugin.d.ts +6 -0
  235. package/dist/plugins/momentPlugin.js +69 -0
  236. package/dist/plugins/monthSelect/index.d.ts +17 -0
  237. package/dist/plugins/monthSelect/index.js +301 -0
  238. package/dist/plugins/monthSelect/style.css +117 -0
  239. package/dist/plugins/rangePlugin.d.ts +12 -0
  240. package/dist/plugins/rangePlugin.js +179 -0
  241. package/dist/plugins/scrollPlugin.d.ts +3 -0
  242. package/dist/plugins/scrollPlugin.js +93 -0
  243. package/dist/plugins/weekSelect/weekSelect.d.ts +7 -0
  244. package/dist/plugins/weekSelect/weekSelect.js +99 -0
  245. package/dist/themes/airbnb.css +883 -0
  246. package/dist/themes/confetti.css +806 -0
  247. package/dist/themes/dark.css +795 -0
  248. package/dist/themes/light.css +809 -0
  249. package/dist/themes/material_blue.css +806 -0
  250. package/dist/themes/material_green.css +806 -0
  251. package/dist/themes/material_orange.css +806 -0
  252. package/dist/themes/material_red.css +806 -0
  253. package/dist/types/globals.d.ts +20 -0
  254. package/dist/types/instance.d.ts +118 -0
  255. package/dist/types/locale.d.ts +112 -0
  256. package/dist/types/options.d.ts +148 -0
  257. package/dist/typings.d.ts +40 -0
  258. package/dist/utils/dates.d.ts +25 -0
  259. package/dist/utils/dom.d.ts +7 -0
  260. package/dist/utils/formatting.d.ts +13 -0
  261. package/dist/utils/index.d.ts +8 -0
  262. package/package.json +81 -4
  263. package/src/style/_vars.styl +34 -0
  264. package/src/style/flatpickr.styl +703 -0
  265. package/src/style/ie.styl +14 -0
  266. package/src/style/themes/airbnb.styl +87 -0
  267. package/src/style/themes/confetti.styl +18 -0
  268. package/src/style/themes/dark.styl +18 -0
  269. package/src/style/themes/light.styl +22 -0
  270. package/src/style/themes/material_blue.styl +18 -0
  271. package/src/style/themes/material_green.styl +18 -0
  272. package/src/style/themes/material_orange.styl +18 -0
  273. package/src/style/themes/material_red.styl +18 -0
@@ -0,0 +1,2724 @@
1
+ /* flatpickr v4.7.0, @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 = typeof globalThis !== 'undefined' ? globalThis : global || self, global.flatpickr = factory());
6
+ }(this, (function () { 'use strict';
7
+
8
+ /*! *****************************************************************************
9
+ Copyright (c) Microsoft Corporation.
10
+
11
+ Permission to use, copy, modify, and/or distribute this software for any
12
+ purpose with or without fee is hereby granted.
13
+
14
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
15
+ REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
16
+ AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
17
+ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
18
+ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
19
+ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
20
+ PERFORMANCE OF THIS SOFTWARE.
21
+ ***************************************************************************** */
22
+
23
+ var __assign = function() {
24
+ __assign = Object.assign || function __assign(t) {
25
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
26
+ s = arguments[i];
27
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
28
+ }
29
+ return t;
30
+ };
31
+ return __assign.apply(this, arguments);
32
+ };
33
+
34
+ function __spreadArrays() {
35
+ for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
36
+ for (var r = Array(s), k = 0, i = 0; i < il; i++)
37
+ for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
38
+ r[k] = a[j];
39
+ return r;
40
+ }
41
+
42
+ var HOOKS = [
43
+ "onChange",
44
+ "onClose",
45
+ "onDayCreate",
46
+ "onDestroy",
47
+ "onKeyDown",
48
+ "onMonthChange",
49
+ "onOpen",
50
+ "onParseConfig",
51
+ "onReady",
52
+ "onValueUpdate",
53
+ "onYearChange",
54
+ "onPreCalendarPosition",
55
+ ];
56
+ var defaults = {
57
+ _disable: [],
58
+ allowInput: false,
59
+ allowInvalidPreload: false,
60
+ altFormat: "F j, Y",
61
+ altInput: false,
62
+ altInputClass: "form-control input",
63
+ animate: typeof window === "object" &&
64
+ window.navigator.userAgent.indexOf("MSIE") === -1,
65
+ ariaDateFormat: "F j, Y",
66
+ autoFillDefaultTime: true,
67
+ clickOpens: true,
68
+ closeOnSelect: true,
69
+ conjunction: ", ",
70
+ dateFormat: "Y-m-d",
71
+ defaultHour: 12,
72
+ defaultMinute: 0,
73
+ defaultSeconds: 0,
74
+ disable: [],
75
+ disableMobile: false,
76
+ enableSeconds: false,
77
+ enableTime: false,
78
+ errorHandler: function (err) {
79
+ return typeof console !== "undefined" && console.warn(err);
80
+ },
81
+ getWeek: function (givenDate) {
82
+ var date = new Date(givenDate.getTime());
83
+ date.setHours(0, 0, 0, 0);
84
+ // Thursday in current week decides the year.
85
+ date.setDate(date.getDate() + 3 - ((date.getDay() + 6) % 7));
86
+ // January 4 is always in week 1.
87
+ var week1 = new Date(date.getFullYear(), 0, 4);
88
+ // Adjust to Thursday in week 1 and count number of weeks from date to week1.
89
+ return (1 +
90
+ Math.round(((date.getTime() - week1.getTime()) / 86400000 -
91
+ 3 +
92
+ ((week1.getDay() + 6) % 7)) /
93
+ 7));
94
+ },
95
+ hourIncrement: 1,
96
+ ignoredFocusElements: [],
97
+ inline: false,
98
+ locale: "default",
99
+ minuteIncrement: 5,
100
+ mode: "single",
101
+ monthSelectorType: "dropdown",
102
+ 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>",
103
+ noCalendar: false,
104
+ now: new Date(),
105
+ onChange: [],
106
+ onClose: [],
107
+ onDayCreate: [],
108
+ onDestroy: [],
109
+ onKeyDown: [],
110
+ onMonthChange: [],
111
+ onOpen: [],
112
+ onParseConfig: [],
113
+ onReady: [],
114
+ onValueUpdate: [],
115
+ onYearChange: [],
116
+ onPreCalendarPosition: [],
117
+ plugins: [],
118
+ position: "auto",
119
+ positionElement: undefined,
120
+ 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>",
121
+ shorthandCurrentMonth: false,
122
+ showMonths: 1,
123
+ static: false,
124
+ time_24hr: false,
125
+ weekNumbers: false,
126
+ wrap: false,
127
+ };
128
+
129
+ var english = {
130
+ weekdays: {
131
+ shorthand: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
132
+ longhand: [
133
+ "Sunday",
134
+ "Monday",
135
+ "Tuesday",
136
+ "Wednesday",
137
+ "Thursday",
138
+ "Friday",
139
+ "Saturday",
140
+ ],
141
+ },
142
+ months: {
143
+ shorthand: [
144
+ "Jan",
145
+ "Feb",
146
+ "Mar",
147
+ "Apr",
148
+ "May",
149
+ "Jun",
150
+ "Jul",
151
+ "Aug",
152
+ "Sep",
153
+ "Oct",
154
+ "Nov",
155
+ "Dec",
156
+ ],
157
+ longhand: [
158
+ "January",
159
+ "February",
160
+ "March",
161
+ "April",
162
+ "May",
163
+ "June",
164
+ "July",
165
+ "August",
166
+ "September",
167
+ "October",
168
+ "November",
169
+ "December",
170
+ ],
171
+ },
172
+ daysInMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
173
+ firstDayOfWeek: 0,
174
+ ordinal: function (nth) {
175
+ var s = nth % 100;
176
+ if (s > 3 && s < 21)
177
+ return "th";
178
+ switch (s % 10) {
179
+ case 1:
180
+ return "st";
181
+ case 2:
182
+ return "nd";
183
+ case 3:
184
+ return "rd";
185
+ default:
186
+ return "th";
187
+ }
188
+ },
189
+ rangeSeparator: " to ",
190
+ weekAbbreviation: "Wk",
191
+ scrollTitle: "Scroll to increment",
192
+ toggleTitle: "Click to toggle",
193
+ amPM: ["AM", "PM"],
194
+ yearAriaLabel: "Year",
195
+ monthAriaLabel: "Month",
196
+ hourAriaLabel: "Hour",
197
+ minuteAriaLabel: "Minute",
198
+ time_24hr: false,
199
+ };
200
+
201
+ var pad = function (number, length) {
202
+ if (length === void 0) { length = 2; }
203
+ return ("000" + number).slice(length * -1);
204
+ };
205
+ var int = function (bool) { return (bool === true ? 1 : 0); };
206
+ /* istanbul ignore next */
207
+ function debounce(fn, wait) {
208
+ var t;
209
+ return function () {
210
+ var _this = this;
211
+ var args = arguments;
212
+ clearTimeout(t);
213
+ t = setTimeout(function () { return fn.apply(_this, args); }, wait);
214
+ };
215
+ }
216
+ var arrayify = function (obj) {
217
+ return obj instanceof Array ? obj : [obj];
218
+ };
219
+
220
+ function toggleClass(elem, className, bool) {
221
+ if (bool === true)
222
+ return elem.classList.add(className);
223
+ elem.classList.remove(className);
224
+ }
225
+ function createElement(tag, className, content) {
226
+ var e = window.document.createElement(tag);
227
+ className = className || "";
228
+ content = content || "";
229
+ e.className = className;
230
+ if (content !== undefined)
231
+ e.textContent = content;
232
+ return e;
233
+ }
234
+ function clearNode(node) {
235
+ while (node.firstChild)
236
+ node.removeChild(node.firstChild);
237
+ }
238
+ function findParent(node, condition) {
239
+ if (condition(node))
240
+ return node;
241
+ else if (node.parentNode)
242
+ return findParent(node.parentNode, condition);
243
+ return undefined; // nothing found
244
+ }
245
+ function createNumberInput(inputClassName, opts) {
246
+ var wrapper = createElement("div", "numInputWrapper"), numInput = createElement("input", "numInput " + inputClassName), arrowUp = createElement("span", "arrowUp"), arrowDown = createElement("span", "arrowDown");
247
+ if (navigator.userAgent.indexOf("MSIE 9.0") === -1) {
248
+ numInput.type = "number";
249
+ }
250
+ else {
251
+ numInput.type = "text";
252
+ numInput.pattern = "\\d*";
253
+ }
254
+ if (opts !== undefined)
255
+ for (var key in opts)
256
+ numInput.setAttribute(key, opts[key]);
257
+ wrapper.appendChild(numInput);
258
+ wrapper.appendChild(arrowUp);
259
+ wrapper.appendChild(arrowDown);
260
+ return wrapper;
261
+ }
262
+ function getEventTarget(event) {
263
+ try {
264
+ if (typeof event.composedPath === "function") {
265
+ var path = event.composedPath();
266
+ return path[0];
267
+ }
268
+ return event.target;
269
+ }
270
+ catch (error) {
271
+ return event.target;
272
+ }
273
+ }
274
+ // Works across windows, unlike `instanceof Node`
275
+ function isNode(value) {
276
+ var _a;
277
+ return typeof ((_a = value) === null || _a === void 0 ? void 0 : _a.nodeType) === "number";
278
+ }
279
+
280
+ var doNothing = function () { return undefined; };
281
+ var monthToStr = function (monthNumber, shorthand, locale) { return locale.months[shorthand ? "shorthand" : "longhand"][monthNumber]; };
282
+ var revFormat = {
283
+ D: doNothing,
284
+ F: function (dateObj, monthName, locale) {
285
+ dateObj.setMonth(locale.months.longhand.indexOf(monthName));
286
+ },
287
+ G: function (dateObj, hour) {
288
+ dateObj.setHours((dateObj.getHours() >= 12 ? 12 : 0) + parseFloat(hour));
289
+ },
290
+ H: function (dateObj, hour) {
291
+ dateObj.setHours(parseFloat(hour));
292
+ },
293
+ J: function (dateObj, day) {
294
+ dateObj.setDate(parseFloat(day));
295
+ },
296
+ K: function (dateObj, amPM, locale) {
297
+ dateObj.setHours((dateObj.getHours() % 12) +
298
+ 12 * int(new RegExp(locale.amPM[1], "i").test(amPM)));
299
+ },
300
+ M: function (dateObj, shortMonth, locale) {
301
+ dateObj.setMonth(locale.months.shorthand.indexOf(shortMonth));
302
+ },
303
+ S: function (dateObj, seconds) {
304
+ dateObj.setSeconds(parseFloat(seconds));
305
+ },
306
+ U: function (_, unixSeconds) { return new Date(parseFloat(unixSeconds) * 1000); },
307
+ W: function (dateObj, weekNum, locale) {
308
+ var weekNumber = parseInt(weekNum);
309
+ var date = new Date(dateObj.getFullYear(), 0, 2 + (weekNumber - 1) * 7, 0, 0, 0, 0);
310
+ date.setDate(date.getDate() - date.getDay() + locale.firstDayOfWeek);
311
+ return date;
312
+ },
313
+ Y: function (dateObj, year) {
314
+ dateObj.setFullYear(parseFloat(year));
315
+ },
316
+ Z: function (_, ISODate) { return new Date(ISODate); },
317
+ d: function (dateObj, day) {
318
+ dateObj.setDate(parseFloat(day));
319
+ },
320
+ h: function (dateObj, hour) {
321
+ dateObj.setHours((dateObj.getHours() >= 12 ? 12 : 0) + parseFloat(hour));
322
+ },
323
+ i: function (dateObj, minutes) {
324
+ dateObj.setMinutes(parseFloat(minutes));
325
+ },
326
+ j: function (dateObj, day) {
327
+ dateObj.setDate(parseFloat(day));
328
+ },
329
+ l: doNothing,
330
+ m: function (dateObj, month) {
331
+ dateObj.setMonth(parseFloat(month) - 1);
332
+ },
333
+ n: function (dateObj, month) {
334
+ dateObj.setMonth(parseFloat(month) - 1);
335
+ },
336
+ s: function (dateObj, seconds) {
337
+ dateObj.setSeconds(parseFloat(seconds));
338
+ },
339
+ u: function (_, unixMillSeconds) {
340
+ return new Date(parseFloat(unixMillSeconds));
341
+ },
342
+ w: doNothing,
343
+ y: function (dateObj, year) {
344
+ dateObj.setFullYear(2000 + parseFloat(year));
345
+ },
346
+ };
347
+ var tokenRegex = {
348
+ D: "",
349
+ F: "",
350
+ G: "(\\d\\d|\\d)",
351
+ H: "(\\d\\d|\\d)",
352
+ J: "(\\d\\d|\\d)\\w+",
353
+ K: "",
354
+ M: "",
355
+ S: "(\\d\\d|\\d)",
356
+ U: "(.+)",
357
+ W: "(\\d\\d|\\d)",
358
+ Y: "(\\d{4})",
359
+ Z: "(.+)",
360
+ d: "(\\d\\d|\\d)",
361
+ h: "(\\d\\d|\\d)",
362
+ i: "(\\d\\d|\\d)",
363
+ j: "(\\d\\d|\\d)",
364
+ l: "",
365
+ m: "(\\d\\d|\\d)",
366
+ n: "(\\d\\d|\\d)",
367
+ s: "(\\d\\d|\\d)",
368
+ u: "(.+)",
369
+ w: "(\\d\\d|\\d)",
370
+ y: "(\\d{2})",
371
+ };
372
+ var formats = {
373
+ // get the date in UTC
374
+ Z: function (date) { return date.toISOString(); },
375
+ // weekday name, short, e.g. Thu
376
+ D: function (date, locale, options) {
377
+ return locale.weekdays.shorthand[formats.w(date, locale, options)];
378
+ },
379
+ // full month name e.g. January
380
+ F: function (date, locale, options) {
381
+ return monthToStr(formats.n(date, locale, options) - 1, false, locale);
382
+ },
383
+ // padded hour 1-12
384
+ G: function (date, locale, options) {
385
+ return pad(formats.h(date, locale, options));
386
+ },
387
+ // hours with leading zero e.g. 03
388
+ H: function (date) { return pad(date.getHours()); },
389
+ // day (1-30) with ordinal suffix e.g. 1st, 2nd
390
+ J: function (date, locale) {
391
+ return locale.ordinal !== undefined
392
+ ? date.getDate() + locale.ordinal(date.getDate())
393
+ : date.getDate();
394
+ },
395
+ // AM/PM
396
+ K: function (date, locale) { return locale.amPM[int(date.getHours() > 11)]; },
397
+ // shorthand month e.g. Jan, Sep, Oct, etc
398
+ M: function (date, locale) {
399
+ return monthToStr(date.getMonth(), true, locale);
400
+ },
401
+ // seconds 00-59
402
+ S: function (date) { return pad(date.getSeconds()); },
403
+ // unix timestamp
404
+ U: function (date) { return date.getTime() / 1000; },
405
+ W: function (date, _, options) {
406
+ return options.getWeek(date);
407
+ },
408
+ // full year e.g. 2016, padded (0001-9999)
409
+ Y: function (date) { return pad(date.getFullYear(), 4); },
410
+ // day in month, padded (01-30)
411
+ d: function (date) { return pad(date.getDate()); },
412
+ // hour from 1-12 (am/pm)
413
+ h: function (date) { return (date.getHours() % 12 ? date.getHours() % 12 : 12); },
414
+ // minutes, padded with leading zero e.g. 09
415
+ i: function (date) { return pad(date.getMinutes()); },
416
+ // day in month (1-30)
417
+ j: function (date) { return date.getDate(); },
418
+ // weekday name, full, e.g. Thursday
419
+ l: function (date, locale) {
420
+ return locale.weekdays.longhand[date.getDay()];
421
+ },
422
+ // padded month number (01-12)
423
+ m: function (date) { return pad(date.getMonth() + 1); },
424
+ // the month number (1-12)
425
+ n: function (date) { return date.getMonth() + 1; },
426
+ // seconds 0-59
427
+ s: function (date) { return date.getSeconds(); },
428
+ // Unix Milliseconds
429
+ u: function (date) { return date.getTime(); },
430
+ // number of the day of the week
431
+ w: function (date) { return date.getDay(); },
432
+ // last two digits of year e.g. 16 for 2016
433
+ y: function (date) { return String(date.getFullYear()).substring(2); },
434
+ };
435
+
436
+ var createDateFormatter = function (_a) {
437
+ var _b = _a.config, config = _b === void 0 ? defaults : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _c, _d = _a.isMobile, isMobile = _d === void 0 ? false : _d;
438
+ return function (dateObj, frmt, overrideLocale) {
439
+ var locale = overrideLocale || l10n;
440
+ if (config.formatDate !== undefined && !isMobile) {
441
+ return config.formatDate(dateObj, frmt, locale);
442
+ }
443
+ return frmt
444
+ .split("")
445
+ .map(function (c, i, arr) {
446
+ return formats[c] && arr[i - 1] !== "\\"
447
+ ? formats[c](dateObj, locale, config)
448
+ : c !== "\\"
449
+ ? c
450
+ : "";
451
+ })
452
+ .join("");
453
+ };
454
+ };
455
+ var createDateParser = function (_a) {
456
+ var _b = _a.config, config = _b === void 0 ? defaults : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _c;
457
+ return function (date, givenFormat, timeless, customLocale) {
458
+ if (date !== 0 && !date)
459
+ return undefined;
460
+ var locale = customLocale || l10n;
461
+ var parsedDate;
462
+ var dateOrig = date;
463
+ if (date instanceof Date)
464
+ parsedDate = new Date(date.getTime());
465
+ else if (typeof date !== "string" &&
466
+ date.toFixed !== undefined // timestamp
467
+ )
468
+ // create a copy
469
+ parsedDate = new Date(date);
470
+ else if (typeof date === "string") {
471
+ // date string
472
+ var format = givenFormat || (config || defaults).dateFormat;
473
+ var datestr = String(date).trim();
474
+ if (datestr === "today") {
475
+ parsedDate = new Date();
476
+ timeless = true;
477
+ }
478
+ else if (config && config.parseDate) {
479
+ parsedDate = config.parseDate(date, format);
480
+ }
481
+ else if (/Z$/.test(datestr) ||
482
+ /GMT$/.test(datestr) // datestrings w/ timezone
483
+ ) {
484
+ parsedDate = new Date(date);
485
+ }
486
+ else {
487
+ var matched = void 0, ops = [];
488
+ for (var i = 0, matchIndex = 0, regexStr = ""; i < format.length; i++) {
489
+ var token_1 = format[i];
490
+ var isBackSlash = token_1 === "\\";
491
+ var escaped = format[i - 1] === "\\" || isBackSlash;
492
+ if (tokenRegex[token_1] && !escaped) {
493
+ regexStr += tokenRegex[token_1];
494
+ var match = new RegExp(regexStr).exec(date);
495
+ if (match && (matched = true)) {
496
+ ops[token_1 !== "Y" ? "push" : "unshift"]({
497
+ fn: revFormat[token_1],
498
+ val: match[++matchIndex],
499
+ });
500
+ }
501
+ }
502
+ else if (!isBackSlash)
503
+ regexStr += "."; // don't really care
504
+ }
505
+ parsedDate =
506
+ !config || !config.noCalendar
507
+ ? new Date(new Date().getFullYear(), 0, 1, 0, 0, 0, 0)
508
+ : new Date(new Date().setHours(0, 0, 0, 0));
509
+ ops.forEach(function (_a) {
510
+ var fn = _a.fn, val = _a.val;
511
+ return (parsedDate = fn(parsedDate, val, locale) || parsedDate);
512
+ });
513
+ parsedDate = matched ? parsedDate : undefined;
514
+ }
515
+ }
516
+ /* istanbul ignore next */
517
+ if (!(parsedDate instanceof Date && !isNaN(parsedDate.getTime()))) {
518
+ config.errorHandler(new Error("Invalid date provided: " + dateOrig));
519
+ return undefined;
520
+ }
521
+ if (timeless === true)
522
+ parsedDate.setHours(0, 0, 0, 0);
523
+ return parsedDate;
524
+ };
525
+ };
526
+ /**
527
+ * Compute the difference in dates, measured in ms
528
+ */
529
+ function compareDates(date1, date2, timeless) {
530
+ if (timeless === void 0) { timeless = true; }
531
+ if (timeless !== false) {
532
+ return (new Date(date1.getTime()).setHours(0, 0, 0, 0) -
533
+ new Date(date2.getTime()).setHours(0, 0, 0, 0));
534
+ }
535
+ return date1.getTime() - date2.getTime();
536
+ }
537
+ var isBetween = function (ts, ts1, ts2) {
538
+ return ts > Math.min(ts1, ts2) && ts < Math.max(ts1, ts2);
539
+ };
540
+ var calculateSecondsSinceMidnight = function (hours, minutes, seconds) {
541
+ return hours * 3600 + minutes * 60 + seconds;
542
+ };
543
+ var parseSeconds = function (secondsSinceMidnight) {
544
+ var hours = Math.floor(secondsSinceMidnight / 3600), minutes = (secondsSinceMidnight - hours * 3600) / 60;
545
+ return [hours, minutes, secondsSinceMidnight - hours * 3600 - minutes * 60];
546
+ };
547
+ var duration = {
548
+ DAY: 86400000,
549
+ };
550
+ function getDefaultHours(config) {
551
+ var hours = config.defaultHour;
552
+ var minutes = config.defaultMinute;
553
+ var seconds = config.defaultSeconds;
554
+ if (config.minDate !== undefined) {
555
+ var minHour = config.minDate.getHours();
556
+ var minMinutes = config.minDate.getMinutes();
557
+ var minSeconds = config.minDate.getSeconds();
558
+ if (hours < minHour) {
559
+ hours = minHour;
560
+ }
561
+ if (hours === minHour && minutes < minMinutes) {
562
+ minutes = minMinutes;
563
+ }
564
+ if (hours === minHour && minutes === minMinutes && seconds < minSeconds)
565
+ seconds = config.minDate.getSeconds();
566
+ }
567
+ if (config.maxDate !== undefined) {
568
+ var maxHr = config.maxDate.getHours();
569
+ var maxMinutes = config.maxDate.getMinutes();
570
+ hours = Math.min(hours, maxHr);
571
+ if (hours === maxHr)
572
+ minutes = Math.min(maxMinutes, minutes);
573
+ if (hours === maxHr && minutes === maxMinutes)
574
+ seconds = config.maxDate.getSeconds();
575
+ }
576
+ return { hours: hours, minutes: minutes, seconds: seconds };
577
+ }
578
+
579
+ if (typeof Object.assign !== "function") {
580
+ Object.assign = function (target) {
581
+ var args = [];
582
+ for (var _i = 1; _i < arguments.length; _i++) {
583
+ args[_i - 1] = arguments[_i];
584
+ }
585
+ if (!target) {
586
+ throw TypeError("Cannot convert undefined or null to object");
587
+ }
588
+ var _loop_1 = function (source) {
589
+ if (source) {
590
+ Object.keys(source).forEach(function (key) { return (target[key] = source[key]); });
591
+ }
592
+ };
593
+ for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
594
+ var source = args_1[_a];
595
+ _loop_1(source);
596
+ }
597
+ return target;
598
+ };
599
+ }
600
+
601
+ var DEBOUNCED_CHANGE_MS = 300;
602
+ function FlatpickrInstance(element, instanceConfig) {
603
+ var self = {
604
+ config: __assign(__assign({}, defaults), flatpickr.defaultConfig),
605
+ l10n: english,
606
+ };
607
+ // The element may live in another document than the one flatpickr was
608
+ // loaded in (an iframe, or a window.open() popup), each with its own globals.
609
+ // A document without a window (e.g. a <template> clone not yet inserted)
610
+ // can't render anything, so fall back to ours.
611
+ var win = element.ownerDocument.defaultView || window;
612
+ var doc = win.document;
613
+ self.parseDate = createDateParser({ config: self.config, l10n: self.l10n });
614
+ self._handlers = [];
615
+ self.pluginElements = [];
616
+ self.loadedPlugins = [];
617
+ self._bind = bind;
618
+ self._setHoursFromDate = setHoursFromDate;
619
+ self._positionCalendar = positionCalendar;
620
+ self.changeMonth = changeMonth;
621
+ self.changeYear = changeYear;
622
+ self.clear = clear;
623
+ self.close = close;
624
+ self.onMouseOver = onMouseOver;
625
+ self._createElement = createElement;
626
+ self.createDay = createDay;
627
+ self.destroy = destroy;
628
+ self.isEnabled = isEnabled;
629
+ self.jumpToDate = jumpToDate;
630
+ self.updateValue = updateValue;
631
+ self.open = open;
632
+ self.redraw = redraw;
633
+ self.set = set;
634
+ self.setDate = setDate;
635
+ self.toggle = toggle;
636
+ function setupHelperFunctions() {
637
+ self.utils = {
638
+ getDaysInMonth: function (month, yr) {
639
+ if (month === void 0) { month = self.currentMonth; }
640
+ if (yr === void 0) { yr = self.currentYear; }
641
+ if (month === 1 && ((yr % 4 === 0 && yr % 100 !== 0) || yr % 400 === 0))
642
+ return 29;
643
+ return self.l10n.daysInMonth[month];
644
+ },
645
+ };
646
+ }
647
+ function init() {
648
+ self.element = self.input = element;
649
+ self.isOpen = false;
650
+ parseConfig();
651
+ setupLocale();
652
+ setupInputs();
653
+ setupDates();
654
+ setupHelperFunctions();
655
+ if (!self.isMobile)
656
+ build();
657
+ bindEvents();
658
+ if (self.selectedDates.length || self.config.noCalendar) {
659
+ if (self.config.enableTime) {
660
+ setHoursFromDate(self.config.noCalendar ? self.latestSelectedDateObj : undefined);
661
+ }
662
+ updateValue(false);
663
+ }
664
+ setCalendarWidth();
665
+ var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
666
+ /* TODO: investigate this further
667
+
668
+ Currently, there is weird positioning behavior in safari causing pages
669
+ to scroll up. https://github.com/chmln/flatpickr/issues/563
670
+
671
+ However, most browsers are not Safari and positioning is expensive when used
672
+ in scale. https://github.com/chmln/flatpickr/issues/1096
673
+ */
674
+ if (!self.isMobile && isSafari) {
675
+ positionCalendar();
676
+ }
677
+ triggerEvent("onReady");
678
+ }
679
+ function getClosestActiveElement() {
680
+ var _a;
681
+ return (((_a = self.calendarContainer) === null || _a === void 0 ? void 0 : _a.getRootNode())
682
+ .activeElement || doc.activeElement);
683
+ }
684
+ function bindToInstance(fn) {
685
+ return fn.bind(self);
686
+ }
687
+ function setCalendarWidth() {
688
+ var config = self.config;
689
+ if (config.weekNumbers === false && config.showMonths === 1) {
690
+ return;
691
+ }
692
+ else if (config.noCalendar !== true) {
693
+ win.requestAnimationFrame(function () {
694
+ if (self.calendarContainer !== undefined) {
695
+ self.calendarContainer.style.visibility = "hidden";
696
+ self.calendarContainer.style.display = "block";
697
+ }
698
+ if (self.daysContainer !== undefined) {
699
+ var daysWidth = (self.days.offsetWidth + 1) * config.showMonths;
700
+ self.daysContainer.style.width = daysWidth + "px";
701
+ self.calendarContainer.style.width =
702
+ daysWidth +
703
+ (self.weekWrapper !== undefined
704
+ ? self.weekWrapper.offsetWidth
705
+ : 0) +
706
+ "px";
707
+ self.calendarContainer.style.removeProperty("visibility");
708
+ self.calendarContainer.style.removeProperty("display");
709
+ }
710
+ });
711
+ }
712
+ }
713
+ /**
714
+ * The handler for all events targeting the time inputs
715
+ */
716
+ function updateTime(e) {
717
+ if (self.selectedDates.length === 0) {
718
+ var defaultDate = self.config.minDate === undefined ||
719
+ compareDates(new Date(), self.config.minDate) >= 0
720
+ ? new Date()
721
+ : new Date(self.config.minDate.getTime());
722
+ var defaults = getDefaultHours(self.config);
723
+ defaultDate.setHours(defaults.hours, defaults.minutes, defaults.seconds, defaultDate.getMilliseconds());
724
+ self.selectedDates = [defaultDate];
725
+ self.latestSelectedDateObj = defaultDate;
726
+ }
727
+ if (e !== undefined && e.type !== "blur") {
728
+ timeWrapper(e);
729
+ }
730
+ var prevValue = self._input.value;
731
+ setHoursFromInputs();
732
+ updateValue();
733
+ if (self._input.value !== prevValue) {
734
+ self._debouncedChange();
735
+ }
736
+ }
737
+ function ampm2military(hour, amPM) {
738
+ return (hour % 12) + 12 * int(amPM === self.l10n.amPM[1]);
739
+ }
740
+ function military2ampm(hour) {
741
+ switch (hour % 24) {
742
+ case 0:
743
+ case 12:
744
+ return 12;
745
+ default:
746
+ return hour % 12;
747
+ }
748
+ }
749
+ /**
750
+ * Syncs the selected date object time with user's time input
751
+ */
752
+ function setHoursFromInputs() {
753
+ if (self.hourElement === undefined || self.minuteElement === undefined)
754
+ return;
755
+ var hours = (parseInt(self.hourElement.value.slice(-2), 10) || 0) % 24, minutes = (parseInt(self.minuteElement.value, 10) || 0) % 60, seconds = self.secondElement !== undefined
756
+ ? (parseInt(self.secondElement.value, 10) || 0) % 60
757
+ : 0;
758
+ if (self.amPM !== undefined) {
759
+ hours = ampm2military(hours, self.amPM.textContent);
760
+ }
761
+ var limitMinHours = self.config.minTime !== undefined ||
762
+ (self.config.minDate &&
763
+ self.minDateHasTime &&
764
+ self.latestSelectedDateObj &&
765
+ compareDates(self.latestSelectedDateObj, self.config.minDate, true) ===
766
+ 0);
767
+ var limitMaxHours = self.config.maxTime !== undefined ||
768
+ (self.config.maxDate &&
769
+ self.maxDateHasTime &&
770
+ self.latestSelectedDateObj &&
771
+ compareDates(self.latestSelectedDateObj, self.config.maxDate, true) ===
772
+ 0);
773
+ if (self.config.maxTime !== undefined &&
774
+ self.config.minTime !== undefined &&
775
+ self.config.minTime > self.config.maxTime) {
776
+ var minBound = calculateSecondsSinceMidnight(self.config.minTime.getHours(), self.config.minTime.getMinutes(), self.config.minTime.getSeconds());
777
+ var maxBound = calculateSecondsSinceMidnight(self.config.maxTime.getHours(), self.config.maxTime.getMinutes(), self.config.maxTime.getSeconds());
778
+ var currentTime = calculateSecondsSinceMidnight(hours, minutes, seconds);
779
+ if (currentTime > maxBound && currentTime < minBound) {
780
+ var result = parseSeconds(minBound);
781
+ hours = result[0];
782
+ minutes = result[1];
783
+ seconds = result[2];
784
+ }
785
+ }
786
+ else {
787
+ if (limitMaxHours) {
788
+ var maxTime = self.config.maxTime !== undefined
789
+ ? self.config.maxTime
790
+ : self.config.maxDate;
791
+ hours = Math.min(hours, maxTime.getHours());
792
+ if (hours === maxTime.getHours())
793
+ minutes = Math.min(minutes, maxTime.getMinutes());
794
+ if (minutes === maxTime.getMinutes())
795
+ seconds = Math.min(seconds, maxTime.getSeconds());
796
+ }
797
+ if (limitMinHours) {
798
+ var minTime = self.config.minTime !== undefined
799
+ ? self.config.minTime
800
+ : self.config.minDate;
801
+ hours = Math.max(hours, minTime.getHours());
802
+ if (hours === minTime.getHours() && minutes < minTime.getMinutes())
803
+ minutes = minTime.getMinutes();
804
+ if (minutes === minTime.getMinutes())
805
+ seconds = Math.max(seconds, minTime.getSeconds());
806
+ }
807
+ }
808
+ setHours(hours, minutes, seconds);
809
+ }
810
+ /**
811
+ * Syncs time input values with a date
812
+ */
813
+ function setHoursFromDate(dateObj) {
814
+ var date = dateObj || self.latestSelectedDateObj;
815
+ if (date && date instanceof Date) {
816
+ setHours(date.getHours(), date.getMinutes(), date.getSeconds());
817
+ }
818
+ }
819
+ /**
820
+ * Sets the hours, minutes, and optionally seconds
821
+ * of the latest selected date object and the
822
+ * corresponding time inputs
823
+ * @param {Number} hours the hour. whether its military
824
+ * or am-pm gets inferred from config
825
+ * @param {Number} minutes the minutes
826
+ * @param {Number} seconds the seconds (optional)
827
+ */
828
+ function setHours(hours, minutes, seconds) {
829
+ if (self.latestSelectedDateObj !== undefined) {
830
+ self.latestSelectedDateObj.setHours(hours % 24, minutes, seconds || 0, 0);
831
+ }
832
+ if (!self.hourElement || !self.minuteElement || self.isMobile)
833
+ return;
834
+ self.hourElement.value = pad(!self.config.time_24hr
835
+ ? ((12 + hours) % 12) + 12 * int(hours % 12 === 0)
836
+ : hours);
837
+ self.minuteElement.value = pad(minutes);
838
+ if (self.amPM !== undefined)
839
+ self.amPM.textContent = self.l10n.amPM[int(hours >= 12)];
840
+ if (self.secondElement !== undefined)
841
+ self.secondElement.value = pad(seconds);
842
+ }
843
+ /**
844
+ * Handles the year input and incrementing events
845
+ * @param {Event} event the keyup or increment event
846
+ */
847
+ function onYearInput(event) {
848
+ var eventTarget = getEventTarget(event);
849
+ var year = parseInt(eventTarget.value) + (event.delta || 0);
850
+ if (year / 1000 > 1 ||
851
+ (event.key === "Enter" && !/[^\d]/.test(year.toString()))) {
852
+ changeYear(year);
853
+ }
854
+ }
855
+ /**
856
+ * Essentially addEventListener + tracking
857
+ * @param {Element} element the element to addEventListener to
858
+ * @param {String} event the event name
859
+ * @param {Function} handler the event handler
860
+ */
861
+ function bind(element, event, handler, options) {
862
+ if (event instanceof Array)
863
+ return event.forEach(function (ev) { return bind(element, ev, handler, options); });
864
+ if (element instanceof Array)
865
+ return element.forEach(function (el) { return bind(el, event, handler, options); });
866
+ element.addEventListener(event, handler, options);
867
+ self._handlers.push({
868
+ remove: function () { return element.removeEventListener(event, handler, options); },
869
+ });
870
+ }
871
+ function triggerChange() {
872
+ triggerEvent("onChange");
873
+ }
874
+ /**
875
+ * Adds all the necessary event listeners
876
+ */
877
+ function bindEvents() {
878
+ if (self.config.wrap) {
879
+ ["open", "close", "toggle", "clear"].forEach(function (evt) {
880
+ Array.prototype.forEach.call(self.element.querySelectorAll("[data-" + evt + "]"), function (el) {
881
+ return bind(el, "click", self[evt]);
882
+ });
883
+ });
884
+ }
885
+ if (self.isMobile) {
886
+ setupMobile();
887
+ return;
888
+ }
889
+ var debouncedResize = debounce(onResize, 50);
890
+ self._debouncedChange = debounce(triggerChange, DEBOUNCED_CHANGE_MS);
891
+ if (self.daysContainer && !/iPhone|iPad|iPod/i.test(navigator.userAgent))
892
+ bind(self.daysContainer, "mouseover", function (e) {
893
+ if (self.config.mode === "range")
894
+ onMouseOver(getEventTarget(e));
895
+ });
896
+ bind(self._input, "keydown", onKeyDown);
897
+ if (self.calendarContainer !== undefined) {
898
+ bind(self.calendarContainer, "keydown", onKeyDown);
899
+ }
900
+ if (!self.config.inline && !self.config.static)
901
+ bind(win, "resize", debouncedResize);
902
+ if (win.ontouchstart !== undefined)
903
+ bind(doc, "touchstart", documentClick);
904
+ else
905
+ bind(doc, "mousedown", documentClick);
906
+ bind(doc, "focus", documentClick, { capture: true });
907
+ if (self.config.clickOpens === true) {
908
+ bind(self._input, "focus", self.open);
909
+ bind(self._input, "click", self.open);
910
+ }
911
+ if (self.daysContainer !== undefined) {
912
+ bind(self.monthNav, "click", onMonthNavClick);
913
+ bind(self.monthNav, ["keyup", "increment"], onYearInput);
914
+ bind(self.daysContainer, "click", selectDate);
915
+ }
916
+ if (self.timeContainer !== undefined &&
917
+ self.minuteElement !== undefined &&
918
+ self.hourElement !== undefined) {
919
+ var selText = function (e) {
920
+ return getEventTarget(e).select();
921
+ };
922
+ bind(self.timeContainer, ["increment"], updateTime);
923
+ bind(self.timeContainer, "blur", updateTime, { capture: true });
924
+ bind(self.timeContainer, "click", timeIncrement);
925
+ bind([self.hourElement, self.minuteElement], ["focus", "click"], selText);
926
+ if (self.secondElement !== undefined)
927
+ bind(self.secondElement, "focus", function () { return self.secondElement && self.secondElement.select(); });
928
+ if (self.amPM !== undefined) {
929
+ bind(self.amPM, "click", function (e) {
930
+ updateTime(e);
931
+ });
932
+ }
933
+ }
934
+ if (self.config.allowInput) {
935
+ bind(self._input, "blur", onBlur);
936
+ }
937
+ }
938
+ /**
939
+ * Set the calendar view to a particular date.
940
+ * @param {Date} jumpDate the date to set the view to
941
+ * @param {boolean} triggerChange if change events should be triggered
942
+ */
943
+ function jumpToDate(jumpDate, triggerChange) {
944
+ var jumpTo = jumpDate !== undefined
945
+ ? self.parseDate(jumpDate)
946
+ : self.latestSelectedDateObj ||
947
+ (self.config.minDate && self.config.minDate > self.now
948
+ ? self.config.minDate
949
+ : self.config.maxDate && self.config.maxDate < self.now
950
+ ? self.config.maxDate
951
+ : self.now);
952
+ var oldYear = self.currentYear;
953
+ var oldMonth = self.currentMonth;
954
+ try {
955
+ if (jumpTo !== undefined) {
956
+ self.currentYear = jumpTo.getFullYear();
957
+ self.currentMonth = jumpTo.getMonth();
958
+ }
959
+ }
960
+ catch (e) {
961
+ /* istanbul ignore next */
962
+ e.message = "Invalid date supplied: " + jumpTo;
963
+ self.config.errorHandler(e);
964
+ }
965
+ if (triggerChange && self.currentYear !== oldYear) {
966
+ triggerEvent("onYearChange");
967
+ buildMonthSwitch();
968
+ }
969
+ if (triggerChange &&
970
+ (self.currentYear !== oldYear || self.currentMonth !== oldMonth)) {
971
+ triggerEvent("onMonthChange");
972
+ }
973
+ self.redraw();
974
+ }
975
+ /**
976
+ * The up/down arrow handler for time inputs
977
+ * @param {Event} e the click event
978
+ */
979
+ function timeIncrement(e) {
980
+ var eventTarget = getEventTarget(e);
981
+ if (~eventTarget.className.indexOf("arrow"))
982
+ incrementNumInput(e, eventTarget.classList.contains("arrowUp") ? 1 : -1);
983
+ }
984
+ /**
985
+ * Increments/decrements the value of input associ-
986
+ * ated with the up/down arrow by dispatching an
987
+ * "increment" event on the input.
988
+ *
989
+ * @param {Event} e the click event
990
+ * @param {Number} delta the diff (usually 1 or -1)
991
+ * @param {Element} inputElem the input element
992
+ */
993
+ function incrementNumInput(e, delta, inputElem) {
994
+ var target = e && getEventTarget(e);
995
+ var input = inputElem ||
996
+ (target && target.parentNode && target.parentNode.firstChild);
997
+ var event = createEvent("increment");
998
+ event.delta = delta;
999
+ input && input.dispatchEvent(event);
1000
+ }
1001
+ function build() {
1002
+ var fragment = doc.createDocumentFragment();
1003
+ self.calendarContainer = createElement("div", "flatpickr-calendar");
1004
+ self.calendarContainer.tabIndex = -1;
1005
+ if (!self.config.noCalendar) {
1006
+ fragment.appendChild(buildMonthNav());
1007
+ self.innerContainer = createElement("div", "flatpickr-innerContainer");
1008
+ if (self.config.weekNumbers) {
1009
+ var _a = buildWeeks(), weekWrapper = _a.weekWrapper, weekNumbers = _a.weekNumbers;
1010
+ self.innerContainer.appendChild(weekWrapper);
1011
+ self.weekNumbers = weekNumbers;
1012
+ self.weekWrapper = weekWrapper;
1013
+ }
1014
+ self.rContainer = createElement("div", "flatpickr-rContainer");
1015
+ self.rContainer.appendChild(buildWeekdays());
1016
+ if (!self.daysContainer) {
1017
+ self.daysContainer = createElement("div", "flatpickr-days");
1018
+ self.daysContainer.tabIndex = -1;
1019
+ }
1020
+ buildDays();
1021
+ self.rContainer.appendChild(self.daysContainer);
1022
+ self.innerContainer.appendChild(self.rContainer);
1023
+ fragment.appendChild(self.innerContainer);
1024
+ }
1025
+ if (self.config.enableTime) {
1026
+ fragment.appendChild(buildTime());
1027
+ }
1028
+ toggleClass(self.calendarContainer, "rangeMode", self.config.mode === "range");
1029
+ toggleClass(self.calendarContainer, "animate", self.config.animate === true);
1030
+ toggleClass(self.calendarContainer, "multiMonth", self.config.showMonths > 1);
1031
+ self.calendarContainer.appendChild(fragment);
1032
+ var customAppend = self.config.appendTo !== undefined &&
1033
+ self.config.appendTo.nodeType !== undefined;
1034
+ if (self.config.inline || self.config.static) {
1035
+ self.calendarContainer.classList.add(self.config.inline ? "inline" : "static");
1036
+ if (self.config.inline) {
1037
+ if (!customAppend && self.element.parentNode)
1038
+ self.element.parentNode.insertBefore(self.calendarContainer, self._input.nextSibling);
1039
+ else if (self.config.appendTo !== undefined)
1040
+ self.config.appendTo.appendChild(self.calendarContainer);
1041
+ }
1042
+ if (self.config.static) {
1043
+ var wrapper = createElement("div", "flatpickr-wrapper");
1044
+ if (self.element.parentNode)
1045
+ self.element.parentNode.insertBefore(wrapper, self.element);
1046
+ wrapper.appendChild(self.element);
1047
+ if (self.altInput)
1048
+ wrapper.appendChild(self.altInput);
1049
+ wrapper.appendChild(self.calendarContainer);
1050
+ }
1051
+ }
1052
+ if (!self.config.static && !self.config.inline)
1053
+ (self.config.appendTo !== undefined
1054
+ ? self.config.appendTo
1055
+ : doc.body).appendChild(self.calendarContainer);
1056
+ }
1057
+ function createDay(className, date, _dayNumber, i) {
1058
+ var dateIsEnabled = isEnabled(date, true), dayElement = createElement("span", className, date.getDate().toString());
1059
+ dayElement.dateObj = date;
1060
+ dayElement.$i = i;
1061
+ dayElement.setAttribute("aria-label", self.formatDate(date, self.config.ariaDateFormat));
1062
+ if (className.indexOf("hidden") === -1 &&
1063
+ compareDates(date, self.now) === 0) {
1064
+ self.todayDateElem = dayElement;
1065
+ dayElement.classList.add("today");
1066
+ dayElement.setAttribute("aria-current", "date");
1067
+ }
1068
+ if (dateIsEnabled) {
1069
+ dayElement.tabIndex = -1;
1070
+ if (isDateSelected(date)) {
1071
+ dayElement.classList.add("selected");
1072
+ self.selectedDateElem = dayElement;
1073
+ if (self.config.mode === "range") {
1074
+ toggleClass(dayElement, "startRange", self.selectedDates[0] &&
1075
+ compareDates(date, self.selectedDates[0], true) === 0);
1076
+ toggleClass(dayElement, "endRange", self.selectedDates[1] &&
1077
+ compareDates(date, self.selectedDates[1], true) === 0);
1078
+ if (className === "nextMonthDay")
1079
+ dayElement.classList.add("inRange");
1080
+ }
1081
+ }
1082
+ }
1083
+ else {
1084
+ dayElement.classList.add("flatpickr-disabled");
1085
+ }
1086
+ if (self.config.mode === "range") {
1087
+ if (isDateInRange(date) && !isDateSelected(date))
1088
+ dayElement.classList.add("inRange");
1089
+ }
1090
+ if (self.weekNumbers &&
1091
+ self.config.showMonths === 1 &&
1092
+ className !== "prevMonthDay" &&
1093
+ i % 7 === 6) {
1094
+ self.weekNumbers.insertAdjacentHTML("beforeend", "<span class='flatpickr-day'>" + self.config.getWeek(date) + "</span>");
1095
+ }
1096
+ triggerEvent("onDayCreate", dayElement);
1097
+ return dayElement;
1098
+ }
1099
+ function focusOnDayElem(targetNode) {
1100
+ targetNode.focus();
1101
+ if (self.config.mode === "range")
1102
+ onMouseOver(targetNode);
1103
+ }
1104
+ function getFirstAvailableDay(delta) {
1105
+ var startMonth = delta > 0 ? 0 : self.config.showMonths - 1;
1106
+ var endMonth = delta > 0 ? self.config.showMonths : -1;
1107
+ for (var m = startMonth; m != endMonth; m += delta) {
1108
+ var month = self.daysContainer.children[m];
1109
+ var startIndex = delta > 0 ? 0 : month.children.length - 1;
1110
+ var endIndex = delta > 0 ? month.children.length : -1;
1111
+ for (var i = startIndex; i != endIndex; i += delta) {
1112
+ var c = month.children[i];
1113
+ if (c.className.indexOf("hidden") === -1 && isEnabled(c.dateObj))
1114
+ return c;
1115
+ }
1116
+ }
1117
+ return undefined;
1118
+ }
1119
+ function getNextAvailableDay(current, delta) {
1120
+ var givenMonth = current.className.indexOf("Month") === -1
1121
+ ? current.dateObj.getMonth()
1122
+ : self.currentMonth;
1123
+ var endMonth = delta > 0 ? self.config.showMonths : -1;
1124
+ var loopDelta = delta > 0 ? 1 : -1;
1125
+ for (var m = givenMonth - self.currentMonth; m != endMonth; m += loopDelta) {
1126
+ var month = self.daysContainer.children[m];
1127
+ var startIndex = givenMonth - self.currentMonth === m
1128
+ ? current.$i + delta
1129
+ : delta < 0
1130
+ ? month.children.length - 1
1131
+ : 0;
1132
+ var numMonthDays = month.children.length;
1133
+ for (var i = startIndex; i >= 0 && i < numMonthDays && i != (delta > 0 ? numMonthDays : -1); i += loopDelta) {
1134
+ var c = month.children[i];
1135
+ if (c.className.indexOf("hidden") === -1 &&
1136
+ isEnabled(c.dateObj) &&
1137
+ Math.abs(current.$i - i) >= Math.abs(delta))
1138
+ return focusOnDayElem(c);
1139
+ }
1140
+ }
1141
+ self.changeMonth(loopDelta);
1142
+ focusOnDay(getFirstAvailableDay(loopDelta), 0);
1143
+ return undefined;
1144
+ }
1145
+ function focusOnDay(current, offset) {
1146
+ var activeElement = getClosestActiveElement();
1147
+ var dayFocused = isInView(activeElement || doc.body);
1148
+ var startElem = current !== undefined
1149
+ ? current
1150
+ : dayFocused
1151
+ ? activeElement
1152
+ : self.selectedDateElem !== undefined && isInView(self.selectedDateElem)
1153
+ ? self.selectedDateElem
1154
+ : self.todayDateElem !== undefined && isInView(self.todayDateElem)
1155
+ ? self.todayDateElem
1156
+ : getFirstAvailableDay(offset > 0 ? 1 : -1);
1157
+ if (startElem === undefined) {
1158
+ self._input.focus();
1159
+ }
1160
+ else if (!dayFocused) {
1161
+ focusOnDayElem(startElem);
1162
+ }
1163
+ else {
1164
+ getNextAvailableDay(startElem, offset);
1165
+ }
1166
+ }
1167
+ function buildMonthDays(year, month) {
1168
+ var firstOfMonth = (new Date(year, month, 1).getDay() - self.l10n.firstDayOfWeek + 7) % 7;
1169
+ var prevMonthDays = self.utils.getDaysInMonth((month - 1 + 12) % 12, year);
1170
+ var daysInMonth = self.utils.getDaysInMonth(month, year), days = doc.createDocumentFragment(), isMultiMonth = self.config.showMonths > 1, prevMonthDayClass = isMultiMonth ? "prevMonthDay hidden" : "prevMonthDay", nextMonthDayClass = isMultiMonth ? "nextMonthDay hidden" : "nextMonthDay";
1171
+ var dayNumber = prevMonthDays + 1 - firstOfMonth, dayIndex = 0;
1172
+ // prepend days from the ending of previous month
1173
+ for (; dayNumber <= prevMonthDays; dayNumber++, dayIndex++) {
1174
+ days.appendChild(createDay("flatpickr-day " + prevMonthDayClass, new Date(year, month - 1, dayNumber), dayNumber, dayIndex));
1175
+ }
1176
+ // Start at 1 since there is no 0th day
1177
+ for (dayNumber = 1; dayNumber <= daysInMonth; dayNumber++, dayIndex++) {
1178
+ days.appendChild(createDay("flatpickr-day", new Date(year, month, dayNumber), dayNumber, dayIndex));
1179
+ }
1180
+ // append days from the next month
1181
+ for (var dayNum = daysInMonth + 1; dayNum <= 42 - firstOfMonth &&
1182
+ (self.config.showMonths === 1 || dayIndex % 7 !== 0); dayNum++, dayIndex++) {
1183
+ days.appendChild(createDay("flatpickr-day " + nextMonthDayClass, new Date(year, month + 1, dayNum % daysInMonth), dayNum, dayIndex));
1184
+ }
1185
+ //updateNavigationCurrentMonth();
1186
+ var dayContainer = createElement("div", "dayContainer");
1187
+ dayContainer.appendChild(days);
1188
+ return dayContainer;
1189
+ }
1190
+ function buildDays() {
1191
+ if (self.daysContainer === undefined) {
1192
+ return;
1193
+ }
1194
+ clearNode(self.daysContainer);
1195
+ // TODO: week numbers for each month
1196
+ if (self.weekNumbers)
1197
+ clearNode(self.weekNumbers);
1198
+ var frag = doc.createDocumentFragment();
1199
+ for (var i = 0; i < self.config.showMonths; i++) {
1200
+ var d = new Date(self.currentYear, self.currentMonth, 1);
1201
+ d.setMonth(self.currentMonth + i);
1202
+ frag.appendChild(buildMonthDays(d.getFullYear(), d.getMonth()));
1203
+ }
1204
+ self.daysContainer.appendChild(frag);
1205
+ self.days = self.daysContainer.firstChild;
1206
+ if (self.config.mode === "range" && self.selectedDates.length === 1) {
1207
+ onMouseOver();
1208
+ }
1209
+ }
1210
+ function buildMonthSwitch() {
1211
+ if (self.config.showMonths > 1 ||
1212
+ self.config.monthSelectorType !== "dropdown")
1213
+ return;
1214
+ var shouldBuildMonth = function (month) {
1215
+ if (self.config.minDate !== undefined &&
1216
+ self.currentYear === self.config.minDate.getFullYear() &&
1217
+ month < self.config.minDate.getMonth()) {
1218
+ return false;
1219
+ }
1220
+ return !(self.config.maxDate !== undefined &&
1221
+ self.currentYear === self.config.maxDate.getFullYear() &&
1222
+ month > self.config.maxDate.getMonth());
1223
+ };
1224
+ self.monthsDropdownContainer.tabIndex = -1;
1225
+ self.monthsDropdownContainer.innerHTML = "";
1226
+ for (var i = 0; i < 12; i++) {
1227
+ if (!shouldBuildMonth(i))
1228
+ continue;
1229
+ var month = createElement("option", "flatpickr-monthDropdown-month");
1230
+ month.value = new Date(self.currentYear, i).getMonth().toString();
1231
+ month.textContent = monthToStr(i, self.config.shorthandCurrentMonth, self.l10n);
1232
+ month.tabIndex = -1;
1233
+ if (self.currentMonth === i) {
1234
+ month.selected = true;
1235
+ }
1236
+ self.monthsDropdownContainer.appendChild(month);
1237
+ }
1238
+ }
1239
+ function buildMonth() {
1240
+ var container = createElement("div", "flatpickr-month");
1241
+ var monthNavFragment = doc.createDocumentFragment();
1242
+ var monthElement;
1243
+ if (self.config.showMonths > 1 ||
1244
+ self.config.monthSelectorType === "static") {
1245
+ monthElement = createElement("span", "cur-month");
1246
+ }
1247
+ else {
1248
+ self.monthsDropdownContainer = createElement("select", "flatpickr-monthDropdown-months");
1249
+ self.monthsDropdownContainer.setAttribute("aria-label", self.l10n.monthAriaLabel);
1250
+ bind(self.monthsDropdownContainer, "change", function (e) {
1251
+ var target = getEventTarget(e);
1252
+ var selectedMonth = parseInt(target.value, 10);
1253
+ self.changeMonth(selectedMonth - self.currentMonth);
1254
+ triggerEvent("onMonthChange");
1255
+ });
1256
+ buildMonthSwitch();
1257
+ monthElement = self.monthsDropdownContainer;
1258
+ }
1259
+ var yearInput = createNumberInput("cur-year", { tabindex: "-1" });
1260
+ var yearElement = yearInput.getElementsByTagName("input")[0];
1261
+ yearElement.setAttribute("aria-label", self.l10n.yearAriaLabel);
1262
+ if (self.config.minDate) {
1263
+ yearElement.setAttribute("min", self.config.minDate.getFullYear().toString());
1264
+ }
1265
+ if (self.config.maxDate) {
1266
+ yearElement.setAttribute("max", self.config.maxDate.getFullYear().toString());
1267
+ yearElement.disabled =
1268
+ !!self.config.minDate &&
1269
+ self.config.minDate.getFullYear() === self.config.maxDate.getFullYear();
1270
+ }
1271
+ var currentMonth = createElement("div", "flatpickr-current-month");
1272
+ currentMonth.appendChild(monthElement);
1273
+ currentMonth.appendChild(yearInput);
1274
+ monthNavFragment.appendChild(currentMonth);
1275
+ container.appendChild(monthNavFragment);
1276
+ return {
1277
+ container: container,
1278
+ yearElement: yearElement,
1279
+ monthElement: monthElement,
1280
+ };
1281
+ }
1282
+ function buildMonths() {
1283
+ clearNode(self.monthNav);
1284
+ self.monthNav.appendChild(self.prevMonthNav);
1285
+ if (self.config.showMonths) {
1286
+ self.yearElements = [];
1287
+ self.monthElements = [];
1288
+ }
1289
+ for (var m = self.config.showMonths; m--;) {
1290
+ var month = buildMonth();
1291
+ self.yearElements.push(month.yearElement);
1292
+ self.monthElements.push(month.monthElement);
1293
+ self.monthNav.appendChild(month.container);
1294
+ }
1295
+ self.monthNav.appendChild(self.nextMonthNav);
1296
+ }
1297
+ function buildMonthNav() {
1298
+ self.monthNav = createElement("div", "flatpickr-months");
1299
+ self.yearElements = [];
1300
+ self.monthElements = [];
1301
+ self.prevMonthNav = createElement("span", "flatpickr-prev-month");
1302
+ self.prevMonthNav.innerHTML = self.config.prevArrow;
1303
+ self.nextMonthNav = createElement("span", "flatpickr-next-month");
1304
+ self.nextMonthNav.innerHTML = self.config.nextArrow;
1305
+ buildMonths();
1306
+ Object.defineProperty(self, "_hidePrevMonthArrow", {
1307
+ get: function () { return self.__hidePrevMonthArrow; },
1308
+ set: function (bool) {
1309
+ if (self.__hidePrevMonthArrow !== bool) {
1310
+ toggleClass(self.prevMonthNav, "flatpickr-disabled", bool);
1311
+ self.__hidePrevMonthArrow = bool;
1312
+ }
1313
+ },
1314
+ });
1315
+ Object.defineProperty(self, "_hideNextMonthArrow", {
1316
+ get: function () { return self.__hideNextMonthArrow; },
1317
+ set: function (bool) {
1318
+ if (self.__hideNextMonthArrow !== bool) {
1319
+ toggleClass(self.nextMonthNav, "flatpickr-disabled", bool);
1320
+ self.__hideNextMonthArrow = bool;
1321
+ }
1322
+ },
1323
+ });
1324
+ self.currentYearElement = self.yearElements[0];
1325
+ updateNavigationCurrentMonth();
1326
+ return self.monthNav;
1327
+ }
1328
+ function buildTime() {
1329
+ self.calendarContainer.classList.add("hasTime");
1330
+ if (self.config.noCalendar)
1331
+ self.calendarContainer.classList.add("noCalendar");
1332
+ var defaults = getDefaultHours(self.config);
1333
+ self.timeContainer = createElement("div", "flatpickr-time");
1334
+ self.timeContainer.tabIndex = -1;
1335
+ var separator = createElement("span", "flatpickr-time-separator", ":");
1336
+ var hourInput = createNumberInput("flatpickr-hour", {
1337
+ "aria-label": self.l10n.hourAriaLabel,
1338
+ });
1339
+ self.hourElement = hourInput.getElementsByTagName("input")[0];
1340
+ var minuteInput = createNumberInput("flatpickr-minute", {
1341
+ "aria-label": self.l10n.minuteAriaLabel,
1342
+ });
1343
+ self.minuteElement = minuteInput.getElementsByTagName("input")[0];
1344
+ self.hourElement.tabIndex = self.minuteElement.tabIndex = -1;
1345
+ self.hourElement.value = pad(self.latestSelectedDateObj
1346
+ ? self.latestSelectedDateObj.getHours()
1347
+ : self.config.time_24hr
1348
+ ? defaults.hours
1349
+ : military2ampm(defaults.hours));
1350
+ self.minuteElement.value = pad(self.latestSelectedDateObj
1351
+ ? self.latestSelectedDateObj.getMinutes()
1352
+ : defaults.minutes);
1353
+ self.hourElement.setAttribute("step", self.config.hourIncrement.toString());
1354
+ self.minuteElement.setAttribute("step", self.config.minuteIncrement.toString());
1355
+ self.hourElement.setAttribute("min", self.config.time_24hr ? "0" : "1");
1356
+ self.hourElement.setAttribute("max", self.config.time_24hr ? "23" : "12");
1357
+ self.hourElement.setAttribute("maxlength", "2");
1358
+ self.minuteElement.setAttribute("min", "0");
1359
+ self.minuteElement.setAttribute("max", "59");
1360
+ self.minuteElement.setAttribute("maxlength", "2");
1361
+ self.timeContainer.appendChild(hourInput);
1362
+ self.timeContainer.appendChild(separator);
1363
+ self.timeContainer.appendChild(minuteInput);
1364
+ if (self.config.time_24hr)
1365
+ self.timeContainer.classList.add("time24hr");
1366
+ if (self.config.enableSeconds) {
1367
+ self.timeContainer.classList.add("hasSeconds");
1368
+ var secondInput = createNumberInput("flatpickr-second");
1369
+ self.secondElement = secondInput.getElementsByTagName("input")[0];
1370
+ self.secondElement.value = pad(self.latestSelectedDateObj
1371
+ ? self.latestSelectedDateObj.getSeconds()
1372
+ : defaults.seconds);
1373
+ self.secondElement.setAttribute("step", self.minuteElement.getAttribute("step"));
1374
+ self.secondElement.setAttribute("min", "0");
1375
+ self.secondElement.setAttribute("max", "59");
1376
+ self.secondElement.setAttribute("maxlength", "2");
1377
+ self.timeContainer.appendChild(createElement("span", "flatpickr-time-separator", ":"));
1378
+ self.timeContainer.appendChild(secondInput);
1379
+ }
1380
+ if (!self.config.time_24hr) {
1381
+ // add self.amPM if appropriate
1382
+ self.amPM = createElement("span", "flatpickr-am-pm", self.l10n.amPM[int((self.latestSelectedDateObj
1383
+ ? self.hourElement.value
1384
+ : self.config.defaultHour) > 11)]);
1385
+ self.amPM.title = self.l10n.toggleTitle;
1386
+ self.amPM.tabIndex = -1;
1387
+ self.timeContainer.appendChild(self.amPM);
1388
+ }
1389
+ return self.timeContainer;
1390
+ }
1391
+ function buildWeekdays() {
1392
+ if (!self.weekdayContainer)
1393
+ self.weekdayContainer = createElement("div", "flatpickr-weekdays");
1394
+ else
1395
+ clearNode(self.weekdayContainer);
1396
+ for (var i = self.config.showMonths; i--;) {
1397
+ var container = createElement("div", "flatpickr-weekdaycontainer");
1398
+ self.weekdayContainer.appendChild(container);
1399
+ }
1400
+ updateWeekdays();
1401
+ return self.weekdayContainer;
1402
+ }
1403
+ function updateWeekdays() {
1404
+ if (!self.weekdayContainer) {
1405
+ return;
1406
+ }
1407
+ var firstDayOfWeek = self.l10n.firstDayOfWeek;
1408
+ var weekdays = __spreadArrays(self.l10n.weekdays.shorthand);
1409
+ if (firstDayOfWeek > 0 && firstDayOfWeek < weekdays.length) {
1410
+ weekdays = __spreadArrays(weekdays.splice(firstDayOfWeek, weekdays.length), weekdays.splice(0, firstDayOfWeek));
1411
+ }
1412
+ for (var i = self.config.showMonths; i--;) {
1413
+ self.weekdayContainer.children[i].innerHTML = "\n <span class='flatpickr-weekday'>\n " + weekdays.join("</span><span class='flatpickr-weekday'>") + "\n </span>\n ";
1414
+ }
1415
+ }
1416
+ /* istanbul ignore next */
1417
+ function buildWeeks() {
1418
+ self.calendarContainer.classList.add("hasWeeks");
1419
+ var weekWrapper = createElement("div", "flatpickr-weekwrapper");
1420
+ weekWrapper.appendChild(createElement("span", "flatpickr-weekday", self.l10n.weekAbbreviation));
1421
+ var weekNumbers = createElement("div", "flatpickr-weeks");
1422
+ weekWrapper.appendChild(weekNumbers);
1423
+ return {
1424
+ weekWrapper: weekWrapper,
1425
+ weekNumbers: weekNumbers,
1426
+ };
1427
+ }
1428
+ function changeMonth(value, isOffset) {
1429
+ if (isOffset === void 0) { isOffset = true; }
1430
+ var delta = isOffset ? value : value - self.currentMonth;
1431
+ if ((delta < 0 && self._hidePrevMonthArrow === true) ||
1432
+ (delta > 0 && self._hideNextMonthArrow === true))
1433
+ return;
1434
+ self.currentMonth += delta;
1435
+ if (self.currentMonth < 0 || self.currentMonth > 11) {
1436
+ self.currentYear += self.currentMonth > 11 ? 1 : -1;
1437
+ self.currentMonth = (self.currentMonth + 12) % 12;
1438
+ triggerEvent("onYearChange");
1439
+ buildMonthSwitch();
1440
+ }
1441
+ buildDays();
1442
+ triggerEvent("onMonthChange");
1443
+ updateNavigationCurrentMonth();
1444
+ }
1445
+ function clear(triggerChangeEvent, toInitial) {
1446
+ if (triggerChangeEvent === void 0) { triggerChangeEvent = true; }
1447
+ if (toInitial === void 0) { toInitial = true; }
1448
+ self.input.value = "";
1449
+ if (self.altInput !== undefined)
1450
+ self.altInput.value = "";
1451
+ if (self.mobileInput !== undefined)
1452
+ self.mobileInput.value = "";
1453
+ self.selectedDates = [];
1454
+ self.latestSelectedDateObj = undefined;
1455
+ if (toInitial === true) {
1456
+ self.currentYear = self._initialDate.getFullYear();
1457
+ self.currentMonth = self._initialDate.getMonth();
1458
+ }
1459
+ if (self.config.enableTime === true) {
1460
+ var _a = getDefaultHours(self.config), hours = _a.hours, minutes = _a.minutes, seconds = _a.seconds;
1461
+ setHours(hours, minutes, seconds);
1462
+ }
1463
+ self.redraw();
1464
+ if (triggerChangeEvent)
1465
+ // triggerChangeEvent is true (default) or an Event
1466
+ triggerEvent("onChange");
1467
+ }
1468
+ function close() {
1469
+ self.isOpen = false;
1470
+ if (!self.isMobile) {
1471
+ if (self.calendarContainer !== undefined) {
1472
+ self.calendarContainer.classList.remove("open");
1473
+ }
1474
+ if (self._input !== undefined) {
1475
+ self._input.classList.remove("active");
1476
+ }
1477
+ }
1478
+ triggerEvent("onClose");
1479
+ }
1480
+ function destroy() {
1481
+ if (self.config !== undefined)
1482
+ triggerEvent("onDestroy");
1483
+ for (var i = self._handlers.length; i--;) {
1484
+ self._handlers[i].remove();
1485
+ }
1486
+ self._handlers = [];
1487
+ if (self.mobileInput) {
1488
+ if (self.mobileInput.parentNode)
1489
+ self.mobileInput.parentNode.removeChild(self.mobileInput);
1490
+ self.mobileInput = undefined;
1491
+ }
1492
+ else if (self.calendarContainer && self.calendarContainer.parentNode) {
1493
+ if (self.config.static && self.calendarContainer.parentNode) {
1494
+ var wrapper = self.calendarContainer.parentNode;
1495
+ wrapper.lastChild && wrapper.removeChild(wrapper.lastChild);
1496
+ if (wrapper.parentNode) {
1497
+ while (wrapper.firstChild)
1498
+ wrapper.parentNode.insertBefore(wrapper.firstChild, wrapper);
1499
+ wrapper.parentNode.removeChild(wrapper);
1500
+ }
1501
+ }
1502
+ else
1503
+ self.calendarContainer.parentNode.removeChild(self.calendarContainer);
1504
+ }
1505
+ if (self.altInput) {
1506
+ self.input.type = "text";
1507
+ if (self.altInput.parentNode)
1508
+ self.altInput.parentNode.removeChild(self.altInput);
1509
+ delete self.altInput;
1510
+ }
1511
+ if (self.input) {
1512
+ self.input.type = self.input._type;
1513
+ self.input.classList.remove("flatpickr-input");
1514
+ self.input.removeAttribute("readonly");
1515
+ }
1516
+ [
1517
+ "_showTimeInput",
1518
+ "latestSelectedDateObj",
1519
+ "_hideNextMonthArrow",
1520
+ "_hidePrevMonthArrow",
1521
+ "__hideNextMonthArrow",
1522
+ "__hidePrevMonthArrow",
1523
+ "isMobile",
1524
+ "isOpen",
1525
+ "selectedDateElem",
1526
+ "minDateHasTime",
1527
+ "maxDateHasTime",
1528
+ "days",
1529
+ "daysContainer",
1530
+ "_input",
1531
+ "_positionElement",
1532
+ "innerContainer",
1533
+ "rContainer",
1534
+ "monthNav",
1535
+ "todayDateElem",
1536
+ "calendarContainer",
1537
+ "weekdayContainer",
1538
+ "prevMonthNav",
1539
+ "nextMonthNav",
1540
+ "monthsDropdownContainer",
1541
+ "currentMonthElement",
1542
+ "currentYearElement",
1543
+ "navigationCurrentMonth",
1544
+ "selectedDateElem",
1545
+ "config",
1546
+ ].forEach(function (k) {
1547
+ try {
1548
+ delete self[k];
1549
+ }
1550
+ catch (_) { }
1551
+ });
1552
+ }
1553
+ function isCalendarElem(elem) {
1554
+ return self.calendarContainer.contains(elem);
1555
+ }
1556
+ function documentClick(e) {
1557
+ if (self.isOpen && !self.config.inline) {
1558
+ var eventTarget_1 = getEventTarget(e);
1559
+ var isCalendarElement = isCalendarElem(eventTarget_1);
1560
+ var isInput = eventTarget_1 === self.input ||
1561
+ eventTarget_1 === self.altInput ||
1562
+ self.element.contains(eventTarget_1);
1563
+ var lostFocus = !isInput &&
1564
+ !isCalendarElement &&
1565
+ !isCalendarElem(e.relatedTarget);
1566
+ var isIgnored = !self.config.ignoredFocusElements.some(function (elem) {
1567
+ return elem.contains(eventTarget_1);
1568
+ });
1569
+ if (lostFocus && isIgnored) {
1570
+ if (self.config.allowInput) {
1571
+ self.setDate(self._input.value, false, self.config.altInput
1572
+ ? self.config.altFormat
1573
+ : self.config.dateFormat);
1574
+ }
1575
+ if (self.timeContainer !== undefined &&
1576
+ self.minuteElement !== undefined &&
1577
+ self.hourElement !== undefined &&
1578
+ self.input.value !== "" &&
1579
+ self.input.value !== undefined) {
1580
+ updateTime();
1581
+ }
1582
+ self.close();
1583
+ if (self.config &&
1584
+ self.config.mode === "range" &&
1585
+ self.selectedDates.length === 1)
1586
+ self.clear(false);
1587
+ }
1588
+ }
1589
+ }
1590
+ function changeYear(newYear) {
1591
+ if (!newYear ||
1592
+ (self.config.minDate && newYear < self.config.minDate.getFullYear()) ||
1593
+ (self.config.maxDate && newYear > self.config.maxDate.getFullYear()))
1594
+ return;
1595
+ var newYearNum = newYear, isNewYear = self.currentYear !== newYearNum;
1596
+ self.currentYear = newYearNum || self.currentYear;
1597
+ if (self.config.maxDate &&
1598
+ self.currentYear === self.config.maxDate.getFullYear()) {
1599
+ self.currentMonth = Math.min(self.config.maxDate.getMonth(), self.currentMonth);
1600
+ }
1601
+ else if (self.config.minDate &&
1602
+ self.currentYear === self.config.minDate.getFullYear()) {
1603
+ self.currentMonth = Math.max(self.config.minDate.getMonth(), self.currentMonth);
1604
+ }
1605
+ if (isNewYear) {
1606
+ self.redraw();
1607
+ triggerEvent("onYearChange");
1608
+ buildMonthSwitch();
1609
+ }
1610
+ }
1611
+ function isEnabled(date, timeless) {
1612
+ var _a;
1613
+ if (timeless === void 0) { timeless = true; }
1614
+ var dateToCheck = self.parseDate(date, undefined, timeless); // timeless
1615
+ if ((self.config.minDate &&
1616
+ dateToCheck &&
1617
+ compareDates(dateToCheck, self.config.minDate, timeless !== undefined ? timeless : !self.minDateHasTime) < 0) ||
1618
+ (self.config.maxDate &&
1619
+ dateToCheck &&
1620
+ compareDates(dateToCheck, self.config.maxDate, timeless !== undefined ? timeless : !self.maxDateHasTime) > 0))
1621
+ return false;
1622
+ if (!self.config.enable && self.config.disable.length === 0)
1623
+ return true;
1624
+ if (dateToCheck === undefined)
1625
+ return false;
1626
+ var bool = !!self.config.enable, array = (_a = self.config.enable) !== null && _a !== void 0 ? _a : self.config.disable;
1627
+ for (var i = 0, d = void 0; i < array.length; i++) {
1628
+ d = array[i];
1629
+ if (typeof d === "function" &&
1630
+ d(dateToCheck) // disabled by function
1631
+ )
1632
+ return bool;
1633
+ else if (d instanceof Date &&
1634
+ dateToCheck !== undefined &&
1635
+ d.getTime() === dateToCheck.getTime())
1636
+ // disabled by date
1637
+ return bool;
1638
+ else if (typeof d === "string") {
1639
+ // disabled by date string
1640
+ var parsed = self.parseDate(d, undefined, true);
1641
+ return parsed && parsed.getTime() === dateToCheck.getTime()
1642
+ ? bool
1643
+ : !bool;
1644
+ }
1645
+ else if (
1646
+ // disabled by range
1647
+ typeof d === "object" &&
1648
+ dateToCheck !== undefined &&
1649
+ d.from &&
1650
+ d.to &&
1651
+ dateToCheck.getTime() >= d.from.getTime() &&
1652
+ dateToCheck.getTime() <= d.to.getTime())
1653
+ return bool;
1654
+ }
1655
+ return !bool;
1656
+ }
1657
+ function isInView(elem) {
1658
+ if (self.daysContainer !== undefined)
1659
+ return (elem.className.indexOf("hidden") === -1 &&
1660
+ elem.className.indexOf("flatpickr-disabled") === -1 &&
1661
+ self.daysContainer.contains(elem));
1662
+ return false;
1663
+ }
1664
+ function onBlur(e) {
1665
+ var isInput = e.target === self._input;
1666
+ var valueChanged = self._input.value.trimEnd() !== getDateStr();
1667
+ if (isInput &&
1668
+ valueChanged &&
1669
+ !(e.relatedTarget && isCalendarElem(e.relatedTarget))) {
1670
+ self.setDate(self._input.value, true, e.target === self.altInput
1671
+ ? self.config.altFormat
1672
+ : self.config.dateFormat);
1673
+ }
1674
+ }
1675
+ function onKeyDown(e) {
1676
+ // e.key e.keyCode
1677
+ // "Backspace" 8
1678
+ // "Tab" 9
1679
+ // "Enter" 13
1680
+ // "Escape" (IE "Esc") 27
1681
+ // "ArrowLeft" (IE "Left") 37
1682
+ // "ArrowUp" (IE "Up") 38
1683
+ // "ArrowRight" (IE "Right") 39
1684
+ // "ArrowDown" (IE "Down") 40
1685
+ // "Delete" (IE "Del") 46
1686
+ var eventTarget = getEventTarget(e);
1687
+ var isInput = self.config.wrap
1688
+ ? element.contains(eventTarget)
1689
+ : eventTarget === self._input;
1690
+ var allowInput = self.config.allowInput;
1691
+ var allowKeydown = self.isOpen && (!allowInput || !isInput);
1692
+ var allowInlineKeydown = self.config.inline && isInput && !allowInput;
1693
+ if (e.keyCode === 13 && isInput) {
1694
+ if (allowInput) {
1695
+ self.setDate(self._input.value, true, eventTarget === self.altInput
1696
+ ? self.config.altFormat
1697
+ : self.config.dateFormat);
1698
+ self.close();
1699
+ return eventTarget.blur();
1700
+ }
1701
+ else {
1702
+ self.open();
1703
+ }
1704
+ }
1705
+ else if (isCalendarElem(eventTarget) ||
1706
+ allowKeydown ||
1707
+ allowInlineKeydown) {
1708
+ var isTimeObj = !!self.timeContainer &&
1709
+ self.timeContainer.contains(eventTarget);
1710
+ switch (e.keyCode) {
1711
+ case 13:
1712
+ if (isTimeObj) {
1713
+ e.preventDefault();
1714
+ updateTime();
1715
+ focusAndClose();
1716
+ }
1717
+ else
1718
+ selectDate(e);
1719
+ break;
1720
+ case 27: // escape
1721
+ e.preventDefault();
1722
+ focusAndClose();
1723
+ break;
1724
+ case 8:
1725
+ case 46:
1726
+ if (isInput && !self.config.allowInput) {
1727
+ e.preventDefault();
1728
+ self.clear();
1729
+ }
1730
+ break;
1731
+ case 37:
1732
+ case 39:
1733
+ if (!isTimeObj && !isInput) {
1734
+ e.preventDefault();
1735
+ var activeElement = getClosestActiveElement();
1736
+ if (self.daysContainer !== undefined &&
1737
+ (allowInput === false ||
1738
+ (activeElement && isInView(activeElement)))) {
1739
+ var delta_1 = e.keyCode === 39 ? 1 : -1;
1740
+ if (!e.ctrlKey)
1741
+ focusOnDay(undefined, delta_1);
1742
+ else {
1743
+ e.stopPropagation();
1744
+ changeMonth(delta_1);
1745
+ focusOnDay(getFirstAvailableDay(1), 0);
1746
+ }
1747
+ }
1748
+ }
1749
+ else if (self.hourElement)
1750
+ self.hourElement.focus();
1751
+ break;
1752
+ case 38:
1753
+ case 40:
1754
+ e.preventDefault();
1755
+ var delta = e.keyCode === 40 ? 1 : -1;
1756
+ if ((self.daysContainer &&
1757
+ eventTarget.$i !== undefined) ||
1758
+ eventTarget === self.input ||
1759
+ eventTarget === self.altInput) {
1760
+ if (e.ctrlKey) {
1761
+ e.stopPropagation();
1762
+ changeYear(self.currentYear - delta);
1763
+ focusOnDay(getFirstAvailableDay(1), 0);
1764
+ }
1765
+ else if (!isTimeObj)
1766
+ focusOnDay(undefined, delta * 7);
1767
+ }
1768
+ else if (eventTarget === self.currentYearElement) {
1769
+ changeYear(self.currentYear - delta);
1770
+ }
1771
+ else if (self.config.enableTime) {
1772
+ if (!isTimeObj && self.hourElement)
1773
+ self.hourElement.focus();
1774
+ updateTime(e);
1775
+ self._debouncedChange();
1776
+ }
1777
+ break;
1778
+ case 9:
1779
+ if (isTimeObj) {
1780
+ var elems = [
1781
+ self.hourElement,
1782
+ self.minuteElement,
1783
+ self.secondElement,
1784
+ self.amPM,
1785
+ ]
1786
+ .concat(self.pluginElements)
1787
+ .filter(function (x) { return x; });
1788
+ var i = elems.indexOf(eventTarget);
1789
+ if (i !== -1) {
1790
+ var target = elems[i + (e.shiftKey ? -1 : 1)];
1791
+ e.preventDefault();
1792
+ (target || self._input).focus();
1793
+ }
1794
+ }
1795
+ else if (!self.config.noCalendar &&
1796
+ self.daysContainer &&
1797
+ self.daysContainer.contains(eventTarget) &&
1798
+ e.shiftKey) {
1799
+ e.preventDefault();
1800
+ self._input.focus();
1801
+ }
1802
+ break;
1803
+ }
1804
+ }
1805
+ if (self.amPM !== undefined && eventTarget === self.amPM) {
1806
+ switch (e.key) {
1807
+ case self.l10n.amPM[0].charAt(0):
1808
+ case self.l10n.amPM[0].charAt(0).toLowerCase():
1809
+ self.amPM.textContent = self.l10n.amPM[0];
1810
+ setHoursFromInputs();
1811
+ updateValue();
1812
+ break;
1813
+ case self.l10n.amPM[1].charAt(0):
1814
+ case self.l10n.amPM[1].charAt(0).toLowerCase():
1815
+ self.amPM.textContent = self.l10n.amPM[1];
1816
+ setHoursFromInputs();
1817
+ updateValue();
1818
+ break;
1819
+ }
1820
+ }
1821
+ if (isInput || isCalendarElem(eventTarget)) {
1822
+ triggerEvent("onKeyDown", e);
1823
+ }
1824
+ }
1825
+ function onMouseOver(elem, cellClass) {
1826
+ if (cellClass === void 0) { cellClass = "flatpickr-day"; }
1827
+ if (self.selectedDates.length !== 1 ||
1828
+ (elem &&
1829
+ (!elem.classList.contains(cellClass) ||
1830
+ elem.classList.contains("flatpickr-disabled"))))
1831
+ return;
1832
+ var hoverDate = elem
1833
+ ? elem.dateObj.getTime()
1834
+ : self.days.firstElementChild.dateObj.getTime(), initialDate = self.parseDate(self.selectedDates[0], undefined, true).getTime(), rangeStartDate = Math.min(hoverDate, self.selectedDates[0].getTime()), rangeEndDate = Math.max(hoverDate, self.selectedDates[0].getTime());
1835
+ var containsDisabled = false;
1836
+ var minRange = 0, maxRange = 0;
1837
+ for (var t = rangeStartDate; t < rangeEndDate; t += duration.DAY) {
1838
+ if (!isEnabled(new Date(t), true)) {
1839
+ containsDisabled =
1840
+ containsDisabled || (t > rangeStartDate && t < rangeEndDate);
1841
+ if (t < initialDate && (!minRange || t > minRange))
1842
+ minRange = t;
1843
+ else if (t > initialDate && (!maxRange || t < maxRange))
1844
+ maxRange = t;
1845
+ }
1846
+ }
1847
+ var hoverableCells = Array.from(self.rContainer.querySelectorAll("*:nth-child(-n+" + self.config.showMonths + ") > ." + cellClass));
1848
+ hoverableCells.forEach(function (dayElem) {
1849
+ var date = dayElem.dateObj;
1850
+ var timestamp = date.getTime();
1851
+ var outOfRange = (minRange > 0 && timestamp < minRange) ||
1852
+ (maxRange > 0 && timestamp > maxRange);
1853
+ if (outOfRange) {
1854
+ dayElem.classList.add("notAllowed");
1855
+ ["inRange", "startRange", "endRange"].forEach(function (c) {
1856
+ dayElem.classList.remove(c);
1857
+ });
1858
+ return;
1859
+ }
1860
+ else if (containsDisabled && !outOfRange)
1861
+ return;
1862
+ ["startRange", "inRange", "endRange", "notAllowed"].forEach(function (c) {
1863
+ dayElem.classList.remove(c);
1864
+ });
1865
+ if (elem !== undefined) {
1866
+ elem.classList.add(hoverDate <= self.selectedDates[0].getTime()
1867
+ ? "startRange"
1868
+ : "endRange");
1869
+ if (initialDate < hoverDate && timestamp === initialDate)
1870
+ dayElem.classList.add("startRange");
1871
+ else if (initialDate > hoverDate && timestamp === initialDate)
1872
+ dayElem.classList.add("endRange");
1873
+ if (timestamp >= minRange &&
1874
+ (maxRange === 0 || timestamp <= maxRange) &&
1875
+ isBetween(timestamp, initialDate, hoverDate))
1876
+ dayElem.classList.add("inRange");
1877
+ }
1878
+ });
1879
+ }
1880
+ function onResize() {
1881
+ if (self.isOpen && !self.config.static && !self.config.inline)
1882
+ positionCalendar();
1883
+ }
1884
+ function open(e, positionElement) {
1885
+ if (positionElement === void 0) { positionElement = self._positionElement; }
1886
+ if (self.isMobile === true) {
1887
+ if (e) {
1888
+ e.preventDefault();
1889
+ var eventTarget = getEventTarget(e);
1890
+ if (eventTarget) {
1891
+ eventTarget.blur();
1892
+ }
1893
+ }
1894
+ if (self.mobileInput !== undefined) {
1895
+ self.mobileInput.focus();
1896
+ self.mobileInput.click();
1897
+ }
1898
+ triggerEvent("onOpen");
1899
+ return;
1900
+ }
1901
+ else if (self._input.disabled || self.config.inline) {
1902
+ return;
1903
+ }
1904
+ var wasOpen = self.isOpen;
1905
+ self.isOpen = true;
1906
+ if (!wasOpen) {
1907
+ self.calendarContainer.classList.add("open");
1908
+ self._input.classList.add("active");
1909
+ triggerEvent("onOpen");
1910
+ positionCalendar(positionElement);
1911
+ }
1912
+ if (self.config.enableTime === true && self.config.noCalendar === true) {
1913
+ if (self.config.allowInput === false &&
1914
+ (e === undefined ||
1915
+ !self.timeContainer.contains(e.relatedTarget))) {
1916
+ setTimeout(function () { return self.hourElement.select(); }, 50);
1917
+ }
1918
+ }
1919
+ }
1920
+ function minMaxDateSetter(type) {
1921
+ return function (date) {
1922
+ var dateObj = (self.config["_" + type + "Date"] = self.parseDate(date, self.config.dateFormat));
1923
+ var inverseDateObj = self.config["_" + (type === "min" ? "max" : "min") + "Date"];
1924
+ if (dateObj !== undefined) {
1925
+ self[type === "min" ? "minDateHasTime" : "maxDateHasTime"] =
1926
+ dateObj.getHours() > 0 ||
1927
+ dateObj.getMinutes() > 0 ||
1928
+ dateObj.getSeconds() > 0;
1929
+ }
1930
+ if (self.selectedDates) {
1931
+ self.selectedDates = self.selectedDates.filter(function (d) { return isEnabled(d); });
1932
+ if (!self.selectedDates.length && type === "min")
1933
+ setHoursFromDate(dateObj);
1934
+ updateValue();
1935
+ }
1936
+ if (self.daysContainer) {
1937
+ redraw();
1938
+ if (dateObj !== undefined)
1939
+ self.currentYearElement[type] = dateObj.getFullYear().toString();
1940
+ else
1941
+ self.currentYearElement.removeAttribute(type);
1942
+ self.currentYearElement.disabled =
1943
+ !!inverseDateObj &&
1944
+ dateObj !== undefined &&
1945
+ inverseDateObj.getFullYear() === dateObj.getFullYear();
1946
+ }
1947
+ };
1948
+ }
1949
+ function parseConfig() {
1950
+ var boolOpts = [
1951
+ "wrap",
1952
+ "weekNumbers",
1953
+ "allowInput",
1954
+ "allowInvalidPreload",
1955
+ "clickOpens",
1956
+ "time_24hr",
1957
+ "enableTime",
1958
+ "noCalendar",
1959
+ "altInput",
1960
+ "shorthandCurrentMonth",
1961
+ "inline",
1962
+ "static",
1963
+ "enableSeconds",
1964
+ "disableMobile",
1965
+ ];
1966
+ var userConfig = __assign(__assign({}, JSON.parse(JSON.stringify(element.dataset || {}))), instanceConfig);
1967
+ var formats = {};
1968
+ self.config.parseDate = userConfig.parseDate;
1969
+ self.config.formatDate = userConfig.formatDate;
1970
+ Object.defineProperty(self.config, "enable", {
1971
+ get: function () { return self.config._enable; },
1972
+ set: function (dates) {
1973
+ self.config._enable = parseDateRules(dates);
1974
+ },
1975
+ });
1976
+ Object.defineProperty(self.config, "disable", {
1977
+ get: function () { return self.config._disable; },
1978
+ set: function (dates) {
1979
+ self.config._disable = parseDateRules(dates);
1980
+ },
1981
+ });
1982
+ var timeMode = userConfig.mode === "time";
1983
+ if (!userConfig.dateFormat && (userConfig.enableTime || timeMode)) {
1984
+ var defaultDateFormat = flatpickr.defaultConfig.dateFormat || defaults.dateFormat;
1985
+ formats.dateFormat =
1986
+ userConfig.noCalendar || timeMode
1987
+ ? "H:i" + (userConfig.enableSeconds ? ":S" : "")
1988
+ : defaultDateFormat + " H:i" + (userConfig.enableSeconds ? ":S" : "");
1989
+ }
1990
+ if (userConfig.altInput &&
1991
+ (userConfig.enableTime || timeMode) &&
1992
+ !userConfig.altFormat) {
1993
+ var defaultAltFormat = flatpickr.defaultConfig.altFormat || defaults.altFormat;
1994
+ formats.altFormat =
1995
+ userConfig.noCalendar || timeMode
1996
+ ? "h:i" + (userConfig.enableSeconds ? ":S K" : " K")
1997
+ : defaultAltFormat + (" h:i" + (userConfig.enableSeconds ? ":S" : "") + " K");
1998
+ }
1999
+ Object.defineProperty(self.config, "minDate", {
2000
+ get: function () { return self.config._minDate; },
2001
+ set: minMaxDateSetter("min"),
2002
+ });
2003
+ Object.defineProperty(self.config, "maxDate", {
2004
+ get: function () { return self.config._maxDate; },
2005
+ set: minMaxDateSetter("max"),
2006
+ });
2007
+ var minMaxTimeSetter = function (type) { return function (val) {
2008
+ self.config[type === "min" ? "_minTime" : "_maxTime"] = self.parseDate(val, "H:i:S");
2009
+ }; };
2010
+ Object.defineProperty(self.config, "minTime", {
2011
+ get: function () { return self.config._minTime; },
2012
+ set: minMaxTimeSetter("min"),
2013
+ });
2014
+ Object.defineProperty(self.config, "maxTime", {
2015
+ get: function () { return self.config._maxTime; },
2016
+ set: minMaxTimeSetter("max"),
2017
+ });
2018
+ if (userConfig.mode === "time") {
2019
+ self.config.noCalendar = true;
2020
+ self.config.enableTime = true;
2021
+ }
2022
+ Object.assign(self.config, formats, userConfig);
2023
+ for (var i = 0; i < boolOpts.length; i++)
2024
+ // https://github.com/microsoft/TypeScript/issues/31663
2025
+ self.config[boolOpts[i]] =
2026
+ self.config[boolOpts[i]] === true ||
2027
+ self.config[boolOpts[i]] === "true";
2028
+ HOOKS.filter(function (hook) { return self.config[hook] !== undefined; }).forEach(function (hook) {
2029
+ self.config[hook] = arrayify(self.config[hook] || []).map(bindToInstance);
2030
+ });
2031
+ self.isMobile =
2032
+ !self.config.disableMobile &&
2033
+ !self.config.inline &&
2034
+ self.config.mode === "single" &&
2035
+ !self.config.disable.length &&
2036
+ !self.config.enable &&
2037
+ !self.config.weekNumbers &&
2038
+ /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
2039
+ for (var i = 0; i < self.config.plugins.length; i++) {
2040
+ var pluginConf = self.config.plugins[i](self) || {};
2041
+ for (var key in pluginConf) {
2042
+ if (HOOKS.indexOf(key) > -1) {
2043
+ self.config[key] = arrayify(pluginConf[key])
2044
+ .map(bindToInstance)
2045
+ .concat(self.config[key]);
2046
+ }
2047
+ else if (typeof userConfig[key] === "undefined")
2048
+ self.config[key] = pluginConf[key];
2049
+ }
2050
+ }
2051
+ if (!userConfig.altInputClass) {
2052
+ self.config.altInputClass =
2053
+ getInputElem().className + " " + self.config.altInputClass;
2054
+ }
2055
+ triggerEvent("onParseConfig");
2056
+ }
2057
+ function getInputElem() {
2058
+ return self.config.wrap
2059
+ ? element.querySelector("[data-input]")
2060
+ : element;
2061
+ }
2062
+ function setupLocale() {
2063
+ if (typeof self.config.locale !== "object" &&
2064
+ typeof flatpickr.l10ns[self.config.locale] === "undefined")
2065
+ self.config.errorHandler(new Error("flatpickr: invalid locale " + self.config.locale));
2066
+ self.l10n = __assign(__assign({}, flatpickr.l10ns.default), (typeof self.config.locale === "object"
2067
+ ? self.config.locale
2068
+ : self.config.locale !== "default"
2069
+ ? flatpickr.l10ns[self.config.locale]
2070
+ : undefined));
2071
+ tokenRegex.D = "(" + self.l10n.weekdays.shorthand.join("|") + ")";
2072
+ tokenRegex.l = "(" + self.l10n.weekdays.longhand.join("|") + ")";
2073
+ tokenRegex.M = "(" + self.l10n.months.shorthand.join("|") + ")";
2074
+ tokenRegex.F = "(" + self.l10n.months.longhand.join("|") + ")";
2075
+ tokenRegex.K = "(" + self.l10n.amPM[0] + "|" + self.l10n.amPM[1] + "|" + self.l10n.amPM[0].toLowerCase() + "|" + self.l10n.amPM[1].toLowerCase() + ")";
2076
+ var userConfig = __assign(__assign({}, instanceConfig), JSON.parse(JSON.stringify(element.dataset || {})));
2077
+ if (userConfig.time_24hr === undefined &&
2078
+ flatpickr.defaultConfig.time_24hr === undefined) {
2079
+ self.config.time_24hr = self.l10n.time_24hr;
2080
+ }
2081
+ self.formatDate = createDateFormatter(self);
2082
+ self.parseDate = createDateParser({ config: self.config, l10n: self.l10n });
2083
+ }
2084
+ function positionCalendar(customPositionElement) {
2085
+ if (typeof self.config.position === "function") {
2086
+ return void self.config.position(self, customPositionElement);
2087
+ }
2088
+ if (self.calendarContainer === undefined)
2089
+ return;
2090
+ triggerEvent("onPreCalendarPosition");
2091
+ var positionElement = customPositionElement || self._positionElement;
2092
+ var calendarHeight = Array.prototype.reduce.call(self.calendarContainer.children, (function (acc, child) { return acc + child.offsetHeight; }), 0), calendarWidth = self.calendarContainer.offsetWidth, configPos = self.config.position.split(" "), configPosVertical = configPos[0], configPosHorizontal = configPos.length > 1 ? configPos[1] : null, inputBounds = positionElement.getBoundingClientRect(), distanceFromBottom = win.innerHeight - inputBounds.bottom, showOnTop = configPosVertical === "above" ||
2093
+ (configPosVertical !== "below" &&
2094
+ distanceFromBottom < calendarHeight &&
2095
+ inputBounds.top > calendarHeight);
2096
+ var top = win.pageYOffset +
2097
+ inputBounds.top +
2098
+ (!showOnTop ? positionElement.offsetHeight + 2 : -calendarHeight - 2);
2099
+ toggleClass(self.calendarContainer, "arrowTop", !showOnTop);
2100
+ toggleClass(self.calendarContainer, "arrowBottom", showOnTop);
2101
+ if (self.config.inline)
2102
+ return;
2103
+ var left = win.pageXOffset + inputBounds.left;
2104
+ var isCenter = false;
2105
+ var isRight = false;
2106
+ if (configPosHorizontal === "center") {
2107
+ left -= (calendarWidth - inputBounds.width) / 2;
2108
+ isCenter = true;
2109
+ }
2110
+ else if (configPosHorizontal === "right") {
2111
+ left -= calendarWidth - inputBounds.width;
2112
+ isRight = true;
2113
+ }
2114
+ toggleClass(self.calendarContainer, "arrowLeft", !isCenter && !isRight);
2115
+ toggleClass(self.calendarContainer, "arrowCenter", isCenter);
2116
+ toggleClass(self.calendarContainer, "arrowRight", isRight);
2117
+ var right = doc.body.offsetWidth - (win.pageXOffset + inputBounds.right);
2118
+ var rightMost = left + calendarWidth > doc.body.offsetWidth;
2119
+ var centerMost = right + calendarWidth > doc.body.offsetWidth;
2120
+ toggleClass(self.calendarContainer, "rightMost", rightMost);
2121
+ if (self.config.static)
2122
+ return;
2123
+ self.calendarContainer.style.top = top + "px";
2124
+ if (!rightMost) {
2125
+ self.calendarContainer.style.left = left + "px";
2126
+ self.calendarContainer.style.right = "auto";
2127
+ }
2128
+ else if (!centerMost) {
2129
+ self.calendarContainer.style.left = "auto";
2130
+ self.calendarContainer.style.right = right + "px";
2131
+ }
2132
+ else {
2133
+ var sheet = getDocumentStyleSheet();
2134
+ // some testing environments don't have css support
2135
+ if (sheet === undefined)
2136
+ return;
2137
+ var bodyWidth = doc.body.offsetWidth;
2138
+ var centerLeft = Math.max(0, bodyWidth / 2 - calendarWidth / 2);
2139
+ var centerBefore = ".flatpickr-calendar.centerMost:before";
2140
+ var centerAfter = ".flatpickr-calendar.centerMost:after";
2141
+ var centerIndex = sheet.cssRules.length;
2142
+ var centerStyle = "{left:" + inputBounds.left + "px;right:auto;}";
2143
+ toggleClass(self.calendarContainer, "rightMost", false);
2144
+ toggleClass(self.calendarContainer, "centerMost", true);
2145
+ sheet.insertRule(centerBefore + "," + centerAfter + centerStyle, centerIndex);
2146
+ self.calendarContainer.style.left = centerLeft + "px";
2147
+ self.calendarContainer.style.right = "auto";
2148
+ }
2149
+ }
2150
+ function getDocumentStyleSheet() {
2151
+ var editableSheet = null;
2152
+ for (var i = 0; i < doc.styleSheets.length; i++) {
2153
+ var sheet = doc.styleSheets[i];
2154
+ if (!sheet.cssRules)
2155
+ continue;
2156
+ try {
2157
+ sheet.cssRules;
2158
+ }
2159
+ catch (err) {
2160
+ continue;
2161
+ }
2162
+ editableSheet = sheet;
2163
+ break;
2164
+ }
2165
+ return editableSheet != null ? editableSheet : createStyleSheet();
2166
+ }
2167
+ function createStyleSheet() {
2168
+ var style = doc.createElement("style");
2169
+ doc.head.appendChild(style);
2170
+ return style.sheet;
2171
+ }
2172
+ function redraw() {
2173
+ if (self.config.noCalendar || self.isMobile)
2174
+ return;
2175
+ buildMonthSwitch();
2176
+ updateNavigationCurrentMonth();
2177
+ buildDays();
2178
+ }
2179
+ function focusAndClose() {
2180
+ self._input.focus();
2181
+ if (window.navigator.userAgent.indexOf("MSIE") !== -1 ||
2182
+ navigator.msMaxTouchPoints !== undefined) {
2183
+ // hack - bugs in the way IE handles focus keeps the calendar open
2184
+ setTimeout(self.close, 0);
2185
+ }
2186
+ else {
2187
+ self.close();
2188
+ }
2189
+ }
2190
+ function selectDate(e) {
2191
+ e.preventDefault();
2192
+ e.stopPropagation();
2193
+ var isSelectable = function (day) {
2194
+ return day.classList &&
2195
+ day.classList.contains("flatpickr-day") &&
2196
+ !day.classList.contains("flatpickr-disabled") &&
2197
+ !day.classList.contains("notAllowed");
2198
+ };
2199
+ var t = findParent(getEventTarget(e), isSelectable);
2200
+ if (t === undefined)
2201
+ return;
2202
+ var target = t;
2203
+ var selectedDate = (self.latestSelectedDateObj = new Date(target.dateObj.getTime()));
2204
+ var shouldChangeMonth = (selectedDate.getMonth() < self.currentMonth ||
2205
+ selectedDate.getMonth() >
2206
+ self.currentMonth + self.config.showMonths - 1) &&
2207
+ self.config.mode !== "range";
2208
+ self.selectedDateElem = target;
2209
+ if (self.config.mode === "single")
2210
+ self.selectedDates = [selectedDate];
2211
+ else if (self.config.mode === "multiple") {
2212
+ var selectedIndex = isDateSelected(selectedDate);
2213
+ if (selectedIndex)
2214
+ self.selectedDates.splice(parseInt(selectedIndex), 1);
2215
+ else
2216
+ self.selectedDates.push(selectedDate);
2217
+ }
2218
+ else if (self.config.mode === "range") {
2219
+ if (self.selectedDates.length === 2) {
2220
+ self.clear(false, false);
2221
+ }
2222
+ self.latestSelectedDateObj = selectedDate;
2223
+ self.selectedDates.push(selectedDate);
2224
+ // unless selecting same date twice, sort ascendingly
2225
+ if (compareDates(selectedDate, self.selectedDates[0], true) !== 0)
2226
+ self.selectedDates.sort(function (a, b) { return a.getTime() - b.getTime(); });
2227
+ }
2228
+ setHoursFromInputs();
2229
+ if (shouldChangeMonth) {
2230
+ var isNewYear = self.currentYear !== selectedDate.getFullYear();
2231
+ self.currentYear = selectedDate.getFullYear();
2232
+ self.currentMonth = selectedDate.getMonth();
2233
+ if (isNewYear) {
2234
+ triggerEvent("onYearChange");
2235
+ buildMonthSwitch();
2236
+ }
2237
+ triggerEvent("onMonthChange");
2238
+ }
2239
+ updateNavigationCurrentMonth();
2240
+ buildDays();
2241
+ updateValue();
2242
+ // maintain focus
2243
+ if (!shouldChangeMonth &&
2244
+ self.config.mode !== "range" &&
2245
+ self.config.showMonths === 1)
2246
+ focusOnDayElem(target);
2247
+ else if (self.selectedDateElem !== undefined &&
2248
+ self.hourElement === undefined) {
2249
+ self.selectedDateElem && self.selectedDateElem.focus();
2250
+ }
2251
+ if (self.hourElement !== undefined)
2252
+ self.hourElement !== undefined && self.hourElement.focus();
2253
+ if (self.config.closeOnSelect) {
2254
+ var single = self.config.mode === "single" && !self.config.enableTime;
2255
+ var range = self.config.mode === "range" &&
2256
+ self.selectedDates.length === 2 &&
2257
+ !self.config.enableTime;
2258
+ if (single || range) {
2259
+ focusAndClose();
2260
+ }
2261
+ }
2262
+ triggerChange();
2263
+ }
2264
+ var CALLBACKS = {
2265
+ locale: [setupLocale, updateWeekdays],
2266
+ showMonths: [buildMonths, setCalendarWidth, buildWeekdays],
2267
+ minDate: [jumpToDate],
2268
+ maxDate: [jumpToDate],
2269
+ positionElement: [updatePositionElement],
2270
+ clickOpens: [
2271
+ function () {
2272
+ if (self.config.clickOpens === true) {
2273
+ bind(self._input, "focus", self.open);
2274
+ bind(self._input, "click", self.open);
2275
+ }
2276
+ else {
2277
+ self._input.removeEventListener("focus", self.open);
2278
+ self._input.removeEventListener("click", self.open);
2279
+ }
2280
+ },
2281
+ ],
2282
+ };
2283
+ function set(option, value) {
2284
+ if (option !== null && typeof option === "object") {
2285
+ Object.assign(self.config, option);
2286
+ for (var key in option) {
2287
+ if (CALLBACKS[key] !== undefined)
2288
+ CALLBACKS[key].forEach(function (x) { return x(); });
2289
+ }
2290
+ }
2291
+ else {
2292
+ self.config[option] = value;
2293
+ if (CALLBACKS[option] !== undefined)
2294
+ CALLBACKS[option].forEach(function (x) { return x(); });
2295
+ else if (HOOKS.indexOf(option) > -1)
2296
+ self.config[option] = arrayify(value);
2297
+ }
2298
+ self.redraw();
2299
+ updateValue(true);
2300
+ }
2301
+ function setSelectedDate(inputDate, format) {
2302
+ var dates = [];
2303
+ if (inputDate instanceof Array)
2304
+ dates = inputDate.map(function (d) { return self.parseDate(d, format); });
2305
+ else if (inputDate instanceof Date || typeof inputDate === "number")
2306
+ dates = [self.parseDate(inputDate, format)];
2307
+ else if (typeof inputDate === "string") {
2308
+ switch (self.config.mode) {
2309
+ case "single":
2310
+ case "time":
2311
+ dates = [self.parseDate(inputDate, format)];
2312
+ break;
2313
+ case "multiple":
2314
+ dates = inputDate
2315
+ .split(self.config.conjunction)
2316
+ .map(function (date) { return self.parseDate(date, format); });
2317
+ break;
2318
+ case "range":
2319
+ dates = inputDate
2320
+ .split(self.l10n.rangeSeparator)
2321
+ .map(function (date) { return self.parseDate(date, format); });
2322
+ break;
2323
+ }
2324
+ }
2325
+ else
2326
+ self.config.errorHandler(new Error("Invalid date supplied: " + JSON.stringify(inputDate)));
2327
+ self.selectedDates = (self.config.allowInvalidPreload
2328
+ ? dates
2329
+ : dates.filter(function (d) { return d instanceof Date && isEnabled(d, false); }));
2330
+ if (self.config.mode === "range")
2331
+ self.selectedDates.sort(function (a, b) { return a.getTime() - b.getTime(); });
2332
+ }
2333
+ function setDate(date, triggerChange, format) {
2334
+ if (triggerChange === void 0) { triggerChange = false; }
2335
+ if (format === void 0) { format = self.config.dateFormat; }
2336
+ if ((date !== 0 && !date) || (date instanceof Array && date.length === 0))
2337
+ return self.clear(triggerChange);
2338
+ setSelectedDate(date, format);
2339
+ self.latestSelectedDateObj =
2340
+ self.selectedDates[self.selectedDates.length - 1];
2341
+ self.redraw();
2342
+ jumpToDate(undefined, triggerChange);
2343
+ setHoursFromDate();
2344
+ if (self.selectedDates.length === 0) {
2345
+ self.clear(false);
2346
+ }
2347
+ updateValue(triggerChange);
2348
+ if (triggerChange)
2349
+ triggerEvent("onChange");
2350
+ }
2351
+ function parseDateRules(arr) {
2352
+ return arr
2353
+ .slice()
2354
+ .map(function (rule) {
2355
+ if (typeof rule === "string" ||
2356
+ typeof rule === "number" ||
2357
+ rule instanceof Date) {
2358
+ return self.parseDate(rule, undefined, true);
2359
+ }
2360
+ else if (rule &&
2361
+ typeof rule === "object" &&
2362
+ rule.from &&
2363
+ rule.to)
2364
+ return {
2365
+ from: self.parseDate(rule.from, undefined),
2366
+ to: self.parseDate(rule.to, undefined),
2367
+ };
2368
+ return rule;
2369
+ })
2370
+ .filter(function (x) { return x; }); // remove falsy values
2371
+ }
2372
+ function setupDates() {
2373
+ self.selectedDates = [];
2374
+ self.now = self.parseDate(self.config.now) || new Date();
2375
+ // Workaround IE11 setting placeholder as the input's value
2376
+ var preloadedDate = self.config.defaultDate ||
2377
+ ((self.input.nodeName === "INPUT" ||
2378
+ self.input.nodeName === "TEXTAREA") &&
2379
+ self.input.placeholder &&
2380
+ self.input.value === self.input.placeholder
2381
+ ? null
2382
+ : self.input.value);
2383
+ if (preloadedDate)
2384
+ setSelectedDate(preloadedDate, self.config.dateFormat);
2385
+ self._initialDate =
2386
+ self.selectedDates.length > 0
2387
+ ? self.selectedDates[0]
2388
+ : self.config.minDate &&
2389
+ self.config.minDate.getTime() > self.now.getTime()
2390
+ ? self.config.minDate
2391
+ : self.config.maxDate &&
2392
+ self.config.maxDate.getTime() < self.now.getTime()
2393
+ ? self.config.maxDate
2394
+ : self.now;
2395
+ self.currentYear = self._initialDate.getFullYear();
2396
+ self.currentMonth = self._initialDate.getMonth();
2397
+ if (self.selectedDates.length > 0)
2398
+ self.latestSelectedDateObj = self.selectedDates[0];
2399
+ if (self.config.minTime !== undefined)
2400
+ self.config.minTime = self.parseDate(self.config.minTime, "H:i");
2401
+ if (self.config.maxTime !== undefined)
2402
+ self.config.maxTime = self.parseDate(self.config.maxTime, "H:i");
2403
+ self.minDateHasTime =
2404
+ !!self.config.minDate &&
2405
+ (self.config.minDate.getHours() > 0 ||
2406
+ self.config.minDate.getMinutes() > 0 ||
2407
+ self.config.minDate.getSeconds() > 0);
2408
+ self.maxDateHasTime =
2409
+ !!self.config.maxDate &&
2410
+ (self.config.maxDate.getHours() > 0 ||
2411
+ self.config.maxDate.getMinutes() > 0 ||
2412
+ self.config.maxDate.getSeconds() > 0);
2413
+ }
2414
+ function setupInputs() {
2415
+ self.input = getInputElem();
2416
+ /* istanbul ignore next */
2417
+ if (!self.input) {
2418
+ self.config.errorHandler(new Error("Invalid input element specified"));
2419
+ return;
2420
+ }
2421
+ // hack: store previous type to restore it after destroy()
2422
+ self.input._type = self.input.type;
2423
+ self.input.type = "text";
2424
+ self.input.classList.add("flatpickr-input");
2425
+ self._input = self.input;
2426
+ if (self.config.altInput) {
2427
+ // replicate self.element
2428
+ self.altInput = createElement(self.input.nodeName, self.config.altInputClass);
2429
+ self._input = self.altInput;
2430
+ self.altInput.placeholder = self.input.placeholder;
2431
+ self.altInput.disabled = self.input.disabled;
2432
+ self.altInput.required = self.input.required;
2433
+ self.altInput.tabIndex = self.input.tabIndex;
2434
+ self.altInput.type = "text";
2435
+ self.input.setAttribute("type", "hidden");
2436
+ if (!self.config.static && self.input.parentNode)
2437
+ self.input.parentNode.insertBefore(self.altInput, self.input.nextSibling);
2438
+ }
2439
+ if (!self.config.allowInput)
2440
+ self._input.setAttribute("readonly", "readonly");
2441
+ updatePositionElement();
2442
+ }
2443
+ function updatePositionElement() {
2444
+ self._positionElement = self.config.positionElement || self._input;
2445
+ }
2446
+ function setupMobile() {
2447
+ var inputType = self.config.enableTime
2448
+ ? self.config.noCalendar
2449
+ ? "time"
2450
+ : "datetime-local"
2451
+ : "date";
2452
+ self.mobileInput = createElement("input", self.input.className + " flatpickr-mobile");
2453
+ self.mobileInput.tabIndex = 1;
2454
+ self.mobileInput.type = inputType;
2455
+ self.mobileInput.disabled = self.input.disabled;
2456
+ self.mobileInput.required = self.input.required;
2457
+ self.mobileInput.placeholder = self.input.placeholder;
2458
+ self.mobileFormatStr =
2459
+ inputType === "datetime-local"
2460
+ ? "Y-m-d\\TH:i:S"
2461
+ : inputType === "date"
2462
+ ? "Y-m-d"
2463
+ : "H:i:S";
2464
+ if (self.selectedDates.length > 0) {
2465
+ self.mobileInput.defaultValue = self.mobileInput.value = self.formatDate(self.selectedDates[0], self.mobileFormatStr);
2466
+ }
2467
+ if (self.config.minDate)
2468
+ self.mobileInput.min = self.formatDate(self.config.minDate, "Y-m-d");
2469
+ if (self.config.maxDate)
2470
+ self.mobileInput.max = self.formatDate(self.config.maxDate, "Y-m-d");
2471
+ if (self.input.getAttribute("step"))
2472
+ self.mobileInput.step = String(self.input.getAttribute("step"));
2473
+ self.input.type = "hidden";
2474
+ if (self.altInput !== undefined)
2475
+ self.altInput.type = "hidden";
2476
+ try {
2477
+ if (self.input.parentNode)
2478
+ self.input.parentNode.insertBefore(self.mobileInput, self.input.nextSibling);
2479
+ }
2480
+ catch (_a) { }
2481
+ bind(self.mobileInput, "change", function (e) {
2482
+ self.setDate(getEventTarget(e).value, false, self.mobileFormatStr);
2483
+ triggerEvent("onChange");
2484
+ triggerEvent("onClose");
2485
+ });
2486
+ }
2487
+ function toggle(e) {
2488
+ if (self.isOpen === true)
2489
+ return self.close();
2490
+ self.open(e);
2491
+ }
2492
+ function triggerEvent(event, data) {
2493
+ // If the instance has been destroyed already, all hooks have been removed
2494
+ if (self.config === undefined)
2495
+ return;
2496
+ var hooks = self.config[event];
2497
+ if (hooks !== undefined && hooks.length > 0) {
2498
+ for (var i = 0; hooks[i] && i < hooks.length; i++)
2499
+ hooks[i](self.selectedDates, self.input.value, self, data);
2500
+ }
2501
+ if (event === "onChange") {
2502
+ self.input.dispatchEvent(createEvent("change"));
2503
+ // many front-end frameworks bind to the input event
2504
+ self.input.dispatchEvent(createEvent("input"));
2505
+ }
2506
+ }
2507
+ function createEvent(name) {
2508
+ var e = doc.createEvent("Event");
2509
+ e.initEvent(name, true, true);
2510
+ return e;
2511
+ }
2512
+ function isDateSelected(date) {
2513
+ for (var i = 0; i < self.selectedDates.length; i++) {
2514
+ var selectedDate = self.selectedDates[i];
2515
+ if (selectedDate instanceof Date &&
2516
+ compareDates(selectedDate, date) === 0)
2517
+ return "" + i;
2518
+ }
2519
+ return false;
2520
+ }
2521
+ function isDateInRange(date) {
2522
+ if (self.config.mode !== "range" || self.selectedDates.length < 2)
2523
+ return false;
2524
+ return (compareDates(date, self.selectedDates[0]) >= 0 &&
2525
+ compareDates(date, self.selectedDates[1]) <= 0);
2526
+ }
2527
+ function updateNavigationCurrentMonth() {
2528
+ if (self.config.noCalendar || self.isMobile || !self.monthNav)
2529
+ return;
2530
+ self.yearElements.forEach(function (yearElement, i) {
2531
+ var d = new Date(self.currentYear, self.currentMonth, 1);
2532
+ d.setMonth(self.currentMonth + i);
2533
+ if (self.config.showMonths > 1 ||
2534
+ self.config.monthSelectorType === "static") {
2535
+ self.monthElements[i].textContent =
2536
+ monthToStr(d.getMonth(), self.config.shorthandCurrentMonth, self.l10n) + " ";
2537
+ }
2538
+ else {
2539
+ self.monthsDropdownContainer.value = d.getMonth().toString();
2540
+ }
2541
+ yearElement.value = d.getFullYear().toString();
2542
+ });
2543
+ self._hidePrevMonthArrow =
2544
+ self.config.minDate !== undefined &&
2545
+ (self.currentYear === self.config.minDate.getFullYear()
2546
+ ? self.currentMonth <= self.config.minDate.getMonth()
2547
+ : self.currentYear < self.config.minDate.getFullYear());
2548
+ self._hideNextMonthArrow =
2549
+ self.config.maxDate !== undefined &&
2550
+ (self.currentYear === self.config.maxDate.getFullYear()
2551
+ ? self.currentMonth + 1 > self.config.maxDate.getMonth()
2552
+ : self.currentYear > self.config.maxDate.getFullYear());
2553
+ }
2554
+ function getDateStr(specificFormat) {
2555
+ var format = specificFormat ||
2556
+ (self.config.altInput ? self.config.altFormat : self.config.dateFormat);
2557
+ return self.selectedDates
2558
+ .map(function (dObj) { return self.formatDate(dObj, format); })
2559
+ .filter(function (d, i, arr) {
2560
+ return self.config.mode !== "range" ||
2561
+ self.config.enableTime ||
2562
+ arr.indexOf(d) === i;
2563
+ })
2564
+ .join(self.config.mode !== "range"
2565
+ ? self.config.conjunction
2566
+ : self.l10n.rangeSeparator);
2567
+ }
2568
+ /**
2569
+ * Updates the values of inputs associated with the calendar
2570
+ */
2571
+ function updateValue(triggerChange) {
2572
+ if (triggerChange === void 0) { triggerChange = true; }
2573
+ if (self.mobileInput !== undefined && self.mobileFormatStr) {
2574
+ self.mobileInput.value =
2575
+ self.latestSelectedDateObj !== undefined
2576
+ ? self.formatDate(self.latestSelectedDateObj, self.mobileFormatStr)
2577
+ : "";
2578
+ }
2579
+ self.input.value = getDateStr(self.config.dateFormat);
2580
+ if (self.altInput !== undefined) {
2581
+ self.altInput.value = getDateStr(self.config.altFormat);
2582
+ }
2583
+ if (triggerChange !== false)
2584
+ triggerEvent("onValueUpdate");
2585
+ }
2586
+ function onMonthNavClick(e) {
2587
+ var eventTarget = getEventTarget(e);
2588
+ var isPrevMonth = self.prevMonthNav.contains(eventTarget);
2589
+ var isNextMonth = self.nextMonthNav.contains(eventTarget);
2590
+ if (isPrevMonth || isNextMonth) {
2591
+ changeMonth(isPrevMonth ? -1 : 1);
2592
+ }
2593
+ else if (self.yearElements.indexOf(eventTarget) >= 0) {
2594
+ eventTarget.select();
2595
+ }
2596
+ else if (eventTarget.classList.contains("arrowUp")) {
2597
+ self.changeYear(self.currentYear + 1);
2598
+ }
2599
+ else if (eventTarget.classList.contains("arrowDown")) {
2600
+ self.changeYear(self.currentYear - 1);
2601
+ }
2602
+ }
2603
+ function timeWrapper(e) {
2604
+ e.preventDefault();
2605
+ var isKeyDown = e.type === "keydown", eventTarget = getEventTarget(e), input = eventTarget;
2606
+ if (self.amPM !== undefined && eventTarget === self.amPM) {
2607
+ self.amPM.textContent =
2608
+ self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])];
2609
+ }
2610
+ var min = parseFloat(input.getAttribute("min")), max = parseFloat(input.getAttribute("max")), step = parseFloat(input.getAttribute("step")), curValue = parseInt(input.value, 10), delta = e.delta ||
2611
+ (isKeyDown ? (e.which === 38 ? 1 : -1) : 0);
2612
+ var newValue = curValue + step * delta;
2613
+ if (typeof input.value !== "undefined" && input.value.length === 2) {
2614
+ var isHourElem = input === self.hourElement, isMinuteElem = input === self.minuteElement;
2615
+ if (newValue < min) {
2616
+ newValue =
2617
+ max +
2618
+ newValue +
2619
+ int(!isHourElem) +
2620
+ (int(isHourElem) && int(!self.amPM));
2621
+ if (isMinuteElem)
2622
+ incrementNumInput(undefined, -1, self.hourElement);
2623
+ }
2624
+ else if (newValue > max) {
2625
+ newValue =
2626
+ input === self.hourElement ? newValue - max - int(!self.amPM) : min;
2627
+ if (isMinuteElem)
2628
+ incrementNumInput(undefined, 1, self.hourElement);
2629
+ }
2630
+ if (self.amPM &&
2631
+ isHourElem &&
2632
+ (step === 1
2633
+ ? newValue + curValue === 23
2634
+ : Math.abs(newValue - curValue) > step)) {
2635
+ self.amPM.textContent =
2636
+ self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])];
2637
+ }
2638
+ input.value = pad(newValue);
2639
+ }
2640
+ }
2641
+ init();
2642
+ return self;
2643
+ }
2644
+ /* istanbul ignore next */
2645
+ function _flatpickr(nodeList, config) {
2646
+ // static list
2647
+ var nodes = Array.prototype.slice
2648
+ .call(nodeList)
2649
+ // `instanceof HTMLElement` is false for elements from another window
2650
+ .filter(function (x) { return x.nodeType === Node.ELEMENT_NODE; });
2651
+ var instances = [];
2652
+ for (var i = 0; i < nodes.length; i++) {
2653
+ var node = nodes[i];
2654
+ try {
2655
+ if (node.getAttribute("data-fp-omit") !== null)
2656
+ continue;
2657
+ if (node._flatpickr !== undefined) {
2658
+ node._flatpickr.destroy();
2659
+ node._flatpickr = undefined;
2660
+ }
2661
+ node._flatpickr = FlatpickrInstance(node, config || {});
2662
+ instances.push(node._flatpickr);
2663
+ }
2664
+ catch (e) {
2665
+ console.error(e);
2666
+ }
2667
+ }
2668
+ return instances.length === 1 ? instances[0] : instances;
2669
+ }
2670
+ /* istanbul ignore next */
2671
+ if (typeof HTMLElement !== "undefined" &&
2672
+ typeof HTMLCollection !== "undefined" &&
2673
+ typeof NodeList !== "undefined") {
2674
+ // browser env
2675
+ HTMLCollection.prototype.flatpickr = NodeList.prototype.flatpickr = function (config) {
2676
+ return _flatpickr(this, config);
2677
+ };
2678
+ HTMLElement.prototype.flatpickr = function (config) {
2679
+ return _flatpickr([this], config);
2680
+ };
2681
+ }
2682
+ /* istanbul ignore next */
2683
+ var flatpickr = function (selector, config) {
2684
+ if (typeof selector === "string") {
2685
+ return _flatpickr(window.document.querySelectorAll(selector), config);
2686
+ }
2687
+ else if (isNode(selector)) {
2688
+ return _flatpickr([selector], config);
2689
+ }
2690
+ else {
2691
+ return _flatpickr(selector, config);
2692
+ }
2693
+ };
2694
+ /* istanbul ignore next */
2695
+ flatpickr.defaultConfig = {};
2696
+ flatpickr.l10ns = {
2697
+ en: __assign({}, english),
2698
+ default: __assign({}, english),
2699
+ };
2700
+ flatpickr.localize = function (l10n) {
2701
+ flatpickr.l10ns.default = __assign(__assign({}, flatpickr.l10ns.default), l10n);
2702
+ };
2703
+ flatpickr.setDefaults = function (config) {
2704
+ flatpickr.defaultConfig = __assign(__assign({}, flatpickr.defaultConfig), config);
2705
+ };
2706
+ flatpickr.parseDate = createDateParser({});
2707
+ flatpickr.formatDate = createDateFormatter({});
2708
+ flatpickr.compareDates = compareDates;
2709
+ /* istanbul ignore next */
2710
+ if (typeof jQuery !== "undefined" && typeof jQuery.fn !== "undefined") {
2711
+ jQuery.fn.flatpickr = function (config) {
2712
+ return _flatpickr(this, config);
2713
+ };
2714
+ }
2715
+ Date.prototype.fp_incr = function (days) {
2716
+ return new Date(this.getFullYear(), this.getMonth(), this.getDate() + (typeof days === "string" ? parseInt(days, 10) : days));
2717
+ };
2718
+ if (typeof window !== "undefined") {
2719
+ window.flatpickr = flatpickr;
2720
+ }
2721
+
2722
+ return flatpickr;
2723
+
2724
+ })));