/*!
 * inputmask.date.extensions.js
 * https://github.com/RobinHerbots/Inputmask
 * Copyright (c) 2010 - 2017 Robin Herbots
 * Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)
 * Version: 3.3.11
 */

!(function (factory) {
  "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);
})(function ($, Inputmask) {
  function isLeapYear(year) {
    return isNaN(year) || 29 === new Date(year, 2, 0).getDate();
  }
  return (
    Inputmask.extendAliases({
      "dd/mm/yyyy": {
        mask: "1/2/y",
        placeholder: "dd/mm/yyyy",
        regex: {
          val1pre: new RegExp("[0-3]"),
          val1: new RegExp("0[1-9]|[12][0-9]|3[01]"),
          val2pre: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            return new RegExp(
              "((0[1-9]|[12][0-9]|3[01])" + escapedSeparator + "[01])"
            );
          },
          val2: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            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]))"
            );
          },
        },
        leapday: "29/02/",
        separator: "/",
        yearrange: {
          minyear: 1900,
          maxyear: 2099,
        },
        isInYearRange: function (chrs, minyear, maxyear) {
          if (isNaN(chrs)) return !1;
          var enteredyear = parseInt(
              chrs.concat(minyear.toString().slice(chrs.length))
            ),
            enteredyear2 = parseInt(
              chrs.concat(maxyear.toString().slice(chrs.length))
            );
          return (
            (!isNaN(enteredyear) &&
              minyear <= enteredyear &&
              enteredyear <= maxyear) ||
            (!isNaN(enteredyear2) &&
              minyear <= enteredyear2 &&
              enteredyear2 <= maxyear)
          );
        },
        determinebaseyear: function (minyear, maxyear, hint) {
          var currentyear = new Date().getFullYear();
          if (minyear > currentyear) return minyear;
          if (maxyear < currentyear) {
            for (
              var maxYearPrefix = maxyear.toString().slice(0, 2),
                maxYearPostfix = maxyear.toString().slice(2, 4);
              maxyear < maxYearPrefix + hint;

            )
              maxYearPrefix--;
            var maxxYear = maxYearPrefix + maxYearPostfix;
            return minyear > maxxYear ? minyear : maxxYear;
          }
          if (minyear <= currentyear && currentyear <= maxyear) {
            for (
              var currentYearPrefix = currentyear.toString().slice(0, 2);
              maxyear < currentYearPrefix + hint;

            )
              currentYearPrefix--;
            var currentYearAndHint = currentYearPrefix + hint;
            return currentYearAndHint < minyear ? minyear : currentYearAndHint;
          }
          return currentyear;
        },
        onKeyDown: function (e, buffer, caretPos, opts) {
          var $input = $(this);
          if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
            var today = new Date();
            $input.val(
              today.getDate().toString() +
                (today.getMonth() + 1).toString() +
                today.getFullYear().toString()
            ),
              $input.trigger("setvalue");
          }
        },
        getFrontValue: function (mask, buffer, opts) {
          for (
            var start = 0, length = 0, i = 0;
            i < mask.length && "2" !== mask.charAt(i);
            i++
          ) {
            var definition = opts.definitions[mask.charAt(i)];
            definition
              ? ((start += length), (length = definition.cardinality))
              : length++;
          }
          return buffer.join("").substr(start, length);
        },
        postValidation: function (buffer, currentResult, opts) {
          var dayMonthValue,
            year,
            bufferStr = buffer.join("");
          return (
            0 === opts.mask.indexOf("y")
              ? ((year = bufferStr.substr(0, 4)),
                (dayMonthValue = bufferStr.substring(4, 10)))
              : ((year = bufferStr.substring(6, 10)),
                (dayMonthValue = bufferStr.substr(0, 6))),
            currentResult &&
              (dayMonthValue !== opts.leapday || isLeapYear(year))
          );
        },
        definitions: {
          1: {
            validator: function (chrs, maskset, pos, strict, opts) {
              var isValid = opts.regex.val1.test(chrs);
              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"),
                  {
                    refreshFromBuffer: {
                      start: pos - 1,
                      end: pos,
                    },
                    pos: pos,
                    c: chrs.charAt(0),
                  });
            },
            cardinality: 2,
            prevalidator: [
              {
                validator: function (chrs, maskset, pos, strict, opts) {
                  var pchrs = chrs;
                  isNaN(maskset.buffer[pos + 1]) ||
                    (pchrs += maskset.buffer[pos + 1]);
                  var isValid =
                    1 === pchrs.length
                      ? opts.regex.val1pre.test(pchrs)
                      : opts.regex.val1.test(pchrs);
                  if (
                    (isValid &&
                      maskset.validPositions[pos] &&
                      (opts.regex
                        .val2(opts.separator)
                        .test(chrs + maskset.validPositions[pos].input) ||
                        (maskset.validPositions[pos].input =
                          "0" === chrs ? "1" : "0")),
                    !strict && !isValid)
                  ) {
                    if ((isValid = opts.regex.val1.test(chrs + "0")))
                      return (
                        (maskset.buffer[pos] = chrs),
                        (maskset.buffer[++pos] = "0"),
                        {
                          pos: pos,
                          c: "0",
                        }
                      );
                    if ((isValid = opts.regex.val1.test("0" + chrs)))
                      return (
                        (maskset.buffer[pos] = "0"),
                        pos++,
                        {
                          pos: pos,
                        }
                      );
                  }
                  return isValid;
                },
                cardinality: 1,
              },
            ],
          },
          2: {
            validator: function (chrs, maskset, pos, strict, opts) {
              var frontValue = opts.getFrontValue(
                maskset.mask,
                maskset.buffer,
                opts
              );
              -1 !== frontValue.indexOf(opts.placeholder[0]) &&
                (frontValue = "01" + opts.separator);
              var isValid = opts.regex
                .val2(opts.separator)
                .test(frontValue + chrs);
              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"),
                  {
                    refreshFromBuffer: {
                      start: pos - 1,
                      end: pos,
                    },
                    pos: pos,
                    c: chrs.charAt(0),
                  });
            },
            cardinality: 2,
            prevalidator: [
              {
                validator: function (chrs, maskset, pos, strict, opts) {
                  isNaN(maskset.buffer[pos + 1]) ||
                    (chrs += maskset.buffer[pos + 1]);
                  var frontValue = opts.getFrontValue(
                    maskset.mask,
                    maskset.buffer,
                    opts
                  );
                  -1 !== frontValue.indexOf(opts.placeholder[0]) &&
                    (frontValue = "01" + opts.separator);
                  var isValid =
                    1 === chrs.length
                      ? opts.regex
                          .val2pre(opts.separator)
                          .test(frontValue + chrs)
                      : opts.regex.val2(opts.separator).test(frontValue + chrs);
                  return (
                    isValid &&
                      maskset.validPositions[pos] &&
                      (opts.regex
                        .val2(opts.separator)
                        .test(chrs + maskset.validPositions[pos].input) ||
                        (maskset.validPositions[pos].input =
                          "0" === chrs ? "1" : "0")),
                    strict ||
                    isValid ||
                    !(isValid = opts.regex
                      .val2(opts.separator)
                      .test(frontValue + "0" + chrs))
                      ? isValid
                      : ((maskset.buffer[pos] = "0"),
                        pos++,
                        {
                          pos: pos,
                        })
                  );
                },
                cardinality: 1,
              },
            ],
          },
          y: {
            validator: function (chrs, maskset, pos, strict, opts) {
              return opts.isInYearRange(
                chrs,
                opts.yearrange.minyear,
                opts.yearrange.maxyear
              );
            },
            cardinality: 4,
            prevalidator: [
              {
                validator: function (chrs, maskset, pos, strict, opts) {
                  var isValid = opts.isInYearRange(
                    chrs,
                    opts.yearrange.minyear,
                    opts.yearrange.maxyear
                  );
                  if (!strict && !isValid) {
                    var yearPrefix = opts
                      .determinebaseyear(
                        opts.yearrange.minyear,
                        opts.yearrange.maxyear,
                        chrs + "0"
                      )
                      .toString()
                      .slice(0, 1);
                    if (
                      (isValid = opts.isInYearRange(
                        yearPrefix + chrs,
                        opts.yearrange.minyear,
                        opts.yearrange.maxyear
                      ))
                    )
                      return (
                        (maskset.buffer[pos++] = yearPrefix.charAt(0)),
                        {
                          pos: pos,
                        }
                      );
                    if (
                      ((yearPrefix = opts
                        .determinebaseyear(
                          opts.yearrange.minyear,
                          opts.yearrange.maxyear,
                          chrs + "0"
                        )
                        .toString()
                        .slice(0, 2)),
                      (isValid = opts.isInYearRange(
                        yearPrefix + chrs,
                        opts.yearrange.minyear,
                        opts.yearrange.maxyear
                      )))
                    )
                      return (
                        (maskset.buffer[pos++] = yearPrefix.charAt(0)),
                        (maskset.buffer[pos++] = yearPrefix.charAt(1)),
                        {
                          pos: pos,
                        }
                      );
                  }
                  return isValid;
                },
                cardinality: 1,
              },
              {
                validator: function (chrs, maskset, pos, strict, opts) {
                  var isValid = opts.isInYearRange(
                    chrs,
                    opts.yearrange.minyear,
                    opts.yearrange.maxyear
                  );
                  if (!strict && !isValid) {
                    var yearPrefix = opts
                      .determinebaseyear(
                        opts.yearrange.minyear,
                        opts.yearrange.maxyear,
                        chrs
                      )
                      .toString()
                      .slice(0, 2);
                    if (
                      (isValid = opts.isInYearRange(
                        chrs[0] + yearPrefix[1] + chrs[1],
                        opts.yearrange.minyear,
                        opts.yearrange.maxyear
                      ))
                    )
                      return (
                        (maskset.buffer[pos++] = yearPrefix.charAt(1)),
                        {
                          pos: pos,
                        }
                      );
                    if (
                      ((yearPrefix = opts
                        .determinebaseyear(
                          opts.yearrange.minyear,
                          opts.yearrange.maxyear,
                          chrs
                        )
                        .toString()
                        .slice(0, 2)),
                      (isValid = opts.isInYearRange(
                        yearPrefix + chrs,
                        opts.yearrange.minyear,
                        opts.yearrange.maxyear
                      )))
                    )
                      return (
                        (maskset.buffer[pos - 1] = yearPrefix.charAt(0)),
                        (maskset.buffer[pos++] = yearPrefix.charAt(1)),
                        (maskset.buffer[pos++] = chrs.charAt(0)),
                        {
                          refreshFromBuffer: {
                            start: pos - 3,
                            end: pos,
                          },
                          pos: pos,
                        }
                      );
                  }
                  return isValid;
                },
                cardinality: 2,
              },
              {
                validator: function (chrs, maskset, pos, strict, opts) {
                  return opts.isInYearRange(
                    chrs,
                    opts.yearrange.minyear,
                    opts.yearrange.maxyear
                  );
                },
                cardinality: 3,
              },
            ],
          },
        },
        insertMode: !1,
        autoUnmask: !1,
      },
      "mm/dd/yyyy": {
        placeholder: "mm/dd/yyyy",
        alias: "dd/mm/yyyy",
        regex: {
          val2pre: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            return new RegExp(
              "((0[13-9]|1[012])" +
                escapedSeparator +
                "[0-3])|(02" +
                escapedSeparator +
                "[0-2])"
            );
          },
          val2: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            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)"
            );
          },
          val1pre: new RegExp("[01]"),
          val1: new RegExp("0[1-9]|1[012]"),
        },
        leapday: "02/29/",
        onKeyDown: function (e, buffer, caretPos, opts) {
          var $input = $(this);
          if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
            var today = new Date();
            $input.val(
              (today.getMonth() + 1).toString() +
                today.getDate().toString() +
                today.getFullYear().toString()
            ),
              $input.trigger("setvalue");
          }
        },
      },
      "yyyy/mm/dd": {
        mask: "y/1/2",
        placeholder: "yyyy/mm/dd",
        alias: "mm/dd/yyyy",
        leapday: "/02/29",
        onKeyDown: function (e, buffer, caretPos, opts) {
          var $input = $(this);
          if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
            var today = new Date();
            $input.val(
              today.getFullYear().toString() +
                (today.getMonth() + 1).toString() +
                today.getDate().toString()
            ),
              $input.trigger("setvalue");
          }
        },
      },
      "dd.mm.yyyy": {
        mask: "1.2.y",
        placeholder: "dd.mm.yyyy",
        leapday: "29.02.",
        separator: ".",
        alias: "dd/mm/yyyy",
      },
      "dd-mm-yyyy": {
        mask: "1-2-y",
        placeholder: "dd-mm-yyyy",
        leapday: "29-02-",
        separator: "-",
        alias: "dd/mm/yyyy",
      },
      "mm.dd.yyyy": {
        mask: "1.2.y",
        placeholder: "mm.dd.yyyy",
        leapday: "02.29.",
        separator: ".",
        alias: "mm/dd/yyyy",
      },
      "mm-dd-yyyy": {
        mask: "1-2-y",
        placeholder: "mm-dd-yyyy",
        leapday: "02-29-",
        separator: "-",
        alias: "mm/dd/yyyy",
      },
      "yyyy.mm.dd": {
        mask: "y.1.2",
        placeholder: "yyyy.mm.dd",
        leapday: ".02.29",
        separator: ".",
        alias: "yyyy/mm/dd",
      },
      "yyyy-mm-dd": {
        mask: "y-1-2",
        placeholder: "yyyy-mm-dd",
        leapday: "-02-29",
        separator: "-",
        alias: "yyyy/mm/dd",
      },
      datetime: {
        mask: "1/2/y h:s",
        placeholder: "dd/mm/yyyy hh:mm",
        alias: "dd/mm/yyyy",
        regex: {
          hrspre: new RegExp("[012]"),
          hrs24: new RegExp("2[0-4]|1[3-9]"),
          hrs: new RegExp("[01][0-9]|2[0-4]"),
          ampm: new RegExp("^[a|p|A|P][m|M]"),
          mspre: new RegExp("[0-5]"),
          ms: new RegExp("[0-5][0-9]"),
        },
        timeseparator: ":",
        hourFormat: "24",
        definitions: {
          h: {
            validator: function (chrs, maskset, pos, strict, opts) {
              if ("24" === opts.hourFormat && 24 === parseInt(chrs, 10))
                return (
                  (maskset.buffer[pos - 1] = "0"),
                  (maskset.buffer[pos] = "0"),
                  {
                    refreshFromBuffer: {
                      start: pos - 1,
                      end: pos,
                    },
                    c: "0",
                  }
                );
              var isValid = opts.regex.hrs.test(chrs);
              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"),
                  (maskset.buffer[pos] = chrs.charAt(0)),
                  pos++,
                  {
                    refreshFromBuffer: {
                      start: pos - 2,
                      end: pos,
                    },
                    pos: pos,
                    c: opts.timeseparator,
                  }
                );
              if (
                isValid &&
                "24" !== opts.hourFormat &&
                opts.regex.hrs24.test(chrs)
              ) {
                var tmp = parseInt(chrs, 10);
                return (
                  24 === tmp
                    ? ((maskset.buffer[pos + 5] = "a"),
                      (maskset.buffer[pos + 6] = "m"))
                    : ((maskset.buffer[pos + 5] = "p"),
                      (maskset.buffer[pos + 6] = "m")),
                  (tmp -= 12) < 10
                    ? ((maskset.buffer[pos] = tmp.toString()),
                      (maskset.buffer[pos - 1] = "0"))
                    : ((maskset.buffer[pos] = tmp.toString().charAt(1)),
                      (maskset.buffer[pos - 1] = tmp.toString().charAt(0))),
                  {
                    refreshFromBuffer: {
                      start: pos - 1,
                      end: pos + 6,
                    },
                    c: maskset.buffer[pos],
                  }
                );
              }
              return isValid;
            },
            cardinality: 2,
            prevalidator: [
              {
                validator: function (chrs, maskset, pos, strict, opts) {
                  var isValid = opts.regex.hrspre.test(chrs);
                  return strict ||
                    isValid ||
                    !(isValid = opts.regex.hrs.test("0" + chrs))
                    ? isValid
                    : ((maskset.buffer[pos] = "0"),
                      pos++,
                      {
                        pos: pos,
                      });
                },
                cardinality: 1,
              },
            ],
          },
          s: {
            validator: "[0-5][0-9]",
            cardinality: 2,
            prevalidator: [
              {
                validator: function (chrs, maskset, pos, strict, opts) {
                  var isValid = opts.regex.mspre.test(chrs);
                  return strict ||
                    isValid ||
                    !(isValid = opts.regex.ms.test("0" + chrs))
                    ? isValid
                    : ((maskset.buffer[pos] = "0"),
                      pos++,
                      {
                        pos: pos,
                      });
                },
                cardinality: 1,
              },
            ],
          },
          t: {
            validator: function (chrs, maskset, pos, strict, opts) {
              return opts.regex.ampm.test(chrs + "m");
            },
            casing: "lower",
            cardinality: 1,
          },
        },
        insertMode: !1,
        autoUnmask: !1,
      },
      datetime12: {
        mask: "1/2/y h:s t\\m",
        placeholder: "dd/mm/yyyy hh:mm xm",
        alias: "datetime",
        hourFormat: "12",
      },
      "mm/dd/yyyy hh:mm xm": {
        mask: "1/2/y h:s t\\m",
        placeholder: "mm/dd/yyyy hh:mm xm",
        alias: "datetime12",
        regex: {
          val2pre: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            return new RegExp(
              "((0[13-9]|1[012])" +
                escapedSeparator +
                "[0-3])|(02" +
                escapedSeparator +
                "[0-2])"
            );
          },
          val2: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            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)"
            );
          },
          val1pre: new RegExp("[01]"),
          val1: new RegExp("0[1-9]|1[012]"),
        },
        leapday: "02/29/",
        onKeyDown: function (e, buffer, caretPos, opts) {
          var $input = $(this);
          if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
            var today = new Date();
            $input.val(
              (today.getMonth() + 1).toString() +
                today.getDate().toString() +
                today.getFullYear().toString()
            ),
              $input.trigger("setvalue");
          }
        },
      },
      "hh:mm t": {
        mask: "h:s t\\m",
        placeholder: "hh:mm xm",
        alias: "datetime",
        hourFormat: "12",
      },
      "h:s t": {
        mask: "h:s t\\m",
        placeholder: "hh:mm xm",
        alias: "datetime",
        hourFormat: "12",
      },
      "hh:mm:ss": {
        mask: "h:s:s",
        placeholder: "hh:mm:ss",
        alias: "datetime",
        autoUnmask: !1,
      },
      "hh:mm": {
        mask: "h:s",
        placeholder: "hh:mm",
        alias: "datetime",
        autoUnmask: !1,
      },
      date: {
        alias: "dd/mm/yyyy",
      },
      "mm/yyyy": {
        mask: "1/y",
        placeholder: "mm/yyyy",
        leapday: "donotuse",
        separator: "/",
        alias: "mm/dd/yyyy",
      },
      shamsi: {
        regex: {
          val2pre: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            return new RegExp("((0[1-9]|1[012])" + escapedSeparator + "[0-3])");
          },
          val2: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            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)"
            );
          },
          val1pre: new RegExp("[01]"),
          val1: new RegExp("0[1-9]|1[012]"),
        },
        yearrange: {
          minyear: 1300,
          maxyear: 1499,
        },
        mask: "y/1/2",
        leapday: "/12/30",
        placeholder: "yyyy/mm/dd",
        alias: "mm/dd/yyyy",
        clearIncomplete: !0,
      },
      "yyyy-mm-dd hh:mm:ss": {
        mask: "y-1-2 h:s:s",
        placeholder: "yyyy-mm-dd hh:mm:ss",
        alias: "datetime",
        separator: "-",
        leapday: "-02-29",
        regex: {
          val2pre: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            return new RegExp(
              "((0[13-9]|1[012])" +
                escapedSeparator +
                "[0-3])|(02" +
                escapedSeparator +
                "[0-2])"
            );
          },
          val2: function (separator) {
            var escapedSeparator = Inputmask.escapeRegex.call(this, separator);
            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)"
            );
          },
          val1pre: new RegExp("[01]"),
          val1: new RegExp("0[1-9]|1[012]"),
        },
        onKeyDown: function (e, buffer, caretPos, opts) {},
      },
    }),
    Inputmask
  );
});