1#@!#!123s

22527 1#@!#!123s
: / var / www / html / webadmin / assets / libs / inputmask / dist / inputmask /
Filename : inputmask.js
back
/*!
 * inputmask.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",
          "./global/window",
          "./global/document",
        ],
        factory
      )
    : "object" == typeof exports
    ? (module.exports = factory(
        require("./dependencyLibs/inputmask.dependencyLib"),
        require("./global/window"),
        require("./global/document")
      ))
    : (window.Inputmask = factory(
        window.dependencyLib || jQuery,
        window,
        document
      ));
})(function ($, window, document, undefined) {
  function Inputmask(alias, options, internal) {
    if (!(this instanceof Inputmask))
      return new Inputmask(alias, options, internal);
    (this.el = undefined),
      (this.events = {}),
      (this.maskset = undefined),
      (this.refreshValue = !1),
      !0 !== internal &&
        ($.isPlainObject(alias)
          ? (options = alias)
          : ((options = options || {}).alias = alias),
        (this.opts = $.extend(!0, {}, this.defaults, options)),
        (this.noMasksCache = options && options.definitions !== undefined),
        (this.userOptions = options || {}),
        (this.isRTL = this.opts.numericInput),
        resolveAlias(this.opts.alias, options, this.opts));
  }
  function resolveAlias(aliasStr, options, opts) {
    var aliasDefinition = Inputmask.prototype.aliases[aliasStr];
    return aliasDefinition
      ? (aliasDefinition.alias &&
          resolveAlias(aliasDefinition.alias, undefined, opts),
        $.extend(!0, opts, aliasDefinition),
        $.extend(!0, opts, options),
        !0)
      : (null === opts.mask && (opts.mask = aliasStr), !1);
  }
  function generateMaskSet(opts, nocache) {
    function generateMask(mask, metadata, opts) {
      var regexMask = !1;
      if (
        ((null !== mask && "" !== mask) ||
          ((regexMask = null !== opts.regex)
            ? (mask = (mask = opts.regex).replace(/^(\^)(.*)(\$)$/, "$2"))
            : ((regexMask = !0), (mask = ".*"))),
        1 === mask.length &&
          !1 === opts.greedy &&
          0 !== opts.repeat &&
          (opts.placeholder = ""),
        opts.repeat > 0 || "*" === opts.repeat || "+" === opts.repeat)
      ) {
        var repeatStart =
          "*" === opts.repeat ? 0 : "+" === opts.repeat ? 1 : opts.repeat;
        mask =
          opts.groupmarker.start +
          mask +
          opts.groupmarker.end +
          opts.quantifiermarker.start +
          repeatStart +
          "," +
          opts.repeat +
          opts.quantifiermarker.end;
      }
      var masksetDefinition,
        maskdefKey = regexMask
          ? "regex_" + opts.regex
          : opts.numericInput
          ? mask.split("").reverse().join("")
          : mask;
      return (
        Inputmask.prototype.masksCache[maskdefKey] === undefined ||
        !0 === nocache
          ? ((masksetDefinition = {
              mask: mask,
              maskToken: Inputmask.prototype.analyseMask(mask, regexMask, opts),
              validPositions: {},
              _buffer: undefined,
              buffer: undefined,
              tests: {},
              metadata: metadata,
              maskLength: undefined,
            }),
            !0 !== nocache &&
              ((Inputmask.prototype.masksCache[maskdefKey] = masksetDefinition),
              (masksetDefinition = $.extend(
                !0,
                {},
                Inputmask.prototype.masksCache[maskdefKey]
              ))))
          : (masksetDefinition = $.extend(
              !0,
              {},
              Inputmask.prototype.masksCache[maskdefKey]
            )),
        masksetDefinition
      );
    }
    if (
      ($.isFunction(opts.mask) && (opts.mask = opts.mask(opts)),
      $.isArray(opts.mask))
    ) {
      if (opts.mask.length > 1) {
        opts.keepStatic = null === opts.keepStatic || opts.keepStatic;
        var altMask = opts.groupmarker.start;
        return (
          $.each(
            opts.numericInput ? opts.mask.reverse() : opts.mask,
            function (ndx, msk) {
              altMask.length > 1 &&
                (altMask +=
                  opts.groupmarker.end +
                  opts.alternatormarker +
                  opts.groupmarker.start),
                msk.mask === undefined || $.isFunction(msk.mask)
                  ? (altMask += msk)
                  : (altMask += msk.mask);
            }
          ),
          (altMask += opts.groupmarker.end),
          generateMask(altMask, opts.mask, opts)
        );
      }
      opts.mask = opts.mask.pop();
    }
    return opts.mask &&
      opts.mask.mask !== undefined &&
      !$.isFunction(opts.mask.mask)
      ? generateMask(opts.mask.mask, opts.mask, opts)
      : generateMask(opts.mask, opts.mask, opts);
  }
  function maskScope(actionObj, maskset, opts) {
    function getMaskTemplate(baseOnInput, minimalPos, includeMode) {
      minimalPos = minimalPos || 0;
      var ndxIntlzr,
        test,
        testPos,
        maskTemplate = [],
        pos = 0,
        lvp = getLastValidPosition();
      do {
        !0 === baseOnInput && getMaskSet().validPositions[pos]
          ? ((test = (testPos = getMaskSet().validPositions[pos]).match),
            (ndxIntlzr = testPos.locator.slice()),
            maskTemplate.push(
              !0 === includeMode
                ? testPos.input
                : !1 === includeMode
                ? test.nativeDef
                : getPlaceholder(pos, test)
            ))
          : ((test = (testPos = getTestTemplate(pos, ndxIntlzr, pos - 1))
              .match),
            (ndxIntlzr = testPos.locator.slice()),
            (!1 === opts.jitMasking ||
              pos < lvp ||
              ("number" == typeof opts.jitMasking &&
                isFinite(opts.jitMasking) &&
                opts.jitMasking > pos)) &&
              maskTemplate.push(
                !1 === includeMode ? test.nativeDef : getPlaceholder(pos, test)
              )),
          pos++;
      } while (((maxLength === undefined || pos < maxLength) && (null !== test.fn || "" !== test.def)) || minimalPos > pos);
      return (
        "" === maskTemplate[maskTemplate.length - 1] && maskTemplate.pop(),
        (getMaskSet().maskLength = pos + 1),
        maskTemplate
      );
    }
    function getMaskSet() {
      return maskset;
    }
    function resetMaskSet(soft) {
      var maskset = getMaskSet();
      (maskset.buffer = undefined),
        !0 !== soft && ((maskset.validPositions = {}), (maskset.p = 0));
    }
    function getLastValidPosition(closestTo, strict, validPositions) {
      var before = -1,
        after = -1,
        valids = validPositions || getMaskSet().validPositions;
      closestTo === undefined && (closestTo = -1);
      for (var posNdx in valids) {
        var psNdx = parseInt(posNdx);
        valids[psNdx] &&
          (strict || !0 !== valids[psNdx].generatedInput) &&
          (psNdx <= closestTo && (before = psNdx),
          psNdx >= closestTo && (after = psNdx));
      }
      return (-1 !== before && closestTo - before > 1) || after < closestTo
        ? before
        : after;
    }
    function stripValidPositions(start, end, nocheck, strict) {
      var i,
        startPos = start,
        positionsClone = $.extend(!0, {}, getMaskSet().validPositions),
        needsValidation = !1;
      for (getMaskSet().p = start, i = end - 1; i >= startPos; i--)
        getMaskSet().validPositions[i] !== undefined &&
          ((!0 !== nocheck &&
            ((!getMaskSet().validPositions[i].match.optionality &&
              (function (pos) {
                var posMatch = getMaskSet().validPositions[pos];
                if (posMatch !== undefined && null === posMatch.match.fn) {
                  var prevMatch = getMaskSet().validPositions[pos - 1],
                    nextMatch = getMaskSet().validPositions[pos + 1];
                  return prevMatch !== undefined && nextMatch !== undefined;
                }
                return !1;
              })(i)) ||
              !1 ===
                opts.canClearPosition(
                  getMaskSet(),
                  i,
                  getLastValidPosition(),
                  strict,
                  opts
                ))) ||
            delete getMaskSet().validPositions[i]);
      for (resetMaskSet(!0), i = startPos + 1; i <= getLastValidPosition(); ) {
        for (; getMaskSet().validPositions[startPos] !== undefined; )
          startPos++;
        if (
          (i < startPos && (i = startPos + 1),
          getMaskSet().validPositions[i] === undefined && isMask(i))
        )
          i++;
        else {
          var t = getTestTemplate(i);
          !1 === needsValidation &&
          positionsClone[startPos] &&
          positionsClone[startPos].match.def === t.match.def
            ? ((getMaskSet().validPositions[startPos] = $.extend(
                !0,
                {},
                positionsClone[startPos]
              )),
              (getMaskSet().validPositions[startPos].input = t.input),
              delete getMaskSet().validPositions[i],
              i++)
            : positionCanMatchDefinition(startPos, t.match.def)
            ? !1 !== isValid(startPos, t.input || getPlaceholder(i), !0) &&
              (delete getMaskSet().validPositions[i],
              i++,
              (needsValidation = !0))
            : isMask(i) || (i++, startPos--),
            startPos++;
        }
      }
      resetMaskSet(!0);
    }
    function determineTestTemplate(tests, guessNextBest) {
      for (
        var testPos,
          testPositions = tests,
          lvp = getLastValidPosition(),
          lvTest = getMaskSet().validPositions[lvp] || getTests(0)[0],
          lvTestAltArr =
            lvTest.alternation !== undefined
              ? lvTest.locator[lvTest.alternation].toString().split(",")
              : [],
          ndx = 0;
        ndx < testPositions.length &&
        (!(
          (testPos = testPositions[ndx]).match &&
          ((opts.greedy && !0 !== testPos.match.optionalQuantifier) ||
            ((!1 === testPos.match.optionality ||
              !1 === testPos.match.newBlockMarker) &&
              !0 !== testPos.match.optionalQuantifier)) &&
          (lvTest.alternation === undefined ||
            lvTest.alternation !== testPos.alternation ||
            (testPos.locator[lvTest.alternation] !== undefined &&
              checkAlternationMatch(
                testPos.locator[lvTest.alternation].toString().split(","),
                lvTestAltArr
              )))
        ) ||
          (!0 === guessNextBest &&
            (null !== testPos.match.fn ||
              /[0-9a-bA-Z]/.test(testPos.match.def))));
        ndx++
      );
      return testPos;
    }
    function getTestTemplate(pos, ndxIntlzr, tstPs) {
      return (
        getMaskSet().validPositions[pos] ||
        determineTestTemplate(
          getTests(pos, ndxIntlzr ? ndxIntlzr.slice() : ndxIntlzr, tstPs)
        )
      );
    }
    function getTest(pos) {
      return getMaskSet().validPositions[pos]
        ? getMaskSet().validPositions[pos]
        : getTests(pos)[0];
    }
    function positionCanMatchDefinition(pos, def) {
      for (
        var valid = !1, tests = getTests(pos), tndx = 0;
        tndx < tests.length;
        tndx++
      )
        if (tests[tndx].match && tests[tndx].match.def === def) {
          valid = !0;
          break;
        }
      return valid;
    }
    function getTests(pos, ndxIntlzr, tstPs) {
      function resolveTestFromToken(
        maskToken,
        ndxInitializer,
        loopNdx,
        quantifierRecurse
      ) {
        function handleMatch(match, loopNdx, quantifierRecurse) {
          function isFirstMatch(latestMatch, tokenGroup) {
            var firstMatch = 0 === $.inArray(latestMatch, tokenGroup.matches);
            return (
              firstMatch ||
                $.each(tokenGroup.matches, function (ndx, match) {
                  if (
                    !0 === match.isQuantifier &&
                    (firstMatch = isFirstMatch(
                      latestMatch,
                      tokenGroup.matches[ndx - 1]
                    ))
                  )
                    return !1;
                }),
              firstMatch
            );
          }
          function resolveNdxInitializer(pos, alternateNdx, targetAlternation) {
            var bestMatch, indexPos;
            if (
              getMaskSet().validPositions[pos - 1] &&
              targetAlternation &&
              getMaskSet().tests[pos]
            )
              for (
                var vpAlternation =
                    getMaskSet().validPositions[pos - 1].locator,
                  tpAlternation = getMaskSet().tests[pos][0].locator,
                  i = 0;
                i < targetAlternation;
                i++
              )
                if (vpAlternation[i] !== tpAlternation[i])
                  return vpAlternation.slice(targetAlternation + 1);
            return (
              (getMaskSet().tests[pos] || getMaskSet().validPositions[pos]) &&
                $.each(
                  getMaskSet().tests[pos] || [getMaskSet().validPositions[pos]],
                  function (ndx, lmnt) {
                    var alternation =
                        targetAlternation !== undefined
                          ? targetAlternation
                          : lmnt.alternation,
                      ndxPos =
                        lmnt.locator[alternation] !== undefined
                          ? lmnt.locator[alternation]
                              .toString()
                              .indexOf(alternateNdx)
                          : -1;
                    (indexPos === undefined || ndxPos < indexPos) &&
                      -1 !== ndxPos &&
                      ((bestMatch = lmnt), (indexPos = ndxPos));
                  }
                ),
              bestMatch
                ? bestMatch.locator.slice(
                    (targetAlternation !== undefined
                      ? targetAlternation
                      : bestMatch.alternation) + 1
                  )
                : targetAlternation !== undefined
                ? resolveNdxInitializer(pos, alternateNdx)
                : undefined
            );
          }
          if (testPos > 1e4)
            throw (
              "Inputmask: There is probably an error in your mask definition or in the code. Create an issue on github with an example of the mask you are using. " +
              getMaskSet().mask
            );
          if (testPos === pos && match.matches === undefined)
            return (
              matches.push({
                match: match,
                locator: loopNdx.reverse(),
                cd: cacheDependency,
              }),
              !0
            );
          if (match.matches !== undefined) {
            if (match.isGroup && quantifierRecurse !== match) {
              if (
                (match = handleMatch(
                  maskToken.matches[$.inArray(match, maskToken.matches) + 1],
                  loopNdx
                ))
              )
                return !0;
            } else if (match.isOptional) {
              var optionalToken = match;
              if (
                (match = resolveTestFromToken(
                  match,
                  ndxInitializer,
                  loopNdx,
                  quantifierRecurse
                ))
              ) {
                if (
                  ((latestMatch = matches[matches.length - 1].match),
                  !isFirstMatch(latestMatch, optionalToken))
                )
                  return !0;
                (insertStop = !0), (testPos = pos);
              }
            } else if (match.isAlternator) {
              var maltMatches,
                alternateToken = match,
                malternateMatches = [],
                currentMatches = matches.slice(),
                loopNdxCnt = loopNdx.length,
                altIndex =
                  ndxInitializer.length > 0 ? ndxInitializer.shift() : -1;
              if (-1 === altIndex || "string" == typeof altIndex) {
                var amndx,
                  currentPos = testPos,
                  ndxInitializerClone = ndxInitializer.slice(),
                  altIndexArr = [];
                if ("string" == typeof altIndex)
                  altIndexArr = altIndex.split(",");
                else
                  for (
                    amndx = 0;
                    amndx < alternateToken.matches.length;
                    amndx++
                  )
                    altIndexArr.push(amndx);
                for (var ndx = 0; ndx < altIndexArr.length; ndx++) {
                  if (
                    ((amndx = parseInt(altIndexArr[ndx])),
                    (matches = []),
                    (ndxInitializer =
                      resolveNdxInitializer(testPos, amndx, loopNdxCnt) ||
                      ndxInitializerClone.slice()),
                    !0 !==
                      (match =
                        handleMatch(
                          alternateToken.matches[amndx] ||
                            maskToken.matches[amndx],
                          [amndx].concat(loopNdx),
                          quantifierRecurse
                        ) || match) &&
                      match !== undefined &&
                      altIndexArr[altIndexArr.length - 1] <
                        alternateToken.matches.length)
                  ) {
                    var ntndx = $.inArray(match, maskToken.matches) + 1;
                    maskToken.matches.length > ntndx &&
                      (match = handleMatch(
                        maskToken.matches[ntndx],
                        [ntndx].concat(loopNdx.slice(1, loopNdx.length)),
                        quantifierRecurse
                      )) &&
                      (altIndexArr.push(ntndx.toString()),
                      $.each(matches, function (ndx, lmnt) {
                        lmnt.alternation = loopNdx.length - 1;
                      }));
                  }
                  (maltMatches = matches.slice()),
                    (testPos = currentPos),
                    (matches = []);
                  for (var ndx1 = 0; ndx1 < maltMatches.length; ndx1++) {
                    var altMatch = maltMatches[ndx1],
                      dropMatch = !1;
                    altMatch.alternation = altMatch.alternation || loopNdxCnt;
                    for (
                      var ndx2 = 0;
                      ndx2 < malternateMatches.length;
                      ndx2++
                    ) {
                      var altMatch2 = malternateMatches[ndx2];
                      if (
                        "string" != typeof altIndex ||
                        -1 !==
                          $.inArray(
                            altMatch.locator[altMatch.alternation].toString(),
                            altIndexArr
                          )
                      ) {
                        if (
                          (function (source, target) {
                            return (
                              source.match.nativeDef ===
                                target.match.nativeDef ||
                              source.match.def === target.match.nativeDef ||
                              source.match.nativeDef === target.match.def
                            );
                          })(altMatch, altMatch2)
                        ) {
                          (dropMatch = !0),
                            altMatch.alternation === altMatch2.alternation &&
                              -1 ===
                                altMatch2.locator[altMatch2.alternation]
                                  .toString()
                                  .indexOf(
                                    altMatch.locator[altMatch.alternation]
                                  ) &&
                              ((altMatch2.locator[altMatch2.alternation] =
                                altMatch2.locator[altMatch2.alternation] +
                                "," +
                                altMatch.locator[altMatch.alternation]),
                              (altMatch2.alternation = altMatch.alternation)),
                            altMatch.match.nativeDef === altMatch2.match.def &&
                              ((altMatch.locator[altMatch.alternation] =
                                altMatch2.locator[altMatch2.alternation]),
                              malternateMatches.splice(
                                malternateMatches.indexOf(altMatch2),
                                1,
                                altMatch
                              ));
                          break;
                        }
                        if (altMatch.match.def === altMatch2.match.def) {
                          dropMatch = !1;
                          break;
                        }
                        if (
                          (function (source, target) {
                            return (
                              null === source.match.fn &&
                              null !== target.match.fn &&
                              target.match.fn.test(
                                source.match.def,
                                getMaskSet(),
                                pos,
                                !1,
                                opts,
                                !1
                              )
                            );
                          })(altMatch, altMatch2) ||
                          (function (source, target) {
                            return (
                              null !== source.match.fn &&
                              null !== target.match.fn &&
                              target.match.fn.test(
                                source.match.def.replace(/[\[\]]/g, ""),
                                getMaskSet(),
                                pos,
                                !1,
                                opts,
                                !1
                              )
                            );
                          })(altMatch, altMatch2)
                        ) {
                          altMatch.alternation === altMatch2.alternation &&
                            -1 ===
                              altMatch.locator[altMatch.alternation]
                                .toString()
                                .indexOf(
                                  altMatch2.locator[altMatch2.alternation]
                                    .toString()
                                    .split("")[0]
                                ) &&
                            ((altMatch.na =
                              altMatch.na ||
                              altMatch.locator[
                                altMatch.alternation
                              ].toString()),
                            -1 ===
                              altMatch.na.indexOf(
                                altMatch.locator[altMatch.alternation]
                                  .toString()
                                  .split("")[0]
                              ) &&
                              (altMatch.na =
                                altMatch.na +
                                "," +
                                altMatch.locator[altMatch2.alternation]
                                  .toString()
                                  .split("")[0]),
                            (dropMatch = !0),
                            (altMatch.locator[altMatch.alternation] =
                              altMatch2.locator[altMatch2.alternation]
                                .toString()
                                .split("")[0] +
                              "," +
                              altMatch.locator[altMatch.alternation]),
                            malternateMatches.splice(
                              malternateMatches.indexOf(altMatch2),
                              0,
                              altMatch
                            ));
                          break;
                        }
                      }
                    }
                    dropMatch || malternateMatches.push(altMatch);
                  }
                }
                "string" == typeof altIndex &&
                  (malternateMatches = $.map(
                    malternateMatches,
                    function (lmnt, ndx) {
                      if (isFinite(ndx)) {
                        var alternation = lmnt.alternation,
                          altLocArr = lmnt.locator[alternation]
                            .toString()
                            .split(",");
                        (lmnt.locator[alternation] = undefined),
                          (lmnt.alternation = undefined);
                        for (var alndx = 0; alndx < altLocArr.length; alndx++)
                          -1 !== $.inArray(altLocArr[alndx], altIndexArr) &&
                            (lmnt.locator[alternation] !== undefined
                              ? ((lmnt.locator[alternation] += ","),
                                (lmnt.locator[alternation] += altLocArr[alndx]))
                              : (lmnt.locator[alternation] = parseInt(
                                  altLocArr[alndx]
                                )),
                            (lmnt.alternation = alternation));
                        if (lmnt.locator[alternation] !== undefined)
                          return lmnt;
                      }
                    }
                  )),
                  (matches = currentMatches.concat(malternateMatches)),
                  (testPos = pos),
                  (insertStop = matches.length > 0),
                  (match = malternateMatches.length > 0),
                  (ndxInitializer = ndxInitializerClone.slice());
              } else
                match = handleMatch(
                  alternateToken.matches[altIndex] ||
                    maskToken.matches[altIndex],
                  [altIndex].concat(loopNdx),
                  quantifierRecurse
                );
              if (match) return !0;
            } else if (
              match.isQuantifier &&
              quantifierRecurse !==
                maskToken.matches[$.inArray(match, maskToken.matches) - 1]
            )
              for (
                var qt = match,
                  qndx = ndxInitializer.length > 0 ? ndxInitializer.shift() : 0;
                qndx <
                  (isNaN(qt.quantifier.max) ? qndx + 1 : qt.quantifier.max) &&
                testPos <= pos;
                qndx++
              ) {
                var tokenGroup =
                  maskToken.matches[$.inArray(qt, maskToken.matches) - 1];
                if (
                  (match = handleMatch(
                    tokenGroup,
                    [qndx].concat(loopNdx),
                    tokenGroup
                  ))
                ) {
                  if (
                    ((latestMatch = matches[matches.length - 1].match),
                    (latestMatch.optionalQuantifier =
                      qndx > qt.quantifier.min - 1),
                    isFirstMatch(latestMatch, tokenGroup))
                  ) {
                    if (qndx > qt.quantifier.min - 1) {
                      (insertStop = !0), (testPos = pos);
                      break;
                    }
                    return !0;
                  }
                  return !0;
                }
              }
            else if (
              (match = resolveTestFromToken(
                match,
                ndxInitializer,
                loopNdx,
                quantifierRecurse
              ))
            )
              return !0;
          } else testPos++;
        }
        for (
          var tndx = ndxInitializer.length > 0 ? ndxInitializer.shift() : 0;
          tndx < maskToken.matches.length;
          tndx++
        )
          if (!0 !== maskToken.matches[tndx].isQuantifier) {
            var match = handleMatch(
              maskToken.matches[tndx],
              [tndx].concat(loopNdx),
              quantifierRecurse
            );
            if (match && testPos === pos) return match;
            if (testPos > pos) break;
          }
      }
      function filterTests(tests) {
        if (
          opts.keepStatic &&
          pos > 0 &&
          tests.length >
            1 + ("" === tests[tests.length - 1].match.def ? 1 : 0) &&
          !0 !== tests[0].match.optionality &&
          !0 !== tests[0].match.optionalQuantifier &&
          null === tests[0].match.fn &&
          !/[0-9a-bA-Z]/.test(tests[0].match.def)
        ) {
          if (getMaskSet().validPositions[pos - 1] === undefined)
            return [determineTestTemplate(tests)];
          if (
            getMaskSet().validPositions[pos - 1].alternation ===
            tests[0].alternation
          )
            return [determineTestTemplate(tests)];
          if (getMaskSet().validPositions[pos - 1])
            return [determineTestTemplate(tests)];
        }
        return tests;
      }
      var latestMatch,
        maskTokens = getMaskSet().maskToken,
        testPos = ndxIntlzr ? tstPs : 0,
        ndxInitializer = ndxIntlzr ? ndxIntlzr.slice() : [0],
        matches = [],
        insertStop = !1,
        cacheDependency = ndxIntlzr ? ndxIntlzr.join("") : "";
      if (pos > -1) {
        if (ndxIntlzr === undefined) {
          for (
            var test, previousPos = pos - 1;
            (test =
              getMaskSet().validPositions[previousPos] ||
              getMaskSet().tests[previousPos]) === undefined &&
            previousPos > -1;

          )
            previousPos--;
          test !== undefined &&
            previousPos > -1 &&
            ((ndxInitializer = (function (tests) {
              var locator = [];
              return (
                $.isArray(tests) || (tests = [tests]),
                tests.length > 0 &&
                  (tests[0].alternation === undefined
                    ? 0 ===
                        (locator = determineTestTemplate(
                          tests.slice()
                        ).locator.slice()).length &&
                      (locator = tests[0].locator.slice())
                    : $.each(tests, function (ndx, tst) {
                        if ("" !== tst.def)
                          if (0 === locator.length)
                            locator = tst.locator.slice();
                          else
                            for (var i = 0; i < locator.length; i++)
                              tst.locator[i] &&
                                -1 ===
                                  locator[i]
                                    .toString()
                                    .indexOf(tst.locator[i]) &&
                                (locator[i] += "," + tst.locator[i]);
                      })),
                locator
              );
            })(test)),
            (cacheDependency = ndxInitializer.join("")),
            (testPos = previousPos));
        }
        if (
          getMaskSet().tests[pos] &&
          getMaskSet().tests[pos][0].cd === cacheDependency
        )
          return filterTests(getMaskSet().tests[pos]);
        for (
          var mtndx = ndxInitializer.shift();
          mtndx < maskTokens.length &&
          !(
            (resolveTestFromToken(maskTokens[mtndx], ndxInitializer, [mtndx]) &&
              testPos === pos) ||
            testPos > pos
          );
          mtndx++
        );
      }
      return (
        (0 === matches.length || insertStop) &&
          matches.push({
            match: {
              fn: null,
              cardinality: 0,
              optionality: !0,
              casing: null,
              def: "",
              placeholder: "",
            },
            locator: [],
            cd: cacheDependency,
          }),
        ndxIntlzr !== undefined && getMaskSet().tests[pos]
          ? filterTests($.extend(!0, [], matches))
          : ((getMaskSet().tests[pos] = $.extend(!0, [], matches)),
            filterTests(getMaskSet().tests[pos]))
      );
    }
    function getBufferTemplate() {
      return (
        getMaskSet()._buffer === undefined &&
          ((getMaskSet()._buffer = getMaskTemplate(!1, 1)),
          getMaskSet().buffer === undefined &&
            (getMaskSet().buffer = getMaskSet()._buffer.slice())),
        getMaskSet()._buffer
      );
    }
    function getBuffer(noCache) {
      return (
        (getMaskSet().buffer !== undefined && !0 !== noCache) ||
          (getMaskSet().buffer = getMaskTemplate(
            !0,
            getLastValidPosition(),
            !0
          )),
        getMaskSet().buffer
      );
    }
    function refreshFromBuffer(start, end, buffer) {
      var i, p;
      if (!0 === start) resetMaskSet(), (start = 0), (end = buffer.length);
      else for (i = start; i < end; i++) delete getMaskSet().validPositions[i];
      for (p = start, i = start; i < end; i++)
        if ((resetMaskSet(!0), buffer[i] !== opts.skipOptionalPartCharacter)) {
          var valResult = isValid(p, buffer[i], !0, !0);
          !1 !== valResult &&
            (resetMaskSet(!0),
            (p =
              valResult.caret !== undefined
                ? valResult.caret
                : valResult.pos + 1));
        }
    }
    function casing(elem, test, pos) {
      switch (opts.casing || test.casing) {
        case "upper":
          elem = elem.toUpperCase();
          break;

        case "lower":
          elem = elem.toLowerCase();
          break;

        case "title":
          var posBefore = getMaskSet().validPositions[pos - 1];
          elem =
            0 === pos ||
            (posBefore &&
              posBefore.input === String.fromCharCode(Inputmask.keyCode.SPACE))
              ? elem.toUpperCase()
              : elem.toLowerCase();
          break;

        default:
          if ($.isFunction(opts.casing)) {
            var args = Array.prototype.slice.call(arguments);
            args.push(getMaskSet().validPositions),
              (elem = opts.casing.apply(this, args));
          }
      }
      return elem;
    }
    function checkAlternationMatch(altArr1, altArr2, na) {
      for (
        var naNdx,
          altArrC = opts.greedy ? altArr2 : altArr2.slice(0, 1),
          isMatch = !1,
          naArr = na !== undefined ? na.split(",") : [],
          i = 0;
        i < naArr.length;
        i++
      )
        -1 !== (naNdx = altArr1.indexOf(naArr[i])) && altArr1.splice(naNdx, 1);
      for (var alndx = 0; alndx < altArr1.length; alndx++)
        if (-1 !== $.inArray(altArr1[alndx], altArrC)) {
          isMatch = !0;
          break;
        }
      return isMatch;
    }
    function isValid(
      pos,
      c,
      strict,
      fromSetValid,
      fromAlternate,
      validateOnly
    ) {
      function isSelection(posObj) {
        var selection = isRTL
          ? posObj.begin - posObj.end > 1 || posObj.begin - posObj.end == 1
          : posObj.end - posObj.begin > 1 || posObj.end - posObj.begin == 1;
        return selection &&
          0 === posObj.begin &&
          posObj.end === getMaskSet().maskLength
          ? "full"
          : selection;
      }
      function _isValid(position, c, strict) {
        var rslt = !1;
        return (
          $.each(getTests(position), function (ndx, tst) {
            for (
              var test = tst.match,
                loopend = c ? 1 : 0,
                chrs = "",
                i = test.cardinality;
              i > loopend;
              i--
            )
              chrs += getBufferElement(position - (i - 1));
            if (
              (c && (chrs += c),
              getBuffer(!0),
              !1 !==
                (rslt =
                  null != test.fn
                    ? test.fn.test(
                        chrs,
                        getMaskSet(),
                        position,
                        strict,
                        opts,
                        isSelection(pos)
                      )
                    : (c === test.def ||
                        c === opts.skipOptionalPartCharacter) &&
                      "" !== test.def && {
                        c: getPlaceholder(position, test, !0) || test.def,
                        pos: position,
                      }))
            ) {
              var elem = rslt.c !== undefined ? rslt.c : c;
              elem =
                elem === opts.skipOptionalPartCharacter && null === test.fn
                  ? getPlaceholder(position, test, !0) || test.def
                  : elem;
              var validatedPos = position,
                possibleModifiedBuffer = getBuffer();
              if (
                (rslt.remove !== undefined &&
                  ($.isArray(rslt.remove) || (rslt.remove = [rslt.remove]),
                  $.each(
                    rslt.remove.sort(function (a, b) {
                      return b - a;
                    }),
                    function (ndx, lmnt) {
                      stripValidPositions(lmnt, lmnt + 1, !0);
                    }
                  )),
                rslt.insert !== undefined &&
                  ($.isArray(rslt.insert) || (rslt.insert = [rslt.insert]),
                  $.each(
                    rslt.insert.sort(function (a, b) {
                      return a - b;
                    }),
                    function (ndx, lmnt) {
                      isValid(lmnt.pos, lmnt.c, !0, fromSetValid);
                    }
                  )),
                rslt.refreshFromBuffer)
              ) {
                var refresh = rslt.refreshFromBuffer;
                if (
                  (refreshFromBuffer(
                    !0 === refresh ? refresh : refresh.start,
                    refresh.end,
                    possibleModifiedBuffer
                  ),
                  rslt.pos === undefined && rslt.c === undefined)
                )
                  return (rslt.pos = getLastValidPosition()), !1;
                if (
                  (validatedPos =
                    rslt.pos !== undefined ? rslt.pos : position) !== position
                )
                  return (
                    (rslt = $.extend(
                      rslt,
                      isValid(validatedPos, elem, !0, fromSetValid)
                    )),
                    !1
                  );
              } else if (
                !0 !== rslt &&
                rslt.pos !== undefined &&
                rslt.pos !== position &&
                ((validatedPos = rslt.pos),
                refreshFromBuffer(position, validatedPos, getBuffer().slice()),
                validatedPos !== position)
              )
                return (
                  (rslt = $.extend(rslt, isValid(validatedPos, elem, !0))), !1
                );
              return (
                (!0 === rslt ||
                  rslt.pos !== undefined ||
                  rslt.c !== undefined) &&
                (ndx > 0 && resetMaskSet(!0),
                setValidPosition(
                  validatedPos,
                  $.extend({}, tst, {
                    input: casing(elem, test, validatedPos),
                  }),
                  fromSetValid,
                  isSelection(pos)
                ) || (rslt = !1),
                !1)
              );
            }
          }),
          rslt
        );
      }
      function setValidPosition(pos, validTest, fromSetValid, isSelection) {
        if (
          isSelection ||
          (opts.insertMode &&
            getMaskSet().validPositions[pos] !== undefined &&
            fromSetValid === undefined)
        ) {
          var i,
            positionsClone = $.extend(!0, {}, getMaskSet().validPositions),
            lvp = getLastValidPosition(undefined, !0);
          for (i = pos; i <= lvp; i++) delete getMaskSet().validPositions[i];
          getMaskSet().validPositions[pos] = $.extend(!0, {}, validTest);
          var j,
            valid = !0,
            vps = getMaskSet().validPositions,
            needsValidation = !1,
            initialLength = getMaskSet().maskLength;
          for (i = j = pos; i <= lvp; i++) {
            var t = positionsClone[i];
            if (t !== undefined)
              for (
                var posMatch = j;
                posMatch < getMaskSet().maskLength &&
                ((null === t.match.fn &&
                  vps[i] &&
                  (!0 === vps[i].match.optionalQuantifier ||
                    !0 === vps[i].match.optionality)) ||
                  null != t.match.fn);

              ) {
                if (
                  (posMatch++,
                  !1 === needsValidation &&
                    positionsClone[posMatch] &&
                    positionsClone[posMatch].match.def === t.match.def)
                )
                  (getMaskSet().validPositions[posMatch] = $.extend(
                    !0,
                    {},
                    positionsClone[posMatch]
                  )),
                    (getMaskSet().validPositions[posMatch].input = t.input),
                    fillMissingNonMask(posMatch),
                    (j = posMatch),
                    (valid = !0);
                else if (positionCanMatchDefinition(posMatch, t.match.def)) {
                  var result = isValid(posMatch, t.input, !0, !0);
                  (valid = !1 !== result),
                    (j =
                      result.caret || result.insert
                        ? getLastValidPosition()
                        : posMatch),
                    (needsValidation = !0);
                } else if (
                  !(valid = !0 === t.generatedInput) &&
                  posMatch >= getMaskSet().maskLength - 1
                )
                  break;
                if (
                  (getMaskSet().maskLength < initialLength &&
                    (getMaskSet().maskLength = initialLength),
                  valid)
                )
                  break;
              }
            if (!valid) break;
          }
          if (!valid)
            return (
              (getMaskSet().validPositions = $.extend(!0, {}, positionsClone)),
              resetMaskSet(!0),
              !1
            );
        } else getMaskSet().validPositions[pos] = $.extend(!0, {}, validTest);
        return resetMaskSet(!0), !0;
      }
      function fillMissingNonMask(maskPos) {
        for (
          var pndx = maskPos - 1;
          pndx > -1 && !getMaskSet().validPositions[pndx];
          pndx--
        );
        var testTemplate, testsFromPos;
        for (pndx++; pndx < maskPos; pndx++)
          getMaskSet().validPositions[pndx] === undefined &&
            (!1 === opts.jitMasking || opts.jitMasking > pndx) &&
            ("" ===
              (testsFromPos = getTests(
                pndx,
                getTestTemplate(pndx - 1).locator,
                pndx - 1
              ).slice())[testsFromPos.length - 1].match.def &&
              testsFromPos.pop(),
            (testTemplate = determineTestTemplate(testsFromPos)) &&
              (testTemplate.match.def === opts.radixPointDefinitionSymbol ||
                !isMask(pndx, !0) ||
                ($.inArray(opts.radixPoint, getBuffer()) < pndx &&
                  testTemplate.match.fn &&
                  testTemplate.match.fn.test(
                    getPlaceholder(pndx),
                    getMaskSet(),
                    pndx,
                    !1,
                    opts
                  ))) &&
              !1 !==
                (result = _isValid(
                  pndx,
                  getPlaceholder(pndx, testTemplate.match, !0) ||
                    (null == testTemplate.match.fn
                      ? testTemplate.match.def
                      : "" !== getPlaceholder(pndx)
                      ? getPlaceholder(pndx)
                      : getBuffer()[pndx]),
                  !0
                )) &&
              (getMaskSet().validPositions[result.pos || pndx].generatedInput =
                !0));
      }
      strict = !0 === strict;
      var maskPos = pos;
      pos.begin !== undefined &&
        (maskPos = isRTL && !isSelection(pos) ? pos.end : pos.begin);
      var result = !0,
        positionsClone = $.extend(!0, {}, getMaskSet().validPositions);
      if (
        ($.isFunction(opts.preValidation) &&
          !strict &&
          !0 !== fromSetValid &&
          !0 !== validateOnly &&
          (result = opts.preValidation(
            getBuffer(),
            maskPos,
            c,
            isSelection(pos),
            opts
          )),
        !0 === result)
      ) {
        if (
          (fillMissingNonMask(maskPos),
          isSelection(pos) &&
            (handleRemove(undefined, Inputmask.keyCode.DELETE, pos, !0, !0),
            (maskPos = getMaskSet().p)),
          maskPos < getMaskSet().maskLength &&
            (maxLength === undefined || maskPos < maxLength) &&
            ((result = _isValid(maskPos, c, strict)),
            (!strict || !0 === fromSetValid) &&
              !1 === result &&
              !0 !== validateOnly))
        ) {
          var currentPosValid = getMaskSet().validPositions[maskPos];
          if (
            !currentPosValid ||
            null !== currentPosValid.match.fn ||
            (currentPosValid.match.def !== c &&
              c !== opts.skipOptionalPartCharacter)
          ) {
            if (
              (opts.insertMode ||
                getMaskSet().validPositions[seekNext(maskPos)] === undefined) &&
              !isMask(maskPos, !0)
            )
              for (
                var nPos = maskPos + 1, snPos = seekNext(maskPos);
                nPos <= snPos;
                nPos++
              )
                if (!1 !== (result = _isValid(nPos, c, strict))) {
                  !(function (originalPos, newPos) {
                    var vp = getMaskSet().validPositions[newPos];
                    if (vp)
                      for (
                        var targetLocator = vp.locator,
                          tll = targetLocator.length,
                          ps = originalPos;
                        ps < newPos;
                        ps++
                      )
                        if (
                          getMaskSet().validPositions[ps] === undefined &&
                          !isMask(ps, !0)
                        ) {
                          var tests = getTests(ps).slice(),
                            bestMatch = determineTestTemplate(tests, !0),
                            equality = -1;
                          "" === tests[tests.length - 1].match.def &&
                            tests.pop(),
                            $.each(tests, function (ndx, tst) {
                              for (var i = 0; i < tll; i++) {
                                if (
                                  tst.locator[i] === undefined ||
                                  !checkAlternationMatch(
                                    tst.locator[i].toString().split(","),
                                    targetLocator[i].toString().split(","),
                                    tst.na
                                  )
                                ) {
                                  var targetAI = targetLocator[i],
                                    bestMatchAI = bestMatch.locator[i],
                                    tstAI = tst.locator[i];
                                  targetAI - bestMatchAI >
                                    Math.abs(targetAI - tstAI) &&
                                    (bestMatch = tst);
                                  break;
                                }
                                equality < i &&
                                  ((equality = i), (bestMatch = tst));
                              }
                            }),
                            ((bestMatch = $.extend({}, bestMatch, {
                              input:
                                getPlaceholder(ps, bestMatch.match, !0) ||
                                bestMatch.match.def,
                            })).generatedInput = !0),
                            setValidPosition(ps, bestMatch, !0),
                            (getMaskSet().validPositions[newPos] = undefined),
                            _isValid(newPos, vp.input, !0);
                        }
                  })(maskPos, result.pos !== undefined ? result.pos : nPos),
                    (maskPos = nPos);
                  break;
                }
          } else
            result = {
              caret: seekNext(maskPos),
            };
        }
        !1 === result &&
          opts.keepStatic &&
          !strict &&
          !0 !== fromAlternate &&
          (result = (function (pos, c, strict) {
            var lastAlt,
              alternation,
              altPos,
              prevAltPos,
              i,
              validPos,
              altNdxs,
              decisionPos,
              validPsClone = $.extend(!0, {}, getMaskSet().validPositions),
              isValidRslt = !1,
              lAltPos = getLastValidPosition();
            for (
              prevAltPos = getMaskSet().validPositions[lAltPos];
              lAltPos >= 0;
              lAltPos--
            )
              if (
                (altPos = getMaskSet().validPositions[lAltPos]) &&
                altPos.alternation !== undefined
              ) {
                if (
                  ((lastAlt = lAltPos),
                  (alternation =
                    getMaskSet().validPositions[lastAlt].alternation),
                  prevAltPos.locator[altPos.alternation] !==
                    altPos.locator[altPos.alternation])
                )
                  break;
                prevAltPos = altPos;
              }
            if (alternation !== undefined) {
              decisionPos = parseInt(lastAlt);
              var decisionTaker =
                prevAltPos.locator[prevAltPos.alternation || alternation] !==
                undefined
                  ? prevAltPos.locator[prevAltPos.alternation || alternation]
                  : altNdxs[0];
              decisionTaker.length > 0 &&
                (decisionTaker = decisionTaker.split(",")[0]);
              var possibilityPos = getMaskSet().validPositions[decisionPos],
                prevPos = getMaskSet().validPositions[decisionPos - 1];
              $.each(
                getTests(
                  decisionPos,
                  prevPos ? prevPos.locator : undefined,
                  decisionPos - 1
                ),
                function (ndx, test) {
                  altNdxs = test.locator[alternation]
                    ? test.locator[alternation].toString().split(",")
                    : [];
                  for (var mndx = 0; mndx < altNdxs.length; mndx++) {
                    var validInputs = [],
                      staticInputsBeforePos = 0,
                      staticInputsBeforePosAlternate = 0,
                      verifyValidInput = !1;
                    if (
                      decisionTaker < altNdxs[mndx] &&
                      (test.na === undefined ||
                        -1 === $.inArray(altNdxs[mndx], test.na.split(",")) ||
                        -1 === $.inArray(decisionTaker.toString(), altNdxs))
                    ) {
                      getMaskSet().validPositions[decisionPos] = $.extend(
                        !0,
                        {},
                        test
                      );
                      var possibilities =
                        getMaskSet().validPositions[decisionPos].locator;
                      for (
                        getMaskSet().validPositions[decisionPos].locator[
                          alternation
                        ] = parseInt(altNdxs[mndx]),
                          null == test.match.fn
                            ? (possibilityPos.input !== test.match.def &&
                                ((verifyValidInput = !0),
                                !0 !== possibilityPos.generatedInput &&
                                  validInputs.push(possibilityPos.input)),
                              staticInputsBeforePosAlternate++,
                              (getMaskSet().validPositions[
                                decisionPos
                              ].generatedInput = !/[0-9a-bA-Z]/.test(
                                test.match.def
                              )),
                              (getMaskSet().validPositions[decisionPos].input =
                                test.match.def))
                            : (getMaskSet().validPositions[decisionPos].input =
                                possibilityPos.input),
                          i = decisionPos + 1;
                        i < getLastValidPosition(undefined, !0) + 1;
                        i++
                      )
                        (validPos = getMaskSet().validPositions[i]) &&
                        !0 !== validPos.generatedInput &&
                        /[0-9a-bA-Z]/.test(validPos.input)
                          ? validInputs.push(validPos.input)
                          : i < pos && staticInputsBeforePos++,
                          delete getMaskSet().validPositions[i];
                      for (
                        verifyValidInput &&
                          validInputs[0] === test.match.def &&
                          validInputs.shift(),
                          resetMaskSet(!0),
                          isValidRslt = !0;
                        validInputs.length > 0;

                      ) {
                        var input = validInputs.shift();
                        if (
                          input !== opts.skipOptionalPartCharacter &&
                          !(isValidRslt = isValid(
                            getLastValidPosition(undefined, !0) + 1,
                            input,
                            !1,
                            fromSetValid,
                            !0
                          ))
                        )
                          break;
                      }
                      if (isValidRslt) {
                        getMaskSet().validPositions[decisionPos].locator =
                          possibilities;
                        var targetLvp = getLastValidPosition(pos) + 1;
                        for (
                          i = decisionPos + 1;
                          i < getLastValidPosition() + 1;
                          i++
                        )
                          ((validPos = getMaskSet().validPositions[i]) ===
                            undefined ||
                            null == validPos.match.fn) &&
                            i <
                              pos +
                                (staticInputsBeforePosAlternate -
                                  staticInputsBeforePos) &&
                            staticInputsBeforePosAlternate++;
                        isValidRslt = isValid(
                          (pos +=
                            staticInputsBeforePosAlternate -
                            staticInputsBeforePos) > targetLvp
                            ? targetLvp
                            : pos,
                          c,
                          strict,
                          fromSetValid,
                          !0
                        );
                      }
                      if (isValidRslt) return !1;
                      resetMaskSet(),
                        (getMaskSet().validPositions = $.extend(
                          !0,
                          {},
                          validPsClone
                        ));
                    }
                  }
                }
              );
            }
            return isValidRslt;
          })(maskPos, c, strict)),
          !0 === result &&
            (result = {
              pos: maskPos,
            });
      }
      if (
        $.isFunction(opts.postValidation) &&
        !1 !== result &&
        !strict &&
        !0 !== fromSetValid &&
        !0 !== validateOnly
      ) {
        var postResult = opts.postValidation(getBuffer(!0), result, opts);
        if (postResult.refreshFromBuffer && postResult.buffer) {
          var refresh = postResult.refreshFromBuffer;
          refreshFromBuffer(
            !0 === refresh ? refresh : refresh.start,
            refresh.end,
            postResult.buffer
          );
        }
        result = !0 === postResult ? result : postResult;
      }
      return (
        result && result.pos === undefined && (result.pos = maskPos),
        (!1 !== result && !0 !== validateOnly) ||
          (resetMaskSet(!0),
          (getMaskSet().validPositions = $.extend(!0, {}, positionsClone))),
        result
      );
    }
    function isMask(pos, strict) {
      var test = getTestTemplate(pos).match;
      if (("" === test.def && (test = getTest(pos).match), null != test.fn))
        return test.fn;
      if (!0 !== strict && pos > -1) {
        var tests = getTests(pos);
        return (
          tests.length > 1 + ("" === tests[tests.length - 1].match.def ? 1 : 0)
        );
      }
      return !1;
    }
    function seekNext(pos, newBlock) {
      var maskL = getMaskSet().maskLength;
      if (pos >= maskL) return maskL;
      var position = pos;
      for (
        getTests(maskL + 1).length > 1 &&
        (getMaskTemplate(!0, maskL + 1, !0), (maskL = getMaskSet().maskLength));
        ++position < maskL &&
        ((!0 === newBlock &&
          (!0 !== getTest(position).match.newBlockMarker ||
            !isMask(position))) ||
          (!0 !== newBlock && !isMask(position)));

      );
      return position;
    }
    function seekPrevious(pos, newBlock) {
      var tests,
        position = pos;
      if (position <= 0) return 0;
      for (
        ;
        --position > 0 &&
        ((!0 === newBlock && !0 !== getTest(position).match.newBlockMarker) ||
          (!0 !== newBlock &&
            !isMask(position) &&
            ((tests = getTests(position)).length < 2 ||
              (2 === tests.length && "" === tests[1].match.def))));

      );
      return position;
    }
    function getBufferElement(position) {
      return getMaskSet().validPositions[position] === undefined
        ? getPlaceholder(position)
        : getMaskSet().validPositions[position].input;
    }
    function writeBuffer(input, buffer, caretPos, event, triggerInputEvent) {
      if (event && $.isFunction(opts.onBeforeWrite)) {
        var result = opts.onBeforeWrite.call(
          inputmask,
          event,
          buffer,
          caretPos,
          opts
        );
        if (result) {
          if (result.refreshFromBuffer) {
            var refresh = result.refreshFromBuffer;
            refreshFromBuffer(
              !0 === refresh ? refresh : refresh.start,
              refresh.end,
              result.buffer || buffer
            ),
              (buffer = getBuffer(!0));
          }
          caretPos !== undefined &&
            (caretPos = result.caret !== undefined ? result.caret : caretPos);
        }
      }
      input !== undefined &&
        (input.inputmask._valueSet(buffer.join("")),
        caretPos === undefined || (event !== undefined && "blur" === event.type)
          ? renderColorMask(input, caretPos, 0 === buffer.length)
          : android && event && "input" === event.type
          ? setTimeout(function () {
              caret(input, caretPos);
            }, 0)
          : caret(input, caretPos),
        !0 === triggerInputEvent &&
          ((skipInputEvent = !0), $(input).trigger("input")));
    }
    function getPlaceholder(pos, test, returnPL) {
      if (
        (test = test || getTest(pos).match).placeholder !== undefined ||
        !0 === returnPL
      )
        return $.isFunction(test.placeholder)
          ? test.placeholder(opts)
          : test.placeholder;
      if (null === test.fn) {
        if (pos > -1 && getMaskSet().validPositions[pos] === undefined) {
          var prevTest,
            tests = getTests(pos),
            staticAlternations = [];
          if (
            tests.length >
            1 + ("" === tests[tests.length - 1].match.def ? 1 : 0)
          )
            for (var i = 0; i < tests.length; i++)
              if (
                !0 !== tests[i].match.optionality &&
                !0 !== tests[i].match.optionalQuantifier &&
                (null === tests[i].match.fn ||
                  prevTest === undefined ||
                  !1 !==
                    tests[i].match.fn.test(
                      prevTest.match.def,
                      getMaskSet(),
                      pos,
                      !0,
                      opts
                    )) &&
                (staticAlternations.push(tests[i]),
                null === tests[i].match.fn && (prevTest = tests[i]),
                staticAlternations.length > 1 &&
                  /[0-9a-bA-Z]/.test(staticAlternations[0].match.def))
              )
                return opts.placeholder.charAt(pos % opts.placeholder.length);
        }
        return test.def;
      }
      return opts.placeholder.charAt(pos % opts.placeholder.length);
    }
    function checkVal(input, writeOut, strict, nptvl, initiatingEvent) {
      function isTemplateMatch(ndx, charCodes) {
        return (
          -1 !==
            getBufferTemplate()
              .slice(ndx, seekNext(ndx))
              .join("")
              .indexOf(charCodes) &&
          !isMask(ndx) &&
          getTest(ndx).match.nativeDef ===
            charCodes.charAt(charCodes.length - 1)
        );
      }
      var inputValue = nptvl.slice(),
        charCodes = "",
        initialNdx = -1,
        result = undefined;
      if ((resetMaskSet(), strict || !0 === opts.autoUnmask))
        initialNdx = seekNext(initialNdx);
      else {
        var staticInput = getBufferTemplate().slice(0, seekNext(-1)).join(""),
          matches = inputValue
            .join("")
            .match(new RegExp("^" + Inputmask.escapeRegex(staticInput), "g"));
        matches &&
          matches.length > 0 &&
          (inputValue.splice(0, matches.length * staticInput.length),
          (initialNdx = seekNext(initialNdx)));
      }
      if (
        (-1 === initialNdx
          ? ((getMaskSet().p = seekNext(initialNdx)), (initialNdx = 0))
          : (getMaskSet().p = initialNdx),
        $.each(inputValue, function (ndx, charCode) {
          if (charCode !== undefined)
            if (
              getMaskSet().validPositions[ndx] === undefined &&
              inputValue[ndx] === getPlaceholder(ndx) &&
              isMask(ndx, !0) &&
              !1 === isValid(ndx, inputValue[ndx], !0, undefined, undefined, !0)
            )
              getMaskSet().p++;
            else {
              var keypress = new $.Event("_checkval");
              (keypress.which = charCode.charCodeAt(0)),
                (charCodes += charCode);
              var lvp = getLastValidPosition(undefined, !0),
                lvTest = getMaskSet().validPositions[lvp],
                nextTest = getTestTemplate(
                  lvp + 1,
                  lvTest ? lvTest.locator.slice() : undefined,
                  lvp
                );
              if (
                !isTemplateMatch(initialNdx, charCodes) ||
                strict ||
                opts.autoUnmask
              ) {
                var pos = strict
                  ? ndx
                  : null == nextTest.match.fn &&
                    nextTest.match.optionality &&
                    lvp + 1 < getMaskSet().p
                  ? lvp + 1
                  : getMaskSet().p;
                (result = EventHandlers.keypressEvent.call(
                  input,
                  keypress,
                  !0,
                  !1,
                  strict,
                  pos
                )),
                  (initialNdx = pos + 1),
                  (charCodes = "");
              } else
                result = EventHandlers.keypressEvent.call(
                  input,
                  keypress,
                  !0,
                  !1,
                  !0,
                  lvp + 1
                );
              if (
                !1 !== result &&
                !strict &&
                $.isFunction(opts.onBeforeWrite)
              ) {
                var origResult = result;
                if (
                  ((result = opts.onBeforeWrite.call(
                    inputmask,
                    keypress,
                    getBuffer(),
                    result.forwardPosition,
                    opts
                  )),
                  (result = $.extend(origResult, result)) &&
                    result.refreshFromBuffer)
                ) {
                  var refresh = result.refreshFromBuffer;
                  refreshFromBuffer(
                    !0 === refresh ? refresh : refresh.start,
                    refresh.end,
                    result.buffer
                  ),
                    resetMaskSet(!0),
                    result.caret &&
                      ((getMaskSet().p = result.caret),
                      (result.forwardPosition = result.caret));
                }
              }
            }
        }),
        writeOut)
      ) {
        var caretPos = undefined;
        document.activeElement === input &&
          result &&
          (caretPos = opts.numericInput
            ? seekPrevious(result.forwardPosition)
            : result.forwardPosition),
          writeBuffer(
            input,
            getBuffer(),
            caretPos,
            initiatingEvent || new $.Event("checkval"),
            initiatingEvent && "input" === initiatingEvent.type
          );
      }
    }
    function unmaskedvalue(input) {
      if (input) {
        if (input.inputmask === undefined) return input.value;
        input.inputmask &&
          input.inputmask.refreshValue &&
          EventHandlers.setValueEvent.call(input);
      }
      var umValue = [],
        vps = getMaskSet().validPositions;
      for (var pndx in vps)
        vps[pndx].match &&
          null != vps[pndx].match.fn &&
          umValue.push(vps[pndx].input);
      var unmaskedValue =
        0 === umValue.length
          ? ""
          : (isRTL ? umValue.reverse() : umValue).join("");
      if ($.isFunction(opts.onUnMask)) {
        var bufferValue = (
          isRTL ? getBuffer().slice().reverse() : getBuffer()
        ).join("");
        unmaskedValue = opts.onUnMask.call(
          inputmask,
          bufferValue,
          unmaskedValue,
          opts
        );
      }
      return unmaskedValue;
    }
    function caret(input, begin, end, notranslate) {
      function translatePosition(pos) {
        return (
          !0 === notranslate ||
            !isRTL ||
            "number" != typeof pos ||
            (opts.greedy && "" === opts.placeholder) ||
            (pos = getBuffer().join("").length - pos),
          pos
        );
      }
      var range;
      if (begin === undefined)
        return (
          input.setSelectionRange
            ? ((begin = input.selectionStart), (end = input.selectionEnd))
            : window.getSelection
            ? ((range = window.getSelection().getRangeAt(0))
                .commonAncestorContainer.parentNode !== input &&
                range.commonAncestorContainer !== input) ||
              ((begin = range.startOffset), (end = range.endOffset))
            : document.selection &&
              document.selection.createRange &&
              (end =
                (begin =
                  0 -
                  (range = document.selection.createRange())
                    .duplicate()
                    .moveStart(
                      "character",
                      -input.inputmask._valueGet().length
                    )) + range.text.length),
          {
            begin: translatePosition(begin),
            end: translatePosition(end),
          }
        );
      if (
        (begin.begin !== undefined &&
          ((end = begin.end), (begin = begin.begin)),
        "number" == typeof begin)
      ) {
        (begin = translatePosition(begin)),
          (end =
            "number" == typeof (end = translatePosition(end)) ? end : begin);
        var scrollCalc =
          parseInt(
            ((input.ownerDocument.defaultView || window).getComputedStyle
              ? (input.ownerDocument.defaultView || window).getComputedStyle(
                  input,
                  null
                )
              : input.currentStyle
            ).fontSize
          ) * end;
        if (
          ((input.scrollLeft = scrollCalc > input.scrollWidth ? scrollCalc : 0),
          mobile || !1 !== opts.insertMode || begin !== end || end++,
          input.setSelectionRange)
        )
          (input.selectionStart = begin), (input.selectionEnd = end);
        else if (window.getSelection) {
          if (
            ((range = document.createRange()),
            input.firstChild === undefined || null === input.firstChild)
          ) {
            var textNode = document.createTextNode("");
            input.appendChild(textNode);
          }
          range.setStart(
            input.firstChild,
            begin < input.inputmask._valueGet().length
              ? begin
              : input.inputmask._valueGet().length
          ),
            range.setEnd(
              input.firstChild,
              end < input.inputmask._valueGet().length
                ? end
                : input.inputmask._valueGet().length
            ),
            range.collapse(!0);
          var sel = window.getSelection();
          sel.removeAllRanges(), sel.addRange(range);
        } else
          input.createTextRange &&
            ((range = input.createTextRange()).collapse(!0),
            range.moveEnd("character", end),
            range.moveStart("character", begin),
            range.select());
        renderColorMask(input, {
          begin: begin,
          end: end,
        });
      }
    }
    function determineLastRequiredPosition(returnDefinition) {
      var pos,
        testPos,
        buffer = getBuffer(),
        bl = buffer.length,
        lvp = getLastValidPosition(),
        positions = {},
        lvTest = getMaskSet().validPositions[lvp],
        ndxIntlzr = lvTest !== undefined ? lvTest.locator.slice() : undefined;
      for (pos = lvp + 1; pos < buffer.length; pos++)
        (ndxIntlzr = (testPos = getTestTemplate(
          pos,
          ndxIntlzr,
          pos - 1
        )).locator.slice()),
          (positions[pos] = $.extend(!0, {}, testPos));
      var lvTestAlt =
        lvTest && lvTest.alternation !== undefined
          ? lvTest.locator[lvTest.alternation]
          : undefined;
      for (
        pos = bl - 1;
        pos > lvp &&
        ((testPos = positions[pos]).match.optionality ||
          (testPos.match.optionalQuantifier && testPos.match.newBlockMarker) ||
          (lvTestAlt &&
            ((lvTestAlt !== positions[pos].locator[lvTest.alternation] &&
              null != testPos.match.fn) ||
              (null === testPos.match.fn &&
                testPos.locator[lvTest.alternation] &&
                checkAlternationMatch(
                  testPos.locator[lvTest.alternation].toString().split(","),
                  lvTestAlt.toString().split(",")
                ) &&
                "" !== getTests(pos)[0].def)))) &&
        buffer[pos] === getPlaceholder(pos, testPos.match);
        pos--
      )
        bl--;
      return returnDefinition
        ? {
            l: bl,
            def: positions[bl] ? positions[bl].match : undefined,
          }
        : bl;
    }
    function clearOptionalTail(buffer) {
      for (
        var validPos,
          rl = determineLastRequiredPosition(),
          bl = buffer.length,
          lv = getMaskSet().validPositions[getLastValidPosition()];
        rl < bl &&
        !isMask(rl, !0) &&
        (validPos =
          lv !== undefined
            ? getTestTemplate(rl, lv.locator.slice(""), lv)
            : getTest(rl)) &&
        !0 !== validPos.match.optionality &&
        ((!0 !== validPos.match.optionalQuantifier &&
          !0 !== validPos.match.newBlockMarker) ||
          (rl + 1 === bl &&
            "" ===
              (lv !== undefined
                ? getTestTemplate(rl + 1, lv.locator.slice(""), lv)
                : getTest(rl + 1)
              ).match.def));

      )
        rl++;
      for (
        ;
        (validPos = getMaskSet().validPositions[rl - 1]) &&
        validPos &&
        validPos.match.optionality &&
        validPos.input === opts.skipOptionalPartCharacter;

      )
        rl--;
      return buffer.splice(rl), buffer;
    }
    function isComplete(buffer) {
      if ($.isFunction(opts.isComplete)) return opts.isComplete(buffer, opts);
      if ("*" === opts.repeat) return undefined;
      var complete = !1,
        lrp = determineLastRequiredPosition(!0),
        aml = seekPrevious(lrp.l);
      if (
        lrp.def === undefined ||
        lrp.def.newBlockMarker ||
        lrp.def.optionality ||
        lrp.def.optionalQuantifier
      ) {
        complete = !0;
        for (var i = 0; i <= aml; i++) {
          var test = getTestTemplate(i).match;
          if (
            (null !== test.fn &&
              getMaskSet().validPositions[i] === undefined &&
              !0 !== test.optionality &&
              !0 !== test.optionalQuantifier) ||
            (null === test.fn && buffer[i] !== getPlaceholder(i, test))
          ) {
            complete = !1;
            break;
          }
        }
      }
      return complete;
    }
    function handleRemove(input, k, pos, strict, fromIsValid) {
      if (
        (opts.numericInput || isRTL) &&
        (k === Inputmask.keyCode.BACKSPACE
          ? (k = Inputmask.keyCode.DELETE)
          : k === Inputmask.keyCode.DELETE && (k = Inputmask.keyCode.BACKSPACE),
        isRTL)
      ) {
        var pend = pos.end;
        (pos.end = pos.begin), (pos.begin = pend);
      }
      k === Inputmask.keyCode.BACKSPACE &&
      (pos.end - pos.begin < 1 || !1 === opts.insertMode)
        ? ((pos.begin = seekPrevious(pos.begin)),
          getMaskSet().validPositions[pos.begin] !== undefined &&
            getMaskSet().validPositions[pos.begin].input ===
              opts.groupSeparator &&
            pos.begin--)
        : k === Inputmask.keyCode.DELETE &&
          pos.begin === pos.end &&
          ((pos.end =
            isMask(pos.end, !0) &&
            getMaskSet().validPositions[pos.end] &&
            getMaskSet().validPositions[pos.end].input !== opts.radixPoint
              ? pos.end + 1
              : seekNext(pos.end) + 1),
          getMaskSet().validPositions[pos.begin] !== undefined &&
            getMaskSet().validPositions[pos.begin].input ===
              opts.groupSeparator &&
            pos.end++),
        stripValidPositions(pos.begin, pos.end, !1, strict),
        !0 !== strict &&
          (function () {
            if (opts.keepStatic) {
              for (
                var validInputs = [],
                  lastAlt = getLastValidPosition(-1, !0),
                  positionsClone = $.extend(
                    !0,
                    {},
                    getMaskSet().validPositions
                  ),
                  prevAltPos = getMaskSet().validPositions[lastAlt];
                lastAlt >= 0;
                lastAlt--
              ) {
                var altPos = getMaskSet().validPositions[lastAlt];
                if (altPos) {
                  if (
                    (!0 !== altPos.generatedInput &&
                      /[0-9a-bA-Z]/.test(altPos.input) &&
                      validInputs.push(altPos.input),
                    delete getMaskSet().validPositions[lastAlt],
                    altPos.alternation !== undefined &&
                      altPos.locator[altPos.alternation] !==
                        prevAltPos.locator[altPos.alternation])
                  )
                    break;
                  prevAltPos = altPos;
                }
              }
              if (lastAlt > -1)
                for (
                  getMaskSet().p = seekNext(getLastValidPosition(-1, !0));
                  validInputs.length > 0;

                ) {
                  var keypress = new $.Event("keypress");
                  (keypress.which = validInputs.pop().charCodeAt(0)),
                    EventHandlers.keypressEvent.call(
                      input,
                      keypress,
                      !0,
                      !1,
                      !1,
                      getMaskSet().p
                    );
                }
              else
                getMaskSet().validPositions = $.extend(!0, {}, positionsClone);
            }
          })();
      var lvp = getLastValidPosition(pos.begin, !0);
      if (lvp < pos.begin) getMaskSet().p = seekNext(lvp);
      else if (
        !0 !== strict &&
        ((getMaskSet().p = pos.begin), !0 !== fromIsValid)
      )
        for (
          ;
          getMaskSet().p < lvp &&
          getMaskSet().validPositions[getMaskSet().p] === undefined;

        )
          getMaskSet().p++;
    }
    function initializeColorMask(input) {
      function findCaretPos(clientx) {
        var caretPos,
          e = document.createElement("span");
        for (var style in computedStyle)
          isNaN(style) &&
            -1 !== style.indexOf("font") &&
            (e.style[style] = computedStyle[style]);
        (e.style.textTransform = computedStyle.textTransform),
          (e.style.letterSpacing = computedStyle.letterSpacing),
          (e.style.position = "absolute"),
          (e.style.height = "auto"),
          (e.style.width = "auto"),
          (e.style.visibility = "hidden"),
          (e.style.whiteSpace = "nowrap"),
          document.body.appendChild(e);
        var itl,
          inputText = input.inputmask._valueGet(),
          previousWidth = 0;
        for (
          caretPos = 0, itl = inputText.length;
          caretPos <= itl;
          caretPos++
        ) {
          if (
            ((e.innerHTML += inputText.charAt(caretPos) || "_"),
            e.offsetWidth >= clientx)
          ) {
            var offset1 = clientx - previousWidth,
              offset2 = e.offsetWidth - clientx;
            (e.innerHTML = inputText.charAt(caretPos)),
              (caretPos =
                (offset1 -= e.offsetWidth / 3) < offset2
                  ? caretPos - 1
                  : caretPos);
            break;
          }
          previousWidth = e.offsetWidth;
        }
        return document.body.removeChild(e), caretPos;
      }
      var computedStyle = (
          input.ownerDocument.defaultView || window
        ).getComputedStyle(input, null),
        template = document.createElement("div");
      (template.style.width = computedStyle.width),
        (template.style.textAlign = computedStyle.textAlign),
        ((colorMask = document.createElement("div")).className =
          "im-colormask"),
        input.parentNode.insertBefore(colorMask, input),
        input.parentNode.removeChild(input),
        colorMask.appendChild(template),
        colorMask.appendChild(input),
        (input.style.left = template.offsetLeft + "px"),
        $(input).on("click", function (e) {
          return (
            caret(input, findCaretPos(e.clientX)),
            EventHandlers.clickEvent.call(input, [e])
          );
        }),
        $(input).on("keydown", function (e) {
          e.shiftKey ||
            !1 === opts.insertMode ||
            setTimeout(function () {
              renderColorMask(input);
            }, 0);
        });
    }
    function renderColorMask(input, caretPos, clear) {
      function handleStatic() {
        isStatic || (null !== test.fn && testPos.input !== undefined)
          ? isStatic &&
            ((null !== test.fn && testPos.input !== undefined) ||
              "" === test.def) &&
            ((isStatic = !1), (maskTemplate += "</span>"))
          : ((isStatic = !0), (maskTemplate += "<span class='im-static'>"));
      }
      function handleCaret(force) {
        (!0 !== force && pos !== caretPos.begin) ||
          document.activeElement !== input ||
          (maskTemplate +=
            "<span class='im-caret' style='border-right-width: 1px;border-right-style: solid;'></span>");
      }
      var test,
        testPos,
        ndxIntlzr,
        maskTemplate = "",
        isStatic = !1,
        pos = 0;
      if (colorMask !== undefined) {
        var buffer = getBuffer();
        if (
          (caretPos === undefined
            ? (caretPos = caret(input))
            : caretPos.begin === undefined &&
              (caretPos = {
                begin: caretPos,
                end: caretPos,
              }),
          !0 !== clear)
        ) {
          var lvp = getLastValidPosition();
          do {
            handleCaret(),
              getMaskSet().validPositions[pos]
                ? ((testPos = getMaskSet().validPositions[pos]),
                  (test = testPos.match),
                  (ndxIntlzr = testPos.locator.slice()),
                  handleStatic(),
                  (maskTemplate += buffer[pos]))
                : ((testPos = getTestTemplate(pos, ndxIntlzr, pos - 1)),
                  (test = testPos.match),
                  (ndxIntlzr = testPos.locator.slice()),
                  (!1 === opts.jitMasking ||
                    pos < lvp ||
                    ("number" == typeof opts.jitMasking &&
                      isFinite(opts.jitMasking) &&
                      opts.jitMasking > pos)) &&
                    (handleStatic(),
                    (maskTemplate += getPlaceholder(pos, test)))),
              pos++;
          } while (
            ((maxLength === undefined || pos < maxLength) &&
              (null !== test.fn || "" !== test.def)) ||
            lvp > pos ||
            isStatic
          );
          -1 === maskTemplate.indexOf("im-caret") && handleCaret(!0),
            isStatic && handleStatic();
        }
        var template = colorMask.getElementsByTagName("div")[0];
        (template.innerHTML = maskTemplate),
          input.inputmask.positionColorMask(input, template);
      }
    }
    (maskset = maskset || this.maskset), (opts = opts || this.opts);
    var undoValue,
      $el,
      maxLength,
      colorMask,
      inputmask = this,
      el = this.el,
      isRTL = this.isRTL,
      skipKeyPressEvent = !1,
      skipInputEvent = !1,
      ignorable = !1,
      mouseEnter = !1,
      EventRuler = {
        on: function (input, eventName, eventHandler) {
          var ev = function (e) {
            if (this.inputmask === undefined && "FORM" !== this.nodeName) {
              var imOpts = $.data(this, "_inputmask_opts");
              imOpts ? new Inputmask(imOpts).mask(this) : EventRuler.off(this);
            } else {
              if (
                "setvalue" === e.type ||
                "FORM" === this.nodeName ||
                !(
                  this.disabled ||
                  (this.readOnly &&
                    !(
                      ("keydown" === e.type && e.ctrlKey && 67 === e.keyCode) ||
                      (!1 === opts.tabThrough &&
                        e.keyCode === Inputmask.keyCode.TAB)
                    ))
                )
              ) {
                switch (e.type) {
                  case "input":
                    if (!0 === skipInputEvent)
                      return (skipInputEvent = !1), e.preventDefault();
                    break;

                  case "keydown":
                    (skipKeyPressEvent = !1), (skipInputEvent = !1);
                    break;

                  case "keypress":
                    if (!0 === skipKeyPressEvent) return e.preventDefault();
                    skipKeyPressEvent = !0;
                    break;

                  case "click":
                    if (iemobile || iphone) {
                      var that = this,
                        args = arguments;
                      return (
                        setTimeout(function () {
                          eventHandler.apply(that, args);
                        }, 0),
                        !1
                      );
                    }
                }
                var returnVal = eventHandler.apply(this, arguments);
                return (
                  !1 === returnVal && (e.preventDefault(), e.stopPropagation()),
                  returnVal
                );
              }
              e.preventDefault();
            }
          };
          (input.inputmask.events[eventName] =
            input.inputmask.events[eventName] || []),
            input.inputmask.events[eventName].push(ev),
            -1 !== $.inArray(eventName, ["submit", "reset"])
              ? null !== input.form && $(input.form).on(eventName, ev)
              : $(input).on(eventName, ev);
        },
        off: function (input, event) {
          if (input.inputmask && input.inputmask.events) {
            var events;
            event
              ? ((events = [])[event] = input.inputmask.events[event])
              : (events = input.inputmask.events),
              $.each(events, function (eventName, evArr) {
                for (; evArr.length > 0; ) {
                  var ev = evArr.pop();
                  -1 !== $.inArray(eventName, ["submit", "reset"])
                    ? null !== input.form && $(input.form).off(eventName, ev)
                    : $(input).off(eventName, ev);
                }
                delete input.inputmask.events[eventName];
              });
          }
        },
      },
      EventHandlers = {
        keydownEvent: function (e) {
          var input = this,
            $input = $(input),
            k = e.keyCode,
            pos = caret(input);
          if (
            k === Inputmask.keyCode.BACKSPACE ||
            k === Inputmask.keyCode.DELETE ||
            (iphone && k === Inputmask.keyCode.BACKSPACE_SAFARI) ||
            (e.ctrlKey &&
              k === Inputmask.keyCode.X &&
              !(function (eventName) {
                var el = document.createElement("input"),
                  evName = "on" + eventName,
                  isSupported = evName in el;
                return (
                  isSupported ||
                    (el.setAttribute(evName, "return;"),
                    (isSupported = "function" == typeof el[evName])),
                  (el = null),
                  isSupported
                );
              })("cut"))
          )
            e.preventDefault(),
              handleRemove(input, k, pos),
              writeBuffer(
                input,
                getBuffer(!0),
                getMaskSet().p,
                e,
                input.inputmask._valueGet() !== getBuffer().join("")
              ),
              input.inputmask._valueGet() === getBufferTemplate().join("")
                ? $input.trigger("cleared")
                : !0 === isComplete(getBuffer()) && $input.trigger("complete");
          else if (
            k === Inputmask.keyCode.END ||
            k === Inputmask.keyCode.PAGE_DOWN
          ) {
            e.preventDefault();
            var caretPos = seekNext(getLastValidPosition());
            opts.insertMode ||
              caretPos !== getMaskSet().maskLength ||
              e.shiftKey ||
              caretPos--,
              caret(input, e.shiftKey ? pos.begin : caretPos, caretPos, !0);
          } else
            (k === Inputmask.keyCode.HOME && !e.shiftKey) ||
            k === Inputmask.keyCode.PAGE_UP
              ? (e.preventDefault(),
                caret(input, 0, e.shiftKey ? pos.begin : 0, !0))
              : ((opts.undoOnEscape && k === Inputmask.keyCode.ESCAPE) ||
                  (90 === k && e.ctrlKey)) &&
                !0 !== e.altKey
              ? (checkVal(input, !0, !1, undoValue.split("")),
                $input.trigger("click"))
              : k !== Inputmask.keyCode.INSERT || e.shiftKey || e.ctrlKey
              ? !0 === opts.tabThrough && k === Inputmask.keyCode.TAB
                ? (!0 === e.shiftKey
                    ? (null === getTest(pos.begin).match.fn &&
                        (pos.begin = seekNext(pos.begin)),
                      (pos.end = seekPrevious(pos.begin, !0)),
                      (pos.begin = seekPrevious(pos.end, !0)))
                    : ((pos.begin = seekNext(pos.begin, !0)),
                      (pos.end = seekNext(pos.begin, !0)),
                      pos.end < getMaskSet().maskLength && pos.end--),
                  pos.begin < getMaskSet().maskLength &&
                    (e.preventDefault(), caret(input, pos.begin, pos.end)))
                : e.shiftKey ||
                  (!1 === opts.insertMode &&
                    (k === Inputmask.keyCode.RIGHT
                      ? setTimeout(function () {
                          var caretPos = caret(input);
                          caret(input, caretPos.begin);
                        }, 0)
                      : k === Inputmask.keyCode.LEFT &&
                        setTimeout(function () {
                          var caretPos = caret(input);
                          caret(
                            input,
                            isRTL ? caretPos.begin + 1 : caretPos.begin - 1
                          );
                        }, 0)))
              : ((opts.insertMode = !opts.insertMode),
                caret(
                  input,
                  opts.insertMode || pos.begin !== getMaskSet().maskLength
                    ? pos.begin
                    : pos.begin - 1
                ));
          opts.onKeyDown.call(this, e, getBuffer(), caret(input).begin, opts),
            (ignorable = -1 !== $.inArray(k, opts.ignorables));
        },
        keypressEvent: function (e, checkval, writeOut, strict, ndx) {
          var input = this,
            $input = $(input),
            k = e.which || e.charCode || e.keyCode;
          if (
            !(!0 === checkval || (e.ctrlKey && e.altKey)) &&
            (e.ctrlKey || e.metaKey || ignorable)
          )
            return (
              k === Inputmask.keyCode.ENTER &&
                undoValue !== getBuffer().join("") &&
                ((undoValue = getBuffer().join("")),
                setTimeout(function () {
                  $input.trigger("change");
                }, 0)),
              !0
            );
          if (k) {
            46 === k &&
              !1 === e.shiftKey &&
              "" !== opts.radixPoint &&
              (k = opts.radixPoint.charCodeAt(0));
            var forwardPosition,
              pos = checkval
                ? {
                    begin: ndx,
                    end: ndx,
                  }
                : caret(input),
              c = String.fromCharCode(k);
            getMaskSet().writeOutBuffer = !0;
            var valResult = isValid(pos, c, strict);
            if (
              (!1 !== valResult &&
                (resetMaskSet(!0),
                (forwardPosition =
                  valResult.caret !== undefined
                    ? valResult.caret
                    : checkval
                    ? valResult.pos + 1
                    : seekNext(valResult.pos)),
                (getMaskSet().p = forwardPosition)),
              !1 !== writeOut &&
                (setTimeout(function () {
                  opts.onKeyValidation.call(input, k, valResult, opts);
                }, 0),
                getMaskSet().writeOutBuffer && !1 !== valResult))
            ) {
              var buffer = getBuffer();
              writeBuffer(
                input,
                buffer,
                opts.numericInput && valResult.caret === undefined
                  ? seekPrevious(forwardPosition)
                  : forwardPosition,
                e,
                !0 !== checkval
              ),
                !0 !== checkval &&
                  setTimeout(function () {
                    !0 === isComplete(buffer) && $input.trigger("complete");
                  }, 0);
            }
            if ((e.preventDefault(), checkval))
              return (
                !1 !== valResult &&
                  (valResult.forwardPosition = forwardPosition),
                valResult
              );
          }
        },
        pasteEvent: function (e) {
          var tempValue,
            input = this,
            ev = e.originalEvent || e,
            $input = $(input),
            inputValue = input.inputmask._valueGet(!0),
            caretPos = caret(input);
          isRTL &&
            ((tempValue = caretPos.end),
            (caretPos.end = caretPos.begin),
            (caretPos.begin = tempValue));
          var valueBeforeCaret = inputValue.substr(0, caretPos.begin),
            valueAfterCaret = inputValue.substr(
              caretPos.end,
              inputValue.length
            );
          if (
            (valueBeforeCaret ===
              (isRTL ? getBufferTemplate().reverse() : getBufferTemplate())
                .slice(0, caretPos.begin)
                .join("") && (valueBeforeCaret = ""),
            valueAfterCaret ===
              (isRTL ? getBufferTemplate().reverse() : getBufferTemplate())
                .slice(caretPos.end)
                .join("") && (valueAfterCaret = ""),
            isRTL &&
              ((tempValue = valueBeforeCaret),
              (valueBeforeCaret = valueAfterCaret),
              (valueAfterCaret = tempValue)),
            window.clipboardData && window.clipboardData.getData)
          )
            inputValue =
              valueBeforeCaret +
              window.clipboardData.getData("Text") +
              valueAfterCaret;
          else {
            if (!ev.clipboardData || !ev.clipboardData.getData) return !0;
            inputValue =
              valueBeforeCaret +
              ev.clipboardData.getData("text/plain") +
              valueAfterCaret;
          }
          var pasteValue = inputValue;
          if ($.isFunction(opts.onBeforePaste)) {
            if (
              !1 ===
              (pasteValue = opts.onBeforePaste.call(
                inputmask,
                inputValue,
                opts
              ))
            )
              return e.preventDefault();
            pasteValue || (pasteValue = inputValue);
          }
          return (
            checkVal(
              input,
              !1,
              !1,
              isRTL
                ? pasteValue.split("").reverse()
                : pasteValue.toString().split("")
            ),
            writeBuffer(
              input,
              getBuffer(),
              seekNext(getLastValidPosition()),
              e,
              undoValue !== getBuffer().join("")
            ),
            !0 === isComplete(getBuffer()) && $input.trigger("complete"),
            e.preventDefault()
          );
        },
        inputFallBackEvent: function (e) {
          var input = this,
            inputValue = input.inputmask._valueGet();
          if (getBuffer().join("") !== inputValue) {
            var caretPos = caret(input);
            if (
              !1 ===
              (function (input, inputValue, caretPos) {
                if (
                  ("." === inputValue.charAt(caretPos.begin - 1) &&
                    "" !== opts.radixPoint &&
                    (((inputValue = inputValue.split(""))[caretPos.begin - 1] =
                      opts.radixPoint.charAt(0)),
                    (inputValue = inputValue.join(""))),
                  inputValue.charAt(caretPos.begin - 1) === opts.radixPoint &&
                    inputValue.length > getBuffer().length)
                ) {
                  var keypress = new $.Event("keypress");
                  return (
                    (keypress.which = opts.radixPoint.charCodeAt(0)),
                    EventHandlers.keypressEvent.call(
                      input,
                      keypress,
                      !0,
                      !0,
                      !1,
                      caretPos.begin - 1
                    ),
                    !1
                  );
                }
              })(input, inputValue, caretPos)
            )
              return !1;
            if (
              ((inputValue = inputValue.replace(
                new RegExp(
                  "(" +
                    Inputmask.escapeRegex(getBufferTemplate().join("")) +
                    ")*"
                ),
                ""
              )),
              !1 ===
                (function (input, inputValue, caretPos) {
                  if (iemobile) {
                    var inputChar = inputValue.replace(
                      getBuffer().join(""),
                      ""
                    );
                    if (1 === inputChar.length) {
                      var keypress = new $.Event("keypress");
                      return (
                        (keypress.which = inputChar.charCodeAt(0)),
                        EventHandlers.keypressEvent.call(
                          input,
                          keypress,
                          !0,
                          !0,
                          !1,
                          getMaskSet().validPositions[caretPos.begin - 1]
                            ? caretPos.begin
                            : caretPos.begin - 1
                        ),
                        !1
                      );
                    }
                  }
                })(input, inputValue, caretPos))
            )
              return !1;
            caretPos.begin > inputValue.length &&
              (caret(input, inputValue.length), (caretPos = caret(input)));
            var buffer = getBuffer().join(""),
              frontPart = inputValue.substr(0, caretPos.begin),
              backPart = inputValue.substr(caretPos.begin),
              frontBufferPart = buffer.substr(0, caretPos.begin),
              backBufferPart = buffer.substr(caretPos.begin),
              selection = caretPos,
              entries = "",
              isEntry = !1;
            if (frontPart !== frontBufferPart) {
              selection.begin = 0;
              for (
                var fpl = (isEntry = frontPart.length >= frontBufferPart.length)
                    ? frontPart.length
                    : frontBufferPart.length,
                  i = 0;
                frontPart.charAt(i) === frontBufferPart.charAt(i) && i < fpl;
                i++
              )
                selection.begin++;
              isEntry &&
                (entries += frontPart.slice(selection.begin, selection.end));
            }
            backPart !== backBufferPart &&
              (backPart.length > backBufferPart.length
                ? isEntry && (selection.end = selection.begin)
                : backPart.length < backBufferPart.length
                ? (selection.end += backBufferPart.length - backPart.length)
                : backPart.charAt(0) !== backBufferPart.charAt(0) &&
                  selection.end++),
              writeBuffer(input, getBuffer(), selection),
              entries.length > 0
                ? $.each(entries.split(""), function (ndx, entry) {
                    var keypress = new $.Event("keypress");
                    (keypress.which = entry.charCodeAt(0)),
                      (ignorable = !1),
                      EventHandlers.keypressEvent.call(input, keypress);
                  })
                : (selection.begin === selection.end - 1 &&
                    caret(
                      input,
                      seekPrevious(selection.begin + 1),
                      selection.end
                    ),
                  (e.keyCode = Inputmask.keyCode.DELETE),
                  EventHandlers.keydownEvent.call(input, e)),
              e.preventDefault();
          }
        },
        setValueEvent: function (e) {
          this.inputmask.refreshValue = !1;
          var input = this,
            value = input.inputmask._valueGet(!0);
          $.isFunction(opts.onBeforeMask) &&
            (value = opts.onBeforeMask.call(inputmask, value, opts) || value),
            (value = value.split("")),
            checkVal(input, !0, !1, isRTL ? value.reverse() : value),
            (undoValue = getBuffer().join("")),
            (opts.clearMaskOnLostFocus || opts.clearIncomplete) &&
              input.inputmask._valueGet() === getBufferTemplate().join("") &&
              input.inputmask._valueSet("");
        },
        focusEvent: function (e) {
          var input = this,
            nptValue = input.inputmask._valueGet();
          opts.showMaskOnFocus &&
            (!opts.showMaskOnHover ||
              (opts.showMaskOnHover && "" === nptValue)) &&
            (input.inputmask._valueGet() !== getBuffer().join("")
              ? writeBuffer(
                  input,
                  getBuffer(),
                  seekNext(getLastValidPosition())
                )
              : !1 === mouseEnter &&
                caret(input, seekNext(getLastValidPosition()))),
            !0 === opts.positionCaretOnTab &&
              !1 === mouseEnter &&
              "" !== nptValue &&
              (writeBuffer(input, getBuffer(), caret(input)),
              EventHandlers.clickEvent.apply(input, [e, !0])),
            (undoValue = getBuffer().join(""));
        },
        mouseleaveEvent: function (e) {
          var input = this;
          if (
            ((mouseEnter = !1),
            opts.clearMaskOnLostFocus && document.activeElement !== input)
          ) {
            var buffer = getBuffer().slice(),
              nptValue = input.inputmask._valueGet();
            nptValue !== input.getAttribute("placeholder") &&
              "" !== nptValue &&
              (-1 === getLastValidPosition() &&
              nptValue === getBufferTemplate().join("")
                ? (buffer = [])
                : clearOptionalTail(buffer),
              writeBuffer(input, buffer));
          }
        },
        clickEvent: function (e, tabbed) {
          function doRadixFocus(clickPos) {
            if ("" !== opts.radixPoint) {
              var vps = getMaskSet().validPositions;
              if (
                vps[clickPos] === undefined ||
                vps[clickPos].input === getPlaceholder(clickPos)
              ) {
                if (clickPos < seekNext(-1)) return !0;
                var radixPos = $.inArray(opts.radixPoint, getBuffer());
                if (-1 !== radixPos) {
                  for (var vp in vps)
                    if (radixPos < vp && vps[vp].input !== getPlaceholder(vp))
                      return !1;
                  return !0;
                }
              }
            }
            return !1;
          }
          var input = this;
          setTimeout(function () {
            if (document.activeElement === input) {
              var selectedCaret = caret(input);
              if (
                (tabbed &&
                  (isRTL
                    ? (selectedCaret.end = selectedCaret.begin)
                    : (selectedCaret.begin = selectedCaret.end)),
                selectedCaret.begin === selectedCaret.end)
              )
                switch (opts.positionCaretOnClick) {
                  case "none":
                    break;

                  case "radixFocus":
                    if (doRadixFocus(selectedCaret.begin)) {
                      var radixPos = getBuffer()
                        .join("")
                        .indexOf(opts.radixPoint);
                      caret(
                        input,
                        opts.numericInput ? seekNext(radixPos) : radixPos
                      );
                      break;
                    }

                  default:
                    var clickPosition = selectedCaret.begin,
                      lvclickPosition = getLastValidPosition(clickPosition, !0),
                      lastPosition = seekNext(lvclickPosition);
                    if (clickPosition < lastPosition)
                      caret(
                        input,
                        isMask(clickPosition, !0) ||
                          isMask(clickPosition - 1, !0)
                          ? clickPosition
                          : seekNext(clickPosition)
                      );
                    else {
                      var lvp = getMaskSet().validPositions[lvclickPosition],
                        tt = getTestTemplate(
                          lastPosition,
                          lvp ? lvp.match.locator : undefined,
                          lvp
                        ),
                        placeholder = getPlaceholder(lastPosition, tt.match);
                      if (
                        ("" !== placeholder &&
                          getBuffer()[lastPosition] !== placeholder &&
                          !0 !== tt.match.optionalQuantifier &&
                          !0 !== tt.match.newBlockMarker) ||
                        (!isMask(lastPosition, !0) &&
                          tt.match.def === placeholder)
                      ) {
                        var newPos = seekNext(lastPosition);
                        (clickPosition >= newPos ||
                          clickPosition === lastPosition) &&
                          (lastPosition = newPos);
                      }
                      caret(input, lastPosition);
                    }
                }
            }
          }, 0);
        },
        dblclickEvent: function (e) {
          var input = this;
          setTimeout(function () {
            caret(input, 0, seekNext(getLastValidPosition()));
          }, 0);
        },
        cutEvent: function (e) {
          var input = this,
            $input = $(input),
            pos = caret(input),
            ev = e.originalEvent || e,
            clipboardData = window.clipboardData || ev.clipboardData,
            clipData = isRTL
              ? getBuffer().slice(pos.end, pos.begin)
              : getBuffer().slice(pos.begin, pos.end);
          clipboardData.setData(
            "text",
            isRTL ? clipData.reverse().join("") : clipData.join("")
          ),
            document.execCommand && document.execCommand("copy"),
            handleRemove(input, Inputmask.keyCode.DELETE, pos),
            writeBuffer(
              input,
              getBuffer(),
              getMaskSet().p,
              e,
              undoValue !== getBuffer().join("")
            ),
            input.inputmask._valueGet() === getBufferTemplate().join("") &&
              $input.trigger("cleared");
        },
        blurEvent: function (e) {
          var $input = $(this),
            input = this;
          if (input.inputmask) {
            var nptValue = input.inputmask._valueGet(),
              buffer = getBuffer().slice();
            "" !== nptValue &&
              (opts.clearMaskOnLostFocus &&
                (-1 === getLastValidPosition() &&
                nptValue === getBufferTemplate().join("")
                  ? (buffer = [])
                  : clearOptionalTail(buffer)),
              !1 === isComplete(buffer) &&
                (setTimeout(function () {
                  $input.trigger("incomplete");
                }, 0),
                opts.clearIncomplete &&
                  (resetMaskSet(),
                  (buffer = opts.clearMaskOnLostFocus
                    ? []
                    : getBufferTemplate().slice()))),
              writeBuffer(input, buffer, undefined, e)),
              undoValue !== getBuffer().join("") &&
                ((undoValue = buffer.join("")), $input.trigger("change"));
          }
        },
        mouseenterEvent: function (e) {
          var input = this;
          (mouseEnter = !0),
            document.activeElement !== input &&
              opts.showMaskOnHover &&
              input.inputmask._valueGet() !== getBuffer().join("") &&
              writeBuffer(input, getBuffer());
        },
        submitEvent: function (e) {
          undoValue !== getBuffer().join("") && $el.trigger("change"),
            opts.clearMaskOnLostFocus &&
              -1 === getLastValidPosition() &&
              el.inputmask._valueGet &&
              el.inputmask._valueGet() === getBufferTemplate().join("") &&
              el.inputmask._valueSet(""),
            opts.removeMaskOnSubmit &&
              (el.inputmask._valueSet(el.inputmask.unmaskedvalue(), !0),
              setTimeout(function () {
                writeBuffer(el, getBuffer());
              }, 0));
        },
        resetEvent: function (e) {
          (el.inputmask.refreshValue = !0),
            setTimeout(function () {
              $el.trigger("setvalue");
            }, 0);
        },
      };
    Inputmask.prototype.positionColorMask = function (input, template) {
      input.style.left = template.offsetLeft + "px";
    };
    var valueBuffer;
    if (actionObj !== undefined)
      switch (actionObj.action) {
        case "isComplete":
          return (el = actionObj.el), isComplete(getBuffer());

        case "unmaskedvalue":
          return (
            (el !== undefined && actionObj.value === undefined) ||
              ((valueBuffer = actionObj.value),
              (valueBuffer = (
                $.isFunction(opts.onBeforeMask)
                  ? opts.onBeforeMask.call(inputmask, valueBuffer, opts) ||
                    valueBuffer
                  : valueBuffer
              ).split("")),
              checkVal(
                undefined,
                !1,
                !1,
                isRTL ? valueBuffer.reverse() : valueBuffer
              ),
              $.isFunction(opts.onBeforeWrite) &&
                opts.onBeforeWrite.call(
                  inputmask,
                  undefined,
                  getBuffer(),
                  0,
                  opts
                )),
            unmaskedvalue(el)
          );

        case "mask":
          !(function (elem) {
            EventRuler.off(elem);
            var isSupported = (function (input, opts) {
              var elementType = input.getAttribute("type"),
                isSupported =
                  ("INPUT" === input.tagName &&
                    -1 !== $.inArray(elementType, opts.supportsInputType)) ||
                  input.isContentEditable ||
                  "TEXTAREA" === input.tagName;
              if (!isSupported)
                if ("INPUT" === input.tagName) {
                  var el = document.createElement("input");
                  el.setAttribute("type", elementType),
                    (isSupported = "text" === el.type),
                    (el = null);
                } else isSupported = "partial";
              return (
                !1 !== isSupported
                  ? (function (npt) {
                      function getter() {
                        return this.inputmask
                          ? this.inputmask.opts.autoUnmask
                            ? this.inputmask.unmaskedvalue()
                            : -1 !== getLastValidPosition() ||
                              !0 !== opts.nullable
                            ? document.activeElement === this &&
                              opts.clearMaskOnLostFocus
                              ? (isRTL
                                  ? clearOptionalTail(
                                      getBuffer().slice()
                                    ).reverse()
                                  : clearOptionalTail(getBuffer().slice())
                                ).join("")
                              : valueGet.call(this)
                            : ""
                          : valueGet.call(this);
                      }
                      function setter(value) {
                        valueSet.call(this, value),
                          this.inputmask && $(this).trigger("setvalue");
                      }
                      var valueGet, valueSet;
                      if (!npt.inputmask.__valueGet) {
                        if (!0 !== opts.noValuePatching) {
                          if (Object.getOwnPropertyDescriptor) {
                            "function" != typeof Object.getPrototypeOf &&
                              (Object.getPrototypeOf =
                                "object" == typeof "test".__proto__
                                  ? function (object) {
                                      return object.__proto__;
                                    }
                                  : function (object) {
                                      return object.constructor.prototype;
                                    });
                            var valueProperty = Object.getPrototypeOf
                              ? Object.getOwnPropertyDescriptor(
                                  Object.getPrototypeOf(npt),
                                  "value"
                                )
                              : undefined;
                            valueProperty &&
                            valueProperty.get &&
                            valueProperty.set
                              ? ((valueGet = valueProperty.get),
                                (valueSet = valueProperty.set),
                                Object.defineProperty(npt, "value", {
                                  get: getter,
                                  set: setter,
                                  configurable: !0,
                                }))
                              : "INPUT" !== npt.tagName &&
                                ((valueGet = function () {
                                  return this.textContent;
                                }),
                                (valueSet = function (value) {
                                  this.textContent = value;
                                }),
                                Object.defineProperty(npt, "value", {
                                  get: getter,
                                  set: setter,
                                  configurable: !0,
                                }));
                          } else
                            document.__lookupGetter__ &&
                              npt.__lookupGetter__("value") &&
                              ((valueGet = npt.__lookupGetter__("value")),
                              (valueSet = npt.__lookupSetter__("value")),
                              npt.__defineGetter__("value", getter),
                              npt.__defineSetter__("value", setter));
                          (npt.inputmask.__valueGet = valueGet),
                            (npt.inputmask.__valueSet = valueSet);
                        }
                        (npt.inputmask._valueGet = function (overruleRTL) {
                          return isRTL && !0 !== overruleRTL
                            ? valueGet
                                .call(this.el)
                                .split("")
                                .reverse()
                                .join("")
                            : valueGet.call(this.el);
                        }),
                          (npt.inputmask._valueSet = function (
                            value,
                            overruleRTL
                          ) {
                            valueSet.call(
                              this.el,
                              null === value || value === undefined
                                ? ""
                                : !0 !== overruleRTL && isRTL
                                ? value.split("").reverse().join("")
                                : value
                            );
                          }),
                          valueGet === undefined &&
                            ((valueGet = function () {
                              return this.value;
                            }),
                            (valueSet = function (value) {
                              this.value = value;
                            }),
                            (function (type) {
                              if (
                                $.valHooks &&
                                ($.valHooks[type] === undefined ||
                                  !0 !== $.valHooks[type].inputmaskpatch)
                              ) {
                                var valhookGet =
                                    $.valHooks[type] && $.valHooks[type].get
                                      ? $.valHooks[type].get
                                      : function (elem) {
                                          return elem.value;
                                        },
                                  valhookSet =
                                    $.valHooks[type] && $.valHooks[type].set
                                      ? $.valHooks[type].set
                                      : function (elem, value) {
                                          return (elem.value = value), elem;
                                        };
                                $.valHooks[type] = {
                                  get: function (elem) {
                                    if (elem.inputmask) {
                                      if (elem.inputmask.opts.autoUnmask)
                                        return elem.inputmask.unmaskedvalue();
                                      var result = valhookGet(elem);
                                      return -1 !==
                                        getLastValidPosition(
                                          undefined,
                                          undefined,
                                          elem.inputmask.maskset.validPositions
                                        ) || !0 !== opts.nullable
                                        ? result
                                        : "";
                                    }
                                    return valhookGet(elem);
                                  },
                                  set: function (elem, value) {
                                    var result,
                                      $elem = $(elem);
                                    return (
                                      (result = valhookSet(elem, value)),
                                      elem.inputmask &&
                                        $elem.trigger("setvalue"),
                                      result
                                    );
                                  },
                                  inputmaskpatch: !0,
                                };
                              }
                            })(npt.type),
                            (function (npt) {
                              EventRuler.on(
                                npt,
                                "mouseenter",
                                function (event) {
                                  var $input = $(this);
                                  this.inputmask._valueGet() !==
                                    getBuffer().join("") &&
                                    $input.trigger("setvalue");
                                }
                              );
                            })(npt));
                      }
                    })(input)
                  : (input.inputmask = undefined),
                isSupported
              );
            })(elem, opts);
            if (
              !1 !== isSupported &&
              ((el = elem),
              ($el = $(el)),
              -1 ===
                (maxLength = el !== undefined ? el.maxLength : undefined) &&
                (maxLength = undefined),
              !0 === opts.colorMask && initializeColorMask(el),
              android &&
                (el.hasOwnProperty("inputmode") &&
                  ((el.inputmode = opts.inputmode),
                  el.setAttribute("inputmode", opts.inputmode)),
                "rtfm" === opts.androidHack &&
                  (!0 !== opts.colorMask && initializeColorMask(el),
                  (el.type = "password"))),
              !0 === isSupported &&
                (EventRuler.on(el, "submit", EventHandlers.submitEvent),
                EventRuler.on(el, "reset", EventHandlers.resetEvent),
                EventRuler.on(el, "mouseenter", EventHandlers.mouseenterEvent),
                EventRuler.on(el, "blur", EventHandlers.blurEvent),
                EventRuler.on(el, "focus", EventHandlers.focusEvent),
                EventRuler.on(el, "mouseleave", EventHandlers.mouseleaveEvent),
                !0 !== opts.colorMask &&
                  EventRuler.on(el, "click", EventHandlers.clickEvent),
                EventRuler.on(el, "dblclick", EventHandlers.dblclickEvent),
                EventRuler.on(el, "paste", EventHandlers.pasteEvent),
                EventRuler.on(el, "dragdrop", EventHandlers.pasteEvent),
                EventRuler.on(el, "drop", EventHandlers.pasteEvent),
                EventRuler.on(el, "cut", EventHandlers.cutEvent),
                EventRuler.on(el, "complete", opts.oncomplete),
                EventRuler.on(el, "incomplete", opts.onincomplete),
                EventRuler.on(el, "cleared", opts.oncleared),
                android || !0 === opts.inputEventOnly
                  ? el.removeAttribute("maxLength")
                  : (EventRuler.on(el, "keydown", EventHandlers.keydownEvent),
                    EventRuler.on(el, "keypress", EventHandlers.keypressEvent)),
                EventRuler.on(el, "compositionstart", $.noop),
                EventRuler.on(el, "compositionupdate", $.noop),
                EventRuler.on(el, "compositionend", $.noop),
                EventRuler.on(el, "keyup", $.noop),
                EventRuler.on(el, "input", EventHandlers.inputFallBackEvent),
                EventRuler.on(el, "beforeinput", $.noop)),
              EventRuler.on(el, "setvalue", EventHandlers.setValueEvent),
              (undoValue = getBufferTemplate().join("")),
              "" !== el.inputmask._valueGet(!0) ||
                !1 === opts.clearMaskOnLostFocus ||
                document.activeElement === el)
            ) {
              var initialValue = $.isFunction(opts.onBeforeMask)
                ? opts.onBeforeMask.call(
                    inputmask,
                    el.inputmask._valueGet(!0),
                    opts
                  ) || el.inputmask._valueGet(!0)
                : el.inputmask._valueGet(!0);
              "" !== initialValue &&
                checkVal(
                  el,
                  !0,
                  !1,
                  isRTL
                    ? initialValue.split("").reverse()
                    : initialValue.split("")
                );
              var buffer = getBuffer().slice();
              (undoValue = buffer.join("")),
                !1 === isComplete(buffer) &&
                  opts.clearIncomplete &&
                  resetMaskSet(),
                opts.clearMaskOnLostFocus &&
                  document.activeElement !== el &&
                  (-1 === getLastValidPosition()
                    ? (buffer = [])
                    : clearOptionalTail(buffer)),
                writeBuffer(el, buffer),
                document.activeElement === el &&
                  caret(el, seekNext(getLastValidPosition()));
            }
          })(el);
          break;

        case "format":
          return (
            (valueBuffer = (
              $.isFunction(opts.onBeforeMask)
                ? opts.onBeforeMask.call(inputmask, actionObj.value, opts) ||
                  actionObj.value
                : actionObj.value
            ).split("")),
            checkVal(
              undefined,
              !0,
              !1,
              isRTL ? valueBuffer.reverse() : valueBuffer
            ),
            actionObj.metadata
              ? {
                  value: isRTL
                    ? getBuffer().slice().reverse().join("")
                    : getBuffer().join(""),
                  metadata: maskScope.call(
                    this,
                    {
                      action: "getmetadata",
                    },
                    maskset,
                    opts
                  ),
                }
              : isRTL
              ? getBuffer().slice().reverse().join("")
              : getBuffer().join("")
          );

        case "isValid":
          actionObj.value
            ? ((valueBuffer = actionObj.value.split("")),
              checkVal(
                undefined,
                !0,
                !0,
                isRTL ? valueBuffer.reverse() : valueBuffer
              ))
            : (actionObj.value = getBuffer().join(""));
          for (
            var buffer = getBuffer(),
              rl = determineLastRequiredPosition(),
              lmib = buffer.length - 1;
            lmib > rl && !isMask(lmib);
            lmib--
          );
          return (
            buffer.splice(rl, lmib + 1 - rl),
            isComplete(buffer) && actionObj.value === getBuffer().join("")
          );

        case "getemptymask":
          return getBufferTemplate().join("");

        case "remove":
          if (el && el.inputmask) {
            ($el = $(el)),
              el.inputmask._valueSet(
                opts.autoUnmask ? unmaskedvalue(el) : el.inputmask._valueGet(!0)
              ),
              EventRuler.off(el);
            Object.getOwnPropertyDescriptor && Object.getPrototypeOf
              ? Object.getOwnPropertyDescriptor(
                  Object.getPrototypeOf(el),
                  "value"
                ) &&
                el.inputmask.__valueGet &&
                Object.defineProperty(el, "value", {
                  get: el.inputmask.__valueGet,
                  set: el.inputmask.__valueSet,
                  configurable: !0,
                })
              : document.__lookupGetter__ &&
                el.__lookupGetter__("value") &&
                el.inputmask.__valueGet &&
                (el.__defineGetter__("value", el.inputmask.__valueGet),
                el.__defineSetter__("value", el.inputmask.__valueSet)),
              (el.inputmask = undefined);
          }
          return el;

        case "getmetadata":
          if ($.isArray(maskset.metadata)) {
            var maskTarget = getMaskTemplate(!0, 0, !1).join("");
            return (
              $.each(maskset.metadata, function (ndx, mtdt) {
                if (mtdt.mask === maskTarget) return (maskTarget = mtdt), !1;
              }),
              maskTarget
            );
          }
          return maskset.metadata;
      }
  }
  var ua = navigator.userAgent,
    mobile = /mobile/i.test(ua),
    iemobile = /iemobile/i.test(ua),
    iphone = /iphone/i.test(ua) && !iemobile,
    android = /android/i.test(ua) && !iemobile;
  return (
    (Inputmask.prototype = {
      dataAttribute: "data-inputmask",
      defaults: {
        placeholder: "_",
        optionalmarker: {
          start: "[",
          end: "]",
        },
        quantifiermarker: {
          start: "{",
          end: "}",
        },
        groupmarker: {
          start: "(",
          end: ")",
        },
        alternatormarker: "|",
        escapeChar: "\\",
        mask: null,
        regex: null,
        oncomplete: $.noop,
        onincomplete: $.noop,
        oncleared: $.noop,
        repeat: 0,
        greedy: !0,
        autoUnmask: !1,
        removeMaskOnSubmit: !1,
        clearMaskOnLostFocus: !0,
        insertMode: !0,
        clearIncomplete: !1,
        alias: null,
        onKeyDown: $.noop,
        onBeforeMask: null,
        onBeforePaste: function (pastedValue, opts) {
          return $.isFunction(opts.onBeforeMask)
            ? opts.onBeforeMask.call(this, pastedValue, opts)
            : pastedValue;
        },
        onBeforeWrite: null,
        onUnMask: null,
        showMaskOnFocus: !0,
        showMaskOnHover: !0,
        onKeyValidation: $.noop,
        skipOptionalPartCharacter: " ",
        numericInput: !1,
        rightAlign: !1,
        undoOnEscape: !0,
        radixPoint: "",
        radixPointDefinitionSymbol: undefined,
        groupSeparator: "",
        keepStatic: null,
        positionCaretOnTab: !0,
        tabThrough: !1,
        supportsInputType: ["text", "tel", "password"],
        ignorables: [
          8, 9, 13, 19, 27, 33, 34, 35, 36, 37, 38, 39, 40, 45, 46, 93, 112,
          113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 0, 229,
        ],
        isComplete: null,
        canClearPosition: $.noop,
        preValidation: null,
        postValidation: null,
        staticDefinitionSymbol: undefined,
        jitMasking: !1,
        nullable: !0,
        inputEventOnly: !1,
        noValuePatching: !1,
        positionCaretOnClick: "lvp",
        casing: null,
        inputmode: "verbatim",
        colorMask: !1,
        androidHack: !1,
        importDataAttributes: !0,
      },
      definitions: {
        9: {
          validator: "[0-9１-９]",
          cardinality: 1,
          definitionSymbol: "*",
        },
        a: {
          validator: "[A-Za-zА-яЁёÀ-ÿµ]",
          cardinality: 1,
          definitionSymbol: "*",
        },
        "*": {
          validator: "[0-9１-９A-Za-zА-яЁёÀ-ÿµ]",
          cardinality: 1,
        },
      },
      aliases: {},
      masksCache: {},
      mask: function (elems) {
        function importAttributeOptions(npt, opts, userOptions, dataAttribute) {
          function importOption(option, optionData) {
            null !==
              (optionData =
                optionData !== undefined
                  ? optionData
                  : npt.getAttribute(dataAttribute + "-" + option)) &&
              ("string" == typeof optionData &&
                (0 === option.indexOf("on")
                  ? (optionData = window[optionData])
                  : "false" === optionData
                  ? (optionData = !1)
                  : "true" === optionData && (optionData = !0)),
              (userOptions[option] = optionData));
          }
          if (!0 === opts.importDataAttributes) {
            var option,
              dataoptions,
              optionData,
              p,
              attrOptions = npt.getAttribute(dataAttribute);
            if (
              (attrOptions &&
                "" !== attrOptions &&
                ((attrOptions = attrOptions.replace(new RegExp("'", "g"), '"')),
                (dataoptions = JSON.parse("{" + attrOptions + "}"))),
              dataoptions)
            ) {
              optionData = undefined;
              for (p in dataoptions)
                if ("alias" === p.toLowerCase()) {
                  optionData = dataoptions[p];
                  break;
                }
            }
            importOption("alias", optionData),
              userOptions.alias &&
                resolveAlias(userOptions.alias, userOptions, opts);
            for (option in opts) {
              if (dataoptions) {
                optionData = undefined;
                for (p in dataoptions)
                  if (p.toLowerCase() === option.toLowerCase()) {
                    optionData = dataoptions[p];
                    break;
                  }
              }
              importOption(option, optionData);
            }
          }
          return (
            $.extend(!0, opts, userOptions),
            ("rtl" === npt.dir || opts.rightAlign) &&
              (npt.style.textAlign = "right"),
            ("rtl" === npt.dir || opts.numericInput) &&
              ((npt.dir = "ltr"),
              npt.removeAttribute("dir"),
              (opts.isRTL = !0)),
            opts
          );
        }
        var that = this;
        return (
          "string" == typeof elems &&
            (elems =
              document.getElementById(elems) ||
              document.querySelectorAll(elems)),
          (elems = elems.nodeName ? [elems] : elems),
          $.each(elems, function (ndx, el) {
            var scopedOpts = $.extend(!0, {}, that.opts);
            importAttributeOptions(
              el,
              scopedOpts,
              $.extend(!0, {}, that.userOptions),
              that.dataAttribute
            );
            var maskset = generateMaskSet(scopedOpts, that.noMasksCache);
            maskset !== undefined &&
              (el.inputmask !== undefined &&
                ((el.inputmask.opts.autoUnmask = !0), el.inputmask.remove()),
              (el.inputmask = new Inputmask(undefined, undefined, !0)),
              (el.inputmask.opts = scopedOpts),
              (el.inputmask.noMasksCache = that.noMasksCache),
              (el.inputmask.userOptions = $.extend(!0, {}, that.userOptions)),
              (el.inputmask.isRTL =
                scopedOpts.isRTL || scopedOpts.numericInput),
              (el.inputmask.el = el),
              (el.inputmask.maskset = maskset),
              $.data(el, "_inputmask_opts", scopedOpts),
              maskScope.call(el.inputmask, {
                action: "mask",
              }));
          }),
          elems && elems[0] ? elems[0].inputmask || this : this
        );
      },
      option: function (options, noremask) {
        return "string" == typeof options
          ? this.opts[options]
          : "object" == typeof options
          ? ($.extend(this.userOptions, options),
            this.el && !0 !== noremask && this.mask(this.el),
            this)
          : void 0;
      },
      unmaskedvalue: function (value) {
        return (
          (this.maskset =
            this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
          maskScope.call(this, {
            action: "unmaskedvalue",
            value: value,
          })
        );
      },
      remove: function () {
        return maskScope.call(this, {
          action: "remove",
        });
      },
      getemptymask: function () {
        return (
          (this.maskset =
            this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
          maskScope.call(this, {
            action: "getemptymask",
          })
        );
      },
      hasMaskedValue: function () {
        return !this.opts.autoUnmask;
      },
      isComplete: function () {
        return (
          (this.maskset =
            this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
          maskScope.call(this, {
            action: "isComplete",
          })
        );
      },
      getmetadata: function () {
        return (
          (this.maskset =
            this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
          maskScope.call(this, {
            action: "getmetadata",
          })
        );
      },
      isValid: function (value) {
        return (
          (this.maskset =
            this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
          maskScope.call(this, {
            action: "isValid",
            value: value,
          })
        );
      },
      format: function (value, metadata) {
        return (
          (this.maskset =
            this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
          maskScope.call(this, {
            action: "format",
            value: value,
            metadata: metadata,
          })
        );
      },
      analyseMask: function (mask, regexMask, opts) {
        function MaskToken(isGroup, isOptional, isQuantifier, isAlternator) {
          (this.matches = []),
            (this.openGroup = isGroup || !1),
            (this.alternatorGroup = !1),
            (this.isGroup = isGroup || !1),
            (this.isOptional = isOptional || !1),
            (this.isQuantifier = isQuantifier || !1),
            (this.isAlternator = isAlternator || !1),
            (this.quantifier = {
              min: 1,
              max: 1,
            });
        }
        function insertTestDefinition(mtoken, element, position) {
          position = position !== undefined ? position : mtoken.matches.length;
          var prevMatch = mtoken.matches[position - 1];
          if (regexMask)
            0 === element.indexOf("[") ||
            (escaped && /\\d|\\s|\\w]/i.test(element)) ||
            "." === element
              ? mtoken.matches.splice(position++, 0, {
                  fn: new RegExp(element, opts.casing ? "i" : ""),
                  cardinality: 1,
                  optionality: mtoken.isOptional,
                  newBlockMarker:
                    prevMatch === undefined || prevMatch.def !== element,
                  casing: null,
                  def: element,
                  placeholder: undefined,
                  nativeDef: element,
                })
              : (escaped && (element = element[element.length - 1]),
                $.each(element.split(""), function (ndx, lmnt) {
                  (prevMatch = mtoken.matches[position - 1]),
                    mtoken.matches.splice(position++, 0, {
                      fn: null,
                      cardinality: 0,
                      optionality: mtoken.isOptional,
                      newBlockMarker:
                        prevMatch === undefined ||
                        (prevMatch.def !== lmnt && null !== prevMatch.fn),
                      casing: null,
                      def: opts.staticDefinitionSymbol || lmnt,
                      placeholder:
                        opts.staticDefinitionSymbol !== undefined
                          ? lmnt
                          : undefined,
                      nativeDef: lmnt,
                    });
                })),
              (escaped = !1);
          else {
            var maskdef =
              (opts.definitions ? opts.definitions[element] : undefined) ||
              Inputmask.prototype.definitions[element];
            if (maskdef && !escaped) {
              for (
                var prevalidators = maskdef.prevalidator,
                  prevalidatorsL = prevalidators ? prevalidators.length : 0,
                  i = 1;
                i < maskdef.cardinality;
                i++
              ) {
                var prevalidator =
                    prevalidatorsL >= i ? prevalidators[i - 1] : [],
                  validator = prevalidator.validator,
                  cardinality = prevalidator.cardinality;
                mtoken.matches.splice(position++, 0, {
                  fn: validator
                    ? "string" == typeof validator
                      ? new RegExp(validator, opts.casing ? "i" : "")
                      : new (function () {
                          this.test = validator;
                        })()
                    : new RegExp("."),
                  cardinality: cardinality || 1,
                  optionality: mtoken.isOptional,
                  newBlockMarker:
                    prevMatch === undefined ||
                    prevMatch.def !== (maskdef.definitionSymbol || element),
                  casing: maskdef.casing,
                  def: maskdef.definitionSymbol || element,
                  placeholder: maskdef.placeholder,
                  nativeDef: element,
                }),
                  (prevMatch = mtoken.matches[position - 1]);
              }
              mtoken.matches.splice(position++, 0, {
                fn: maskdef.validator
                  ? "string" == typeof maskdef.validator
                    ? new RegExp(maskdef.validator, opts.casing ? "i" : "")
                    : new (function () {
                        this.test = maskdef.validator;
                      })()
                  : new RegExp("."),
                cardinality: maskdef.cardinality,
                optionality: mtoken.isOptional,
                newBlockMarker:
                  prevMatch === undefined ||
                  prevMatch.def !== (maskdef.definitionSymbol || element),
                casing: maskdef.casing,
                def: maskdef.definitionSymbol || element,
                placeholder: maskdef.placeholder,
                nativeDef: element,
              });
            } else
              mtoken.matches.splice(position++, 0, {
                fn: null,
                cardinality: 0,
                optionality: mtoken.isOptional,
                newBlockMarker:
                  prevMatch === undefined ||
                  (prevMatch.def !== element && null !== prevMatch.fn),
                casing: null,
                def: opts.staticDefinitionSymbol || element,
                placeholder:
                  opts.staticDefinitionSymbol !== undefined
                    ? element
                    : undefined,
                nativeDef: element,
              }),
                (escaped = !1);
          }
        }
        function verifyGroupMarker(maskToken) {
          maskToken &&
            maskToken.matches &&
            $.each(maskToken.matches, function (ndx, token) {
              var nextToken = maskToken.matches[ndx + 1];
              (nextToken === undefined ||
                nextToken.matches === undefined ||
                !1 === nextToken.isQuantifier) &&
                token &&
                token.isGroup &&
                ((token.isGroup = !1),
                regexMask ||
                  (insertTestDefinition(token, opts.groupmarker.start, 0),
                  !0 !== token.openGroup &&
                    insertTestDefinition(token, opts.groupmarker.end))),
                verifyGroupMarker(token);
            });
        }
        function defaultCase() {
          if (openenings.length > 0) {
            if (
              ((currentOpeningToken = openenings[openenings.length - 1]),
              insertTestDefinition(currentOpeningToken, m),
              currentOpeningToken.isAlternator)
            ) {
              alternator = openenings.pop();
              for (var mndx = 0; mndx < alternator.matches.length; mndx++)
                alternator.matches[mndx].isGroup = !1;
              openenings.length > 0
                ? (currentOpeningToken =
                    openenings[openenings.length - 1]).matches.push(alternator)
                : currentToken.matches.push(alternator);
            }
          } else insertTestDefinition(currentToken, m);
        }
        function reverseTokens(maskToken) {
          maskToken.matches = maskToken.matches.reverse();
          for (var match in maskToken.matches)
            if (maskToken.matches.hasOwnProperty(match)) {
              var intMatch = parseInt(match);
              if (
                maskToken.matches[match].isQuantifier &&
                maskToken.matches[intMatch + 1] &&
                maskToken.matches[intMatch + 1].isGroup
              ) {
                var qt = maskToken.matches[match];
                maskToken.matches.splice(match, 1),
                  maskToken.matches.splice(intMatch + 1, 0, qt);
              }
              maskToken.matches[match].matches !== undefined
                ? (maskToken.matches[match] = reverseTokens(
                    maskToken.matches[match]
                  ))
                : (maskToken.matches[match] = (function (st) {
                    return (
                      st === opts.optionalmarker.start
                        ? (st = opts.optionalmarker.end)
                        : st === opts.optionalmarker.end
                        ? (st = opts.optionalmarker.start)
                        : st === opts.groupmarker.start
                        ? (st = opts.groupmarker.end)
                        : st === opts.groupmarker.end &&
                          (st = opts.groupmarker.start),
                      st
                    );
                  })(maskToken.matches[match]));
            }
          return maskToken;
        }
        var match,
          m,
          openingToken,
          currentOpeningToken,
          alternator,
          lastMatch,
          groupToken,
          tokenizer =
            /(?:[?*+]|\{[0-9\+\*]+(?:,[0-9\+\*]*)?\})|[^.?*+^${[]()|\\]+|./g,
          regexTokenizer =
            /\[\^?]?(?:[^\\\]]+|\\[\S\s]?)*]?|\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9][0-9]*|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|c[A-Za-z]|[\S\s]?)|\((?:\?[:=!]?)?|(?:[?*+]|\{[0-9]+(?:,[0-9]*)?\})\??|[^.?*+^${[()|\\]+|./g,
          escaped = !1,
          currentToken = new MaskToken(),
          openenings = [],
          maskTokens = [];
        for (
          regexMask &&
          ((opts.optionalmarker.start = undefined),
          (opts.optionalmarker.end = undefined));
          (match = regexMask
            ? regexTokenizer.exec(mask)
            : tokenizer.exec(mask));

        ) {
          if (((m = match[0]), regexMask))
            switch (m.charAt(0)) {
              case "?":
                m = "{0,1}";
                break;

              case "+":
              case "*":
                m = "{" + m + "}";
            }
          if (escaped) defaultCase();
          else
            switch (m.charAt(0)) {
              case opts.escapeChar:
                (escaped = !0), regexMask && defaultCase();
                break;

              case opts.optionalmarker.end:
              case opts.groupmarker.end:
                if (
                  ((openingToken = openenings.pop()),
                  (openingToken.openGroup = !1),
                  openingToken !== undefined)
                )
                  if (openenings.length > 0) {
                    if (
                      ((currentOpeningToken =
                        openenings[openenings.length - 1]).matches.push(
                        openingToken
                      ),
                      currentOpeningToken.isAlternator)
                    ) {
                      alternator = openenings.pop();
                      for (
                        var mndx = 0;
                        mndx < alternator.matches.length;
                        mndx++
                      )
                        (alternator.matches[mndx].isGroup = !1),
                          (alternator.matches[mndx].alternatorGroup = !1);
                      openenings.length > 0
                        ? (currentOpeningToken =
                            openenings[openenings.length - 1]).matches.push(
                            alternator
                          )
                        : currentToken.matches.push(alternator);
                    }
                  } else currentToken.matches.push(openingToken);
                else defaultCase();
                break;

              case opts.optionalmarker.start:
                openenings.push(new MaskToken(!1, !0));
                break;

              case opts.groupmarker.start:
                openenings.push(new MaskToken(!0));
                break;

              case opts.quantifiermarker.start:
                var quantifier = new MaskToken(!1, !1, !0),
                  mq = (m = m.replace(/[{}]/g, "")).split(","),
                  mq0 = isNaN(mq[0]) ? mq[0] : parseInt(mq[0]),
                  mq1 =
                    1 === mq.length
                      ? mq0
                      : isNaN(mq[1])
                      ? mq[1]
                      : parseInt(mq[1]);
                if (
                  (("*" !== mq1 && "+" !== mq1) || (mq0 = "*" === mq1 ? 0 : 1),
                  (quantifier.quantifier = {
                    min: mq0,
                    max: mq1,
                  }),
                  openenings.length > 0)
                ) {
                  var matches = openenings[openenings.length - 1].matches;
                  (match = matches.pop()).isGroup ||
                    ((groupToken = new MaskToken(!0)).matches.push(match),
                    (match = groupToken)),
                    matches.push(match),
                    matches.push(quantifier);
                } else
                  (match = currentToken.matches.pop()).isGroup ||
                    (regexMask &&
                      null === match.fn &&
                      "." === match.def &&
                      (match.fn = new RegExp(
                        match.def,
                        opts.casing ? "i" : ""
                      )),
                    (groupToken = new MaskToken(!0)).matches.push(match),
                    (match = groupToken)),
                    currentToken.matches.push(match),
                    currentToken.matches.push(quantifier);
                break;

              case opts.alternatormarker:
                if (openenings.length > 0) {
                  var subToken = (currentOpeningToken =
                    openenings[openenings.length - 1]).matches[
                    currentOpeningToken.matches.length - 1
                  ];
                  lastMatch =
                    currentOpeningToken.openGroup &&
                    (subToken.matches === undefined ||
                      (!1 === subToken.isGroup && !1 === subToken.isAlternator))
                      ? openenings.pop()
                      : currentOpeningToken.matches.pop();
                } else lastMatch = currentToken.matches.pop();
                if (lastMatch.isAlternator) openenings.push(lastMatch);
                else if (
                  (lastMatch.alternatorGroup
                    ? ((alternator = openenings.pop()),
                      (lastMatch.alternatorGroup = !1))
                    : (alternator = new MaskToken(!1, !1, !1, !0)),
                  alternator.matches.push(lastMatch),
                  openenings.push(alternator),
                  lastMatch.openGroup)
                ) {
                  lastMatch.openGroup = !1;
                  var alternatorGroup = new MaskToken(!0);
                  (alternatorGroup.alternatorGroup = !0),
                    openenings.push(alternatorGroup);
                }
                break;

              default:
                defaultCase();
            }
        }
        for (; openenings.length > 0; )
          (openingToken = openenings.pop()),
            currentToken.matches.push(openingToken);
        return (
          currentToken.matches.length > 0 &&
            (verifyGroupMarker(currentToken), maskTokens.push(currentToken)),
          (opts.numericInput || opts.isRTL) && reverseTokens(maskTokens[0]),
          maskTokens
        );
      },
    }),
    (Inputmask.extendDefaults = function (options) {
      $.extend(!0, Inputmask.prototype.defaults, options);
    }),
    (Inputmask.extendDefinitions = function (definition) {
      $.extend(!0, Inputmask.prototype.definitions, definition);
    }),
    (Inputmask.extendAliases = function (alias) {
      $.extend(!0, Inputmask.prototype.aliases, alias);
    }),
    (Inputmask.format = function (value, options, metadata) {
      return Inputmask(options).format(value, metadata);
    }),
    (Inputmask.unmask = function (value, options) {
      return Inputmask(options).unmaskedvalue(value);
    }),
    (Inputmask.isValid = function (value, options) {
      return Inputmask(options).isValid(value);
    }),
    (Inputmask.remove = function (elems) {
      $.each(elems, function (ndx, el) {
        el.inputmask && el.inputmask.remove();
      });
    }),
    (Inputmask.escapeRegex = function (str) {
      var specials = [
        "/",
        ".",
        "*",
        "+",
        "?",
        "|",
        "(",
        ")",
        "[",
        "]",
        "{",
        "}",
        "\\",
        "$",
        "^",
      ];
      return str.replace(
        new RegExp("(\\" + specials.join("|\\") + ")", "gim"),
        "\\$1"
      );
    }),
    (Inputmask.keyCode = {
      ALT: 18,
      BACKSPACE: 8,
      BACKSPACE_SAFARI: 127,
      CAPS_LOCK: 20,
      COMMA: 188,
      COMMAND: 91,
      COMMAND_LEFT: 91,
      COMMAND_RIGHT: 93,
      CONTROL: 17,
      DELETE: 46,
      DOWN: 40,
      END: 35,
      ENTER: 13,
      ESCAPE: 27,
      HOME: 36,
      INSERT: 45,
      LEFT: 37,
      MENU: 93,
      NUMPAD_ADD: 107,
      NUMPAD_DECIMAL: 110,
      NUMPAD_DIVIDE: 111,
      NUMPAD_ENTER: 108,
      NUMPAD_MULTIPLY: 106,
      NUMPAD_SUBTRACT: 109,
      PAGE_DOWN: 34,
      PAGE_UP: 33,
      PERIOD: 190,
      RIGHT: 39,
      SHIFT: 16,
      SPACE: 32,
      TAB: 9,
      UP: 38,
      WINDOWS: 91,
      X: 88,
    }),
    Inputmask
  );
});