PageSourceSearch

https://rockzoneamericas.com/app/cms/assets/core/anomaly/text-fiel…/inputmask.date.extensions.js?v=1688660069

js rockzoneamericas.com collected 2026-10-09 01:28:20 UTC 24,424 bytes, 480 lines download raw bytes

vendor: 24,424 bytes, lines 1-480
1/*!
2* inputmask.date.extensions.js
3* https://github.com/RobinHerbots/Inputmask
4* Copyright (c) 2010 - 2017 Robin Herbots
5* Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)
6* Version: 3.3.11
7*/
8
9!function(factory) {
10    "function" == typeof define && define.amd ? define([ "./dependencyLibs/inputmask.dependencyLib", "./inputmask" ], factory) : "object" == typeof exports ? module.exports = factory(require("./dependencyLibs/inputmask.dependencyLib"), require("./inputmask")) : factory(window.dependencyLib || jQuery, window.Inputmask);
11}(function($, Inputmask) {
12    function isLeapYear(year) {
13        return isNaN(year) || 29 === new Date(year, 2, 0).getDate();
14    }
15    return Inputmask.extendAliases({
16        "dd/mm/yyyy": {
17            mask: "1/2/y",
18            placeholder: "dd/mm/yyyy",
19            regex: {
20                val1pre: new RegExp("[0-3]"),
21                val1: new RegExp("0[1-9]|[12][0-9]|3[01]"),
22                val2pre: function(separator) {
23                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
24                    return new RegExp("((0[1-9]|[12][0-9]|3[01])" + escapedSeparator + "[01])");
25                },
26                val2: function(separator) {
27                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
28                    return new RegExp("((0[1-9]|[12][0-9])" + escapedSeparator + "(0[1-9]|1[012]))|(30" + escapedSeparator + "(0[13-9]|1[012]))|(31" + escapedSeparator + "(0[13578]|1[02]))");
29                }
30            },
31            leapday: "29/02/",
32            separator: "/",
33            yearrange: {
34                minyear: 1900,
35                maxyear: 2099
36            },
37            isInYearRange: function(chrs, minyear, maxyear) {
38                if (isNaN(chrs)) return !1;
39                var enteredyear = parseInt(chrs.concat(minyear.toString().slice(chrs.length))), enteredyear2 = parseInt(chrs.concat(maxyear.toString().slice(chrs.length)));
40                return !isNaN(enteredyear) && (minyear <= enteredyear && enteredyear <= maxyear) || !isNaN(enteredyear2) && (minyear <= enteredyear2 && enteredyear2 <= maxyear);
41            },
42            determinebaseyear: function(minyear, maxyear, hint) {
43                var currentyear = new Date().getFullYear();
44                if (minyear > currentyear) return minyear;
45                if (maxyear < currentyear) {
46                    for (var maxYearPrefix = maxyear.toString().slice(0, 2), maxYearPostfix = maxyear.toString().slice(2, 4); maxyear < maxYearPrefix + hint; ) maxYearPrefix--;
47                    var maxxYear = maxYearPrefix + maxYearPostfix;
48                    return minyear > maxxYear ? minyear : maxxYear;
49                }
50                if (minyear <= currentyear && currentyear <= maxyear) {
51                    for (var currentYearPrefix = currentyear.toString().slice(0, 2); maxyear < currentYearPrefix + hint; ) currentYearPrefix--;
52                    var currentYearAndHint = currentYearPrefix + hint;
53                    return currentYearAndHint < minyear ? minyear : currentYearAndHint;
54                }
55                return currentyear;
56            },
57            onKeyDown: function(e, buffer, caretPos, opts) {
58                var $input = $(this);
59                if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
60                    var today = new Date();
61                    $input.val(today.getDate().toString() + (today.getMonth() + 1).toString() + today.getFullYear().toString()), 
62                    $input.trigger("setvalue");
63                }
64            },
65            getFrontValue: function(mask, buffer, opts) {
66                for (var start = 0, length = 0, i = 0; i < mask.length && "2" !== mask.charAt(i); i++) {
67                    var definition = opts.definitions[mask.charAt(i)];
68                    definition ? (start += length, length = definition.cardinality) : length++;
69                }
70                return buffer.join("").substr(start, length);
71            },
72            postValidation: function(buffer, currentResult, opts) {
73                var dayMonthValue, year, bufferStr = buffer.join("");
74                return 0 === opts.mask.indexOf("y") ? (year = bufferStr.substr(0, 4), dayMonthValue = bufferStr.substring(4, 10)) : (year = bufferStr.substring(6, 10), 
75                dayMonthValue = bufferStr.substr(0, 6)), currentResult && (dayMonthValue !== opts.leapday || isLeapYear(year));
76            },
77            definitions: {
78                "1": {
79                    validator: function(chrs, maskset, pos, strict, opts) {
80                        var isValid = opts.regex.val1.test(chrs);
81                        return strict || isValid || chrs.charAt(1) !== opts.separator && -1 === "-./".indexOf(chrs.charAt(1)) || !(isValid = opts.regex.val1.test("0" + chrs.charAt(0))) ? isValid : (maskset.buffer[pos - 1] = "0", 
82                        {
83                            refreshFromBuffer: {
84                                start: pos - 1,
85                                end: pos
86                            },
87                            pos: pos,
88                            c: chrs.charAt(0)
89                        });
90                    },
91                    cardinality: 2,
92                    prevalidator: [ {
93                        validator: function(chrs, maskset, pos, strict, opts) {
94                            var pchrs = chrs;
95                            isNaN(maskset.buffer[pos + 1]) || (pchrs += maskset.buffer[pos + 1]);
96                            var isValid = 1 === pchrs.length ? opts.regex.val1pre.test(pchrs) : opts.regex.val1.test(pchrs);
97                            if (isValid && maskset.validPositions[pos] && (opts.regex.val2(opts.separator).test(chrs + maskset.validPositions[pos].input) || (maskset.validPositions[pos].input = "0" === chrs ? "1" : "0")), 
98                            !strict && !isValid) {
99                                if (isValid = opts.regex.val1.test(chrs + "0")) return maskset.buffer[pos] = chrs, 
100                                maskset.buffer[++pos] = "0", {
101                                    pos: pos,
102                                    c: "0"
103                                };
104                                if (isValid = opts.regex.val1.test("0" + chrs)) return maskset.buffer[pos] = "0", 
105                                pos++, {
106                                    pos: pos
107                                };
108                            }
109                            return isValid;
110                        },
111                        cardinality: 1
112                    } ]
113                },
114                "2": {
115                    validator: function(chrs, maskset, pos, strict, opts) {
116                        var frontValue = opts.getFrontValue(maskset.mask, maskset.buffer, opts);
117                        -1 !== frontValue.indexOf(opts.placeholder[0]) && (frontValue = "01" + opts.separator);
118                        var isValid = opts.regex.val2(opts.separator).test(frontValue + chrs);
119                        return strict || isValid || chrs.charAt(1) !== opts.separator && -1 === "-./".indexOf(chrs.charAt(1)) || !(isValid = opts.regex.val2(opts.separator).test(frontValue + "0" + chrs.charAt(0))) ? isValid : (maskset.buffer[pos - 1] = "0", 
120                        {
121                            refreshFromBuffer: {
122                                start: pos - 1,
123                                end: pos
124                            },
125                            pos: pos,
126                            c: chrs.charAt(0)
127                        });
128                    },
129                    cardinality: 2,
130                    prevalidator: [ {
131                        validator: function(chrs, maskset, pos, strict, opts) {
132                            isNaN(maskset.buffer[pos + 1]) || (chrs += maskset.buffer[pos + 1]);
133                            var frontValue = opts.getFrontValue(maskset.mask, maskset.buffer, opts);
134                            -1 !== frontValue.indexOf(opts.placeholder[0]) && (frontValue = "01" + opts.separator);
135                            var isValid = 1 === chrs.length ? opts.regex.val2pre(opts.separator).test(frontValue + chrs) : opts.regex.val2(opts.separator).test(frontValue + chrs);
136                            return isValid && maskset.validPositions[pos] && (opts.regex.val2(opts.separator).test(chrs + maskset.validPositions[pos].input) || (maskset.validPositions[pos].input = "0" === chrs ? "1" : "0")), 
137                            strict || isValid || !(isValid = opts.regex.val2(opts.separator).test(frontValue + "0" + chrs)) ? isValid : (maskset.buffer[pos] = "0", 
138                            pos++, {
139                                pos: pos
140                            });
141                        },
142                        cardinality: 1
143                    } ]
144                },
145                y: {
146                    validator: function(chrs, maskset, pos, strict, opts) {
147                        return opts.isInYearRange(chrs, opts.yearrange.minyear, opts.yearrange.maxyear);
148                    },
149                    cardinality: 4,
150                    prevalidator: [ {
151                        validator: function(chrs, maskset, pos, strict, opts) {
152                            var isValid = opts.isInYearRange(chrs, opts.yearrange.minyear, opts.yearrange.maxyear);
153                            if (!strict && !isValid) {
154                                var yearPrefix = opts.determinebaseyear(opts.yearrange.minyear, opts.yearrange.maxyear, chrs + "0").toString().slice(0, 1);
155                                if (isValid = opts.isInYearRange(yearPrefix + chrs, opts.yearrange.minyear, opts.yearrange.maxyear)) return maskset.buffer[pos++] = yearPrefix.charAt(0), 
156                                {
157                                    pos: pos
158                                };
159                                if (yearPrefix = opts.determinebaseyear(opts.yearrange.minyear, opts.yearrange.maxyear, chrs + "0").toString().slice(0, 2), 
160                                isValid = opts.isInYearRange(yearPrefix + chrs, opts.yearrange.minyear, opts.yearrange.maxyear)) return maskset.buffer[pos++] = yearPrefix.charAt(0), 
161                                maskset.buffer[pos++] = yearPrefix.charAt(1), {
162                                    pos: pos
163                                };
164                            }
165                            return isValid;
166                        },
167                        cardinality: 1
168                    }, {
169                        validator: function(chrs, maskset, pos, strict, opts) {
170                            var isValid = opts.isInYearRange(chrs, opts.yearrange.minyear, opts.yearrange.maxyear);
171                            if (!strict && !isValid) {
172                                var yearPrefix = opts.determinebaseyear(opts.yearrange.minyear, opts.yearrange.maxyear, chrs).toString().slice(0, 2);
173                                if (isValid = opts.isInYearRange(chrs[0] + yearPrefix[1] + chrs[1], opts.yearrange.minyear, opts.yearrange.maxyear)) return maskset.buffer[pos++] = yearPrefix.charAt(1), 
174                                {
175                                    pos: pos
176                                };
177                                if (yearPrefix = opts.determinebaseyear(opts.yearrange.minyear, opts.yearrange.maxyear, chrs).toString().slice(0, 2), 
178                                isValid = opts.isInYearRange(yearPrefix + chrs, opts.yearrange.minyear, opts.yearrange.maxyear)) return maskset.buffer[pos - 1] = yearPrefix.charAt(0), 
179                                maskset.buffer[pos++] = yearPrefix.charAt(1), maskset.buffer[pos++] = chrs.charAt(0), 
180                                {
181                                    refreshFromBuffer: {
182                                        start: pos - 3,
183                                        end: pos
184                                    },
185                                    pos: pos
186                                };
187                            }
188                            return isValid;
189                        },
190                        cardinality: 2
191                    }, {
192                        validator: function(chrs, maskset, pos, strict, opts) {
193                            return opts.isInYearRange(chrs, opts.yearrange.minyear, opts.yearrange.maxyear);
194                        },
195                        cardinality: 3
196                    } ]
197                }
198            },
199            insertMode: !1,
200            autoUnmask: !1
201        },
202        "mm/dd/yyyy": {
203            placeholder: "mm/dd/yyyy",
204            alias: "dd/mm/yyyy",
205            regex: {
206                val2pre: function(separator) {
207                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
208                    return new RegExp("((0[13-9]|1[012])" + escapedSeparator + "[0-3])|(02" + escapedSeparator + "[0-2])");
209                },
210                val2: function(separator) {
211                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
212                    return new RegExp("((0[1-9]|1[012])" + escapedSeparator + "(0[1-9]|[12][0-9]))|((0[13-9]|1[012])" + escapedSeparator + "30)|((0[13578]|1[02])" + escapedSeparator + "31)");
213                },
214                val1pre: new RegExp("[01]"),
215                val1: new RegExp("0[1-9]|1[012]")
216            },
217            leapday: "02/29/",
218            onKeyDown: function(e, buffer, caretPos, opts) {
219                var $input = $(this);
220                if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
221                    var today = new Date();
222                    $input.val((today.getMonth() + 1).toString() + today.getDate().toString() + today.getFullYear().toString()), 
223                    $input.trigger("setvalue");
224                }
225            }
226        },
227        "yyyy/mm/dd": {
228            mask: "y/1/2",
229            placeholder: "yyyy/mm/dd",
230            alias: "mm/dd/yyyy",
231            leapday: "/02/29",
232            onKeyDown: function(e, buffer, caretPos, opts) {
233                var $input = $(this);
234                if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
235                    var today = new Date();
236                    $input.val(today.getFullYear().toString() + (today.getMonth() + 1).toString() + today.getDate().toString()), 
237                    $input.trigger("setvalue");
238                }
239            }
240        },
241        "dd.mm.yyyy": {
242            mask: "1.2.y",
243            placeholder: "dd.mm.yyyy",
244            leapday: "29.02.",
245            separator: ".",
246            alias: "dd/mm/yyyy"
247        },
248        "dd-mm-yyyy": {
249            mask: "1-2-y",
250            placeholder: "dd-mm-yyyy",
251            leapday: "29-02-",
252            separator: "-",
253            alias: "dd/mm/yyyy"
254        },
255        "mm.dd.yyyy": {
256            mask: "1.2.y",
257            placeholder: "mm.dd.yyyy",
258            leapday: "02.29.",
259            separator: ".",
260            alias: "mm/dd/yyyy"
261        },
262        "mm-dd-yyyy": {
263            mask: "1-2-y",
264            placeholder: "mm-dd-yyyy",
265            leapday: "02-29-",
266            separator: "-",
267            alias: "mm/dd/yyyy"
268        },
269        "yyyy.mm.dd": {
270            mask: "y.1.2",
271            placeholder: "yyyy.mm.dd",
272            leapday: ".02.29",
273            separator: ".",
274            alias: "yyyy/mm/dd"
275        },
276        "yyyy-mm-dd": {
277            mask: "y-1-2",
278            placeholder: "yyyy-mm-dd",
279            leapday: "-02-29",
280            separator: "-",
281            alias: "yyyy/mm/dd"
282        },
283        datetime: {
284            mask: "1/2/y h:s",
285            placeholder: "dd/mm/yyyy hh:mm",
286            alias: "dd/mm/yyyy",
287            regex: {
288                hrspre: new RegExp("[012]"),
289                hrs24: new RegExp("2[0-4]|1[3-9]"),
290                hrs: new RegExp("[01][0-9]|2[0-4]"),
291                ampm: new RegExp("^[a|p|A|P][m|M]"),
292                mspre: new RegExp("[0-5]"),
293                ms: new RegExp("[0-5][0-9]")
294            },
295            timeseparator: ":",
296            hourFormat: "24",
297            definitions: {
298                h: {
299                    validator: function(chrs, maskset, pos, strict, opts) {
300                        if ("24" === opts.hourFormat && 24 === parseInt(chrs, 10)) return maskset.buffer[pos - 1] = "0", 
301                        maskset.buffer[pos] = "0", {
302                            refreshFromBuffer: {
303                                start: pos - 1,
304                                end: pos
305                            },
306                            c: "0"
307                        };
308                        var isValid = opts.regex.hrs.test(chrs);
309                        if (!strict && !isValid && (chrs.charAt(1) === opts.timeseparator || -1 !== "-.:".indexOf(chrs.charAt(1))) && (isValid = opts.regex.hrs.test("0" + chrs.charAt(0)))) return maskset.buffer[pos - 1] = "0", 
310                        maskset.buffer[pos] = chrs.charAt(0), pos++, {
311                            refreshFromBuffer: {
312                                start: pos - 2,
313                                end: pos
314                            },
315                            pos: pos,
316                            c: opts.timeseparator
317                        };
318                        if (isValid && "24" !== opts.hourFormat && opts.regex.hrs24.test(chrs)) {
319                            var tmp = parseInt(chrs, 10);
320                            return 24 === tmp ? (maskset.buffer[pos + 5] = "a", maskset.buffer[pos + 6] = "m") : (maskset.buffer[pos + 5] = "p", 
321                            maskset.buffer[pos + 6] = "m"), (tmp -= 12) < 10 ? (maskset.buffer[pos] = tmp.toString(), 
322                            maskset.buffer[pos - 1] = "0") : (maskset.buffer[pos] = tmp.toString().charAt(1), 
323                            maskset.buffer[pos - 1] = tmp.toString().charAt(0)), {
324                                refreshFromBuffer: {
325                                    start: pos - 1,
326                                    end: pos + 6
327                                },
328                                c: maskset.buffer[pos]
329                            };
330                        }
331                        return isValid;
332                    },
333                    cardinality: 2,
334                    prevalidator: [ {
335                        validator: function(chrs, maskset, pos, strict, opts) {
336                            var isValid = opts.regex.hrspre.test(chrs);
337                            return strict || isValid || !(isValid = opts.regex.hrs.test("0" + chrs)) ? isValid : (maskset.buffer[pos] = "0", 
338                            pos++, {
339                                pos: pos
340                            });
341                        },
342                        cardinality: 1
343                    } ]
344                },
345                s: {
346                    validator: "[0-5][0-9]",
347                    cardinality: 2,
348                    prevalidator: [ {
349                        validator: function(chrs, maskset, pos, strict, opts) {
350                            var isValid = opts.regex.mspre.test(chrs);
351                            return strict || isValid || !(isValid = opts.regex.ms.test("0" + chrs)) ? isValid : (maskset.buffer[pos] = "0", 
352                            pos++, {
353                                pos: pos
354                            });
355                        },
356                        cardinality: 1
357                    } ]
358                },
359                t: {
360                    validator: function(chrs, maskset, pos, strict, opts) {
361                        return opts.regex.ampm.test(chrs + "m");
362                    },
363                    casing: "lower",
364                    cardinality: 1
365                }
366            },
367            insertMode: !1,
368            autoUnmask: !1
369        },
370        datetime12: {
371            mask: "1/2/y h:s t\\m",
372            placeholder: "dd/mm/yyyy hh:mm xm",
373            alias: "datetime",
374            hourFormat: "12"
375        },
376        "mm/dd/yyyy hh:mm xm": {
377            mask: "1/2/y h:s t\\m",
378            placeholder: "mm/dd/yyyy hh:mm xm",
379            alias: "datetime12",
380            regex: {
381                val2pre: function(separator) {
382                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
383                    return new RegExp("((0[13-9]|1[012])" + escapedSeparator + "[0-3])|(02" + escapedSeparator + "[0-2])");
384                },
385                val2: function(separator) {
386                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
387                    return new RegExp("((0[1-9]|1[012])" + escapedSeparator + "(0[1-9]|[12][0-9]))|((0[13-9]|1[012])" + escapedSeparator + "30)|((0[13578]|1[02])" + escapedSeparator + "31)");
388                },
389                val1pre: new RegExp("[01]"),
390                val1: new RegExp("0[1-9]|1[012]")
391            },
392            leapday: "02/29/",
393            onKeyDown: function(e, buffer, caretPos, opts) {
394                var $input = $(this);
395                if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
396                    var today = new Date();
397                    $input.val((today.getMonth() + 1).toString() + today.getDate().toString() + today.getFullYear().toString()), 
398                    $input.trigger("setvalue");
399                }
400            }
401        },
402        "hh:mm t": {
403            mask: "h:s t\\m",
404            placeholder: "hh:mm xm",
405            alias: "datetime",
406            hourFormat: "12"
407        },
408        "h:s t": {
409            mask: "h:s t\\m",
410            placeholder: "hh:mm xm",
411            alias: "datetime",
412            hourFormat: "12"
413        },
414        "hh:mm:ss": {
415            mask: "h:s:s",
416            placeholder: "hh:mm:ss",
417            alias: "datetime",
418            autoUnmask: !1
419        },
420        "hh:mm": {
421            mask: "h:s",
422            placeholder: "hh:mm",
423            alias: "datetime",
424            autoUnmask: !1
425        },
426        date: {
427            alias: "dd/mm/yyyy"
428        },
429        "mm/yyyy": {
430            mask: "1/y",
431            placeholder: "mm/yyyy",
432            leapday: "donotuse",
433            separator: "/",
434            alias: "mm/dd/yyyy"
435        },
436        shamsi: {
437            regex: {
438                val2pre: function(separator) {
439                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
440                    return new RegExp("((0[1-9]|1[012])" + escapedSeparator + "[0-3])");
441                },
442                val2: function(separator) {
443                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
444                    return new RegExp("((0[1-9]|1[012])" + escapedSeparator + "(0[1-9]|[12][0-9]))|((0[1-9]|1[012])" + escapedSeparator + "30)|((0[1-6])" + escapedSeparator + "31)");
445                },
446                val1pre: new RegExp("[01]"),
447                val1: new RegExp("0[1-9]|1[012]")
448            },
449            yearrange: {
450                minyear: 1300,
451                maxyear: 1499
452            },
453            mask: "y/1/2",
454            leapday: "/12/30",
455            placeholder: "yyyy/mm/dd",
456            alias: "mm/dd/yyyy",
457            clearIncomplete: !0
458        },
459        "yyyy-mm-dd hh:mm:ss": {
460            mask: "y-1-2 h:s:s",
461            placeholder: "yyyy-mm-dd hh:mm:ss",
462            alias: "datetime",
463            separator: "-",
464            leapday: "-02-29",
465            regex: {
466                val2pre: function(separator) {
467                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
468                    return new RegExp("((0[13-9]|1[012])" + escapedSeparator + "[0-3])|(02" + escapedSeparator + "[0-2])");
469                },
470                val2: function(separator) {
471                    var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
472                    return new RegExp("((0[1-9]|1[012])" + escapedSeparator + "(0[1-9]|[12][0-9]))|((0[13-9]|1[012])" + escapedSeparator + "30)|((0[13578]|1[02])" + escapedSeparator + "31)");
473                },
474                val1pre: new RegExp("[01]"),
475                val1: new RegExp("0[1-9]|1[012]")
476            },
477            onKeyDown: function(e, buffer, caretPos, opts) {}
478        }
479    }), Inputmask;
480});;;

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.