@chocolatey-software/ccr 2.1.0 → 2.5.0

package/dist/scripts/validation.js

@@ -7636,6 +7636,1310 @@
     }
   });
 
+  // node_modules/jquery-validation-unobtrusive/node_modules/jquery-validation/dist/jquery.validate.js
+  var require_jquery_validate2 = __commonJS({
+    "node_modules/jquery-validation-unobtrusive/node_modules/jquery-validation/dist/jquery.validate.js"(exports, module) {
+      (function(factory) {
+        if (typeof define === "function" && define.amd) {
+          define(["jquery"], factory);
+        } else if (typeof module === "object" && module.exports) {
+          module.exports = factory(require_jquery());
+        } else {
+          factory(jQuery);
+        }
+      })(function($2) {
+        $2.extend($2.fn, {
+          // https://jqueryvalidation.org/validate/
+          validate: function(options) {
+            if (!this.length) {
+              if (options && options.debug && window.console) {
+                console.warn("Nothing selected, can't validate, returning nothing.");
+              }
+              return;
+            }
+            var validator = $2.data(this[0], "validator");
+            if (validator) {
+              return validator;
+            }
+            this.attr("novalidate", "novalidate");
+            validator = new $2.validator(options, this[0]);
+            $2.data(this[0], "validator", validator);
+            if (validator.settings.onsubmit) {
+              this.on("click.validate", ":submit", function(event) {
+                validator.submitButton = event.currentTarget;
+                if ($2(this).hasClass("cancel")) {
+                  validator.cancelSubmit = true;
+                }
+                if ($2(this).attr("formnovalidate") !== void 0) {
+                  validator.cancelSubmit = true;
+                }
+              });
+              this.on("submit.validate", function(event) {
+                if (validator.settings.debug) {
+                  event.preventDefault();
+                }
+                function handle() {
+                  var hidden, result;
+                  if (validator.submitButton && (validator.settings.submitHandler || validator.formSubmitted)) {
+                    hidden = $2("<input type='hidden'/>").attr("name", validator.submitButton.name).val($2(validator.submitButton).val()).appendTo(validator.currentForm);
+                  }
+                  if (validator.settings.submitHandler && !validator.settings.debug) {
+                    result = validator.settings.submitHandler.call(validator, validator.currentForm, event);
+                    if (hidden) {
+                      hidden.remove();
+                    }
+                    if (result !== void 0) {
+                      return result;
+                    }
+                    return false;
+                  }
+                  return true;
+                }
+                if (validator.cancelSubmit) {
+                  validator.cancelSubmit = false;
+                  return handle();
+                }
+                if (validator.form()) {
+                  if (validator.pendingRequest) {
+                    validator.formSubmitted = true;
+                    return false;
+                  }
+                  return handle();
+                } else {
+                  validator.focusInvalid();
+                  return false;
+                }
+              });
+            }
+            return validator;
+          },
+          // https://jqueryvalidation.org/valid/
+          valid: function() {
+            var valid, validator, errorList;
+            if ($2(this[0]).is("form")) {
+              valid = this.validate().form();
+            } else {
+              errorList = [];
+              valid = true;
+              validator = $2(this[0].form).validate();
+              this.each(function() {
+                valid = validator.element(this) && valid;
+                if (!valid) {
+                  errorList = errorList.concat(validator.errorList);
+                }
+              });
+              validator.errorList = errorList;
+            }
+            return valid;
+          },
+          // https://jqueryvalidation.org/rules/
+          rules: function(command, argument) {
+            var element = this[0], isContentEditable = typeof this.attr("contenteditable") !== "undefined" && this.attr("contenteditable") !== "false", settings, staticRules, existingRules, data, param, filtered;
+            if (element == null) {
+              return;
+            }
+            if (!element.form && isContentEditable) {
+              element.form = this.closest("form")[0];
+              element.name = this.attr("name");
+            }
+            if (element.form == null) {
+              return;
+            }
+            if (command) {
+              settings = $2.data(element.form, "validator").settings;
+              staticRules = settings.rules;
+              existingRules = $2.validator.staticRules(element);
+              switch (command) {
+                case "add":
+                  $2.extend(existingRules, $2.validator.normalizeRule(argument));
+                  delete existingRules.messages;
+                  staticRules[element.name] = existingRules;
+                  if (argument.messages) {
+                    settings.messages[element.name] = $2.extend(settings.messages[element.name], argument.messages);
+                  }
+                  break;
+                case "remove":
+                  if (!argument) {
+                    delete staticRules[element.name];
+                    return existingRules;
+                  }
+                  filtered = {};
+                  $2.each(argument.split(/\s/), function(index, method) {
+                    filtered[method] = existingRules[method];
+                    delete existingRules[method];
+                  });
+                  return filtered;
+              }
+            }
+            data = $2.validator.normalizeRules(
+              $2.extend(
+                {},
+                $2.validator.classRules(element),
+                $2.validator.attributeRules(element),
+                $2.validator.dataRules(element),
+                $2.validator.staticRules(element)
+              ),
+              element
+            );
+            if (data.required) {
+              param = data.required;
+              delete data.required;
+              data = $2.extend({ required: param }, data);
+            }
+            if (data.remote) {
+              param = data.remote;
+              delete data.remote;
+              data = $2.extend(data, { remote: param });
+            }
+            return data;
+          }
+        });
+        var trim = function(str) {
+          return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+        };
+        $2.extend($2.expr.pseudos || $2.expr[":"], {
+          // '|| $.expr[ ":" ]' here enables backwards compatibility to jQuery 1.7. Can be removed when dropping jQ 1.7.x support
+          // https://jqueryvalidation.org/blank-selector/
+          blank: function(a) {
+            return !trim("" + $2(a).val());
+          },
+          // https://jqueryvalidation.org/filled-selector/
+          filled: function(a) {
+            var val = $2(a).val();
+            return val !== null && !!trim("" + val);
+          },
+          // https://jqueryvalidation.org/unchecked-selector/
+          unchecked: function(a) {
+            return !$2(a).prop("checked");
+          }
+        });
+        $2.validator = function(options, form) {
+          this.settings = $2.extend(true, {}, $2.validator.defaults, options);
+          this.currentForm = form;
+          this.init();
+        };
+        $2.validator.format = function(source, params) {
+          if (arguments.length === 1) {
+            return function() {
+              var args = $2.makeArray(arguments);
+              args.unshift(source);
+              return $2.validator.format.apply(this, args);
+            };
+          }
+          if (params === void 0) {
+            return source;
+          }
+          if (arguments.length > 2 && params.constructor !== Array) {
+            params = $2.makeArray(arguments).slice(1);
+          }
+          if (params.constructor !== Array) {
+            params = [params];
+          }
+          $2.each(params, function(i, n) {
+            source = source.replace(new RegExp("\\{" + i + "\\}", "g"), function() {
+              return n;
+            });
+          });
+          return source;
+        };
+        $2.extend($2.validator, {
+          defaults: {
+            messages: {},
+            groups: {},
+            rules: {},
+            errorClass: "error",
+            pendingClass: "pending",
+            validClass: "valid",
+            errorElement: "label",
+            focusCleanup: false,
+            focusInvalid: true,
+            ariaDescribedByCleanup: false,
+            errorContainer: $2([]),
+            errorLabelContainer: $2([]),
+            onsubmit: true,
+            ignore: ":hidden",
+            ignoreTitle: false,
+            customElements: [],
+            onfocusin: function(element) {
+              this.lastActive = element;
+              if (this.settings.focusCleanup) {
+                if (this.settings.unhighlight) {
+                  this.settings.unhighlight.call(this, element, this.settings.errorClass, this.settings.validClass);
+                }
+                this.hideThese(this.errorsFor(element));
+              }
+            },
+            onfocusout: function(element) {
+              if (!this.checkable(element) && (element.name in this.submitted || !this.optional(element))) {
+                this.element(element);
+              }
+            },
+            onkeyup: function(element, event) {
+              var excludedKeys = [
+                16,
+                17,
+                18,
+                20,
+                35,
+                36,
+                37,
+                38,
+                39,
+                40,
+                45,
+                144,
+                225
+              ];
+              if (event.which === 9 && this.elementValue(element) === "" || $2.inArray(event.keyCode, excludedKeys) !== -1) {
+                return;
+              } else if (element.name in this.submitted || element.name in this.invalid) {
+                this.element(element);
+              }
+            },
+            onclick: function(element) {
+              if (element.name in this.submitted) {
+                this.element(element);
+              } else if (element.parentNode.name in this.submitted) {
+                this.element(element.parentNode);
+              }
+            },
+            highlight: function(element, errorClass, validClass) {
+              if (element.type === "radio") {
+                this.findByName(element.name).addClass(errorClass).removeClass(validClass);
+              } else {
+                $2(element).addClass(errorClass).removeClass(validClass);
+              }
+            },
+            unhighlight: function(element, errorClass, validClass) {
+              if (element.type === "radio") {
+                this.findByName(element.name).removeClass(errorClass).addClass(validClass);
+              } else {
+                $2(element).removeClass(errorClass).addClass(validClass);
+              }
+            }
+          },
+          // https://jqueryvalidation.org/jQuery.validator.setDefaults/
+          setDefaults: function(settings) {
+            $2.extend($2.validator.defaults, settings);
+          },
+          messages: {
+            required: "This field is required.",
+            remote: "Please fix this field.",
+            email: "Please enter a valid email address.",
+            url: "Please enter a valid URL.",
+            date: "Please enter a valid date.",
+            dateISO: "Please enter a valid date (ISO).",
+            number: "Please enter a valid number.",
+            digits: "Please enter only digits.",
+            equalTo: "Please enter the same value again.",
+            maxlength: $2.validator.format("Please enter no more than {0} characters."),
+            minlength: $2.validator.format("Please enter at least {0} characters."),
+            rangelength: $2.validator.format("Please enter a value between {0} and {1} characters long."),
+            range: $2.validator.format("Please enter a value between {0} and {1}."),
+            max: $2.validator.format("Please enter a value less than or equal to {0}."),
+            min: $2.validator.format("Please enter a value greater than or equal to {0}."),
+            step: $2.validator.format("Please enter a multiple of {0}.")
+          },
+          autoCreateRanges: false,
+          prototype: {
+            init: function() {
+              this.labelContainer = $2(this.settings.errorLabelContainer);
+              this.errorContext = this.labelContainer.length && this.labelContainer || $2(this.currentForm);
+              this.containers = $2(this.settings.errorContainer).add(this.settings.errorLabelContainer);
+              this.submitted = {};
+              this.valueCache = {};
+              this.pendingRequest = 0;
+              this.pending = {};
+              this.invalid = {};
+              this.reset();
+              var currentForm = this.currentForm, groups = this.groups = {}, rules;
+              $2.each(this.settings.groups, function(key, value) {
+                if (typeof value === "string") {
+                  value = value.split(/\s/);
+                }
+                $2.each(value, function(index, name) {
+                  groups[name] = key;
+                });
+              });
+              rules = this.settings.rules;
+              $2.each(rules, function(key, value) {
+                rules[key] = $2.validator.normalizeRule(value);
+              });
+              function delegate(event) {
+                var isContentEditable = typeof $2(this).attr("contenteditable") !== "undefined" && $2(this).attr("contenteditable") !== "false";
+                if (!this.form && isContentEditable) {
+                  this.form = $2(this).closest("form")[0];
+                  this.name = $2(this).attr("name");
+                }
+                if (currentForm !== this.form) {
+                  return;
+                }
+                var validator = $2.data(this.form, "validator"), eventType = "on" + event.type.replace(/^validate/, ""), settings = validator.settings;
+                if (settings[eventType] && !$2(this).is(settings.ignore)) {
+                  settings[eventType].call(validator, this, event);
+                }
+              }
+              var focusListeners = [
+                ":text",
+                "[type='password']",
+                "[type='file']",
+                "select",
+                "textarea",
+                "[type='number']",
+                "[type='search']",
+                "[type='tel']",
+                "[type='url']",
+                "[type='email']",
+                "[type='datetime']",
+                "[type='date']",
+                "[type='month']",
+                "[type='week']",
+                "[type='time']",
+                "[type='datetime-local']",
+                "[type='range']",
+                "[type='color']",
+                "[type='radio']",
+                "[type='checkbox']",
+                "[contenteditable]",
+                "[type='button']"
+              ];
+              var clickListeners = ["select", "option", "[type='radio']", "[type='checkbox']"];
+              $2(this.currentForm).on("focusin.validate focusout.validate keyup.validate", focusListeners.concat(this.settings.customElements).join(", "), delegate).on("click.validate", clickListeners.concat(this.settings.customElements).join(", "), delegate);
+              if (this.settings.invalidHandler) {
+                $2(this.currentForm).on("invalid-form.validate", this.settings.invalidHandler);
+              }
+            },
+            // https://jqueryvalidation.org/Validator.form/
+            form: function() {
+              this.checkForm();
+              $2.extend(this.submitted, this.errorMap);
+              this.invalid = $2.extend({}, this.errorMap);
+              if (!this.valid()) {
+                $2(this.currentForm).triggerHandler("invalid-form", [this]);
+              }
+              this.showErrors();
+              return this.valid();
+            },
+            checkForm: function() {
+              this.prepareForm();
+              for (var i = 0, elements = this.currentElements = this.elements(); elements[i]; i++) {
+                this.check(elements[i]);
+              }
+              return this.valid();
+            },
+            // https://jqueryvalidation.org/Validator.element/
+            element: function(element) {
+              var cleanElement = this.clean(element), checkElement = this.validationTargetFor(cleanElement), v = this, result = true, rs, group;
+              if (checkElement === void 0) {
+                delete this.invalid[cleanElement.name];
+              } else {
+                this.prepareElement(checkElement);
+                this.currentElements = $2(checkElement);
+                group = this.groups[checkElement.name];
+                if (group) {
+                  $2.each(this.groups, function(name, testgroup) {
+                    if (testgroup === group && name !== checkElement.name) {
+                      cleanElement = v.validationTargetFor(v.clean(v.findByName(name)));
+                      if (cleanElement && cleanElement.name in v.invalid) {
+                        v.currentElements.pushStack(cleanElement);
+                        result = v.check(cleanElement) && result;
+                      }
+                    }
+                  });
+                }
+                rs = this.check(checkElement) !== false;
+                result = result && rs;
+                if (rs) {
+                  this.invalid[checkElement.name] = false;
+                } else {
+                  this.invalid[checkElement.name] = true;
+                }
+                if (!this.numberOfInvalids()) {
+                  this.toHide = this.toHide.add(this.containers);
+                }
+                this.showErrors();
+                $2(element).attr("aria-invalid", !rs);
+              }
+              return result;
+            },
+            // https://jqueryvalidation.org/Validator.showErrors/
+            showErrors: function(errors) {
+              if (errors) {
+                var validator = this;
+                $2.extend(this.errorMap, errors);
+                this.errorList = $2.map(this.errorMap, function(message, name) {
+                  return {
+                    message,
+                    element: validator.findByName(name)[0]
+                  };
+                });
+                this.successList = $2.grep(this.successList, function(element) {
+                  return !(element.name in errors);
+                });
+              }
+              if (this.settings.showErrors) {
+                this.settings.showErrors.call(this, this.errorMap, this.errorList);
+              } else {
+                this.defaultShowErrors();
+              }
+            },
+            // https://jqueryvalidation.org/Validator.resetForm/
+            resetForm: function() {
+              if ($2.fn.resetForm) {
+                $2(this.currentForm).resetForm();
+              }
+              this.invalid = {};
+              this.submitted = {};
+              this.prepareForm();
+              this.hideErrors();
+              var elements = this.elements().removeData("previousValue").removeAttr("aria-invalid");
+              this.resetElements(elements);
+            },
+            resetElements: function(elements) {
+              var i;
+              if (this.settings.unhighlight) {
+                for (i = 0; elements[i]; i++) {
+                  this.settings.unhighlight.call(
+                    this,
+                    elements[i],
+                    this.settings.errorClass,
+                    ""
+                  );
+                  this.findByName(elements[i].name).removeClass(this.settings.validClass);
+                }
+              } else {
+                elements.removeClass(this.settings.errorClass).removeClass(this.settings.validClass);
+              }
+            },
+            numberOfInvalids: function() {
+              return this.objectLength(this.invalid);
+            },
+            objectLength: function(obj) {
+              var count = 0, i;
+              for (i in obj) {
+                if (obj[i] !== void 0 && obj[i] !== null && obj[i] !== false) {
+                  count++;
+                }
+              }
+              return count;
+            },
+            hideErrors: function() {
+              this.hideThese(this.toHide);
+            },
+            addErrorAriaDescribedBy: function(element, error, updateGroupMembers) {
+              updateGroupMembers = updateGroupMembers === void 0 ? false : updateGroupMembers;
+              var errorID, v, group, describedBy = $2(element).attr("aria-describedby");
+              errorID = error.attr("id");
+              if (!describedBy) {
+                describedBy = errorID;
+              } else if (!describedBy.match(new RegExp("\\b" + this.escapeCssMeta(errorID) + "\\b"))) {
+                describedBy += " " + errorID;
+              }
+              $2(element).attr("aria-describedby", describedBy);
+              if (updateGroupMembers) {
+                group = this.groups[element.name];
+                if (group) {
+                  v = this;
+                  $2.each(v.groups, function(name, testgroup) {
+                    if (testgroup === group) {
+                      v.addErrorAriaDescribedBy($2("[name='" + v.escapeCssMeta(name) + "']", v.currentForm), error, false);
+                    }
+                  });
+                }
+              }
+            },
+            removeErrorAriaDescribedBy: function(element, error) {
+              var describedBy = $2(element).attr("aria-describedby"), describedByIds = describedBy.split(" "), errorID = error.attr("id"), ind = describedByIds.indexOf(errorID);
+              if (ind > -1) {
+                describedByIds.splice(ind, 1);
+              }
+              if (describedByIds.length) {
+                $2(element).attr("aria-describedby", describedByIds.join(" "));
+              } else {
+                $2(element).removeAttr("aria-describedby");
+              }
+            },
+            hideThese: function(errors) {
+              for (var i = 0; errors[i]; i++) {
+                var error = $2(errors[i]), errorID = error.attr("id") ? this.escapeCssMeta(error.attr("id")) : void 0, element = errorID ? this.elements().filter('[aria-describedby~="' + errorID + '"]') : [];
+                if (this.settings.ariaDescribedByCleanup && element.length) {
+                  this.removeErrorAriaDescribedBy(element, error);
+                }
+                if (!error.is(this.containers)) {
+                  error.text("");
+                }
+                this.addWrapper(error).hide();
+              }
+            },
+            valid: function() {
+              return this.size() === 0;
+            },
+            size: function() {
+              return this.errorList.length;
+            },
+            focusInvalid: function() {
+              if (this.settings.focusInvalid) {
+                try {
+                  $2(this.findLastActive() || this.errorList.length && this.errorList[0].element || []).filter(":visible").trigger("focus").trigger("focusin");
+                } catch (e) {
+                }
+              }
+            },
+            findLastActive: function() {
+              var lastActive = this.lastActive;
+              return lastActive && $2.grep(this.errorList, function(n) {
+                return n.element.name === lastActive.name;
+              }).length === 1 && lastActive;
+            },
+            elements: function() {
+              var validator = this, rulesCache = {}, selectors = ["input", "select", "textarea", "[contenteditable]"], formId = this.currentForm.id, elements;
+              elements = $2(this.currentForm).find(selectors.concat(this.settings.customElements).join(", ")).not(":submit, :reset, :image, :disabled").not(this.settings.ignore);
+              if (formId) {
+                elements = elements.add(
+                  $2(selectors.concat(this.settings.customElements).join(", ")).filter("[form='" + validator.escapeCssMeta(formId) + "']").not(":submit, :reset, :image, :disabled").not(this.settings.ignore)
+                );
+              }
+              return elements.filter(function() {
+                var name = this.name || $2(this).attr("name");
+                var isContentEditable = typeof $2(this).attr("contenteditable") !== "undefined" && $2(this).attr("contenteditable") !== "false";
+                if (!name && validator.settings.debug && window.console) {
+                  console.error("%o has no name assigned", this);
+                }
+                if (isContentEditable) {
+                  this.form = $2(this).closest("form")[0];
+                  this.name = name;
+                }
+                if (this.form !== validator.currentForm) {
+                  return false;
+                }
+                if (name in rulesCache || !validator.objectLength($2(this).rules())) {
+                  return false;
+                }
+                rulesCache[name] = true;
+                return true;
+              });
+            },
+            clean: function(selector) {
+              return $2(selector)[0];
+            },
+            errors: function() {
+              var errorClass = this.settings.errorClass.split(" ").join(".");
+              return $2(this.settings.errorElement + "." + errorClass, this.errorContext);
+            },
+            resetInternals: function() {
+              this.successList = [];
+              this.errorList = [];
+              this.errorMap = {};
+              this.toShow = $2([]);
+              this.toHide = $2([]);
+            },
+            reset: function() {
+              this.resetInternals();
+              this.currentElements = $2([]);
+            },
+            prepareForm: function() {
+              this.reset();
+              this.toHide = this.errors().add(this.containers);
+            },
+            prepareElement: function(element) {
+              this.reset();
+              this.toHide = this.errorsFor(element);
+            },
+            elementValue: function(element) {
+              var $element = $2(element), type = element.type, isContentEditable = typeof $element.attr("contenteditable") !== "undefined" && $element.attr("contenteditable") !== "false", val, idx;
+              if (type === "radio" || type === "checkbox") {
+                return this.findByName(element.name).filter(":checked").val();
+              } else if (type === "number" && typeof element.validity !== "undefined") {
+                return element.validity.badInput ? "NaN" : $element.val();
+              }
+              if (isContentEditable) {
+                val = $element.text();
+              } else {
+                val = $element.val();
+              }
+              if (type === "file") {
+                if (val.substr(0, 12) === "C:\\fakepath\\") {
+                  return val.substr(12);
+                }
+                idx = val.lastIndexOf("/");
+                if (idx >= 0) {
+                  return val.substr(idx + 1);
+                }
+                idx = val.lastIndexOf("\\");
+                if (idx >= 0) {
+                  return val.substr(idx + 1);
+                }
+                return val;
+              }
+              if (typeof val === "string") {
+                return val.replace(/\r/g, "");
+              }
+              return val;
+            },
+            check: function(element) {
+              element = this.validationTargetFor(this.clean(element));
+              var rules = $2(element).rules(), rulesCount = $2.map(rules, function(n, i) {
+                return i;
+              }).length, dependencyMismatch = false, val = this.elementValue(element), result, method, rule, normalizer;
+              this.abortRequest(element);
+              if (typeof rules.normalizer === "function") {
+                normalizer = rules.normalizer;
+              } else if (typeof this.settings.normalizer === "function") {
+                normalizer = this.settings.normalizer;
+              }
+              if (normalizer) {
+                val = normalizer.call(element, val);
+                delete rules.normalizer;
+              }
+              for (method in rules) {
+                rule = { method, parameters: rules[method] };
+                try {
+                  result = $2.validator.methods[method].call(this, val, element, rule.parameters);
+                  if (result === "dependency-mismatch" && rulesCount === 1) {
+                    dependencyMismatch = true;
+                    continue;
+                  }
+                  dependencyMismatch = false;
+                  if (result === "pending") {
+                    this.toHide = this.toHide.not(this.errorsFor(element));
+                    return;
+                  }
+                  if (!result) {
+                    this.formatAndAdd(element, rule);
+                    return false;
+                  }
+                } catch (e) {
+                  if (this.settings.debug && window.console) {
+                    console.log("Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.", e);
+                  }
+                  if (e instanceof TypeError) {
+                    e.message += ".  Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.";
+                  }
+                  throw e;
+                }
+              }
+              if (dependencyMismatch) {
+                return;
+              }
+              if (this.objectLength(rules)) {
+                this.successList.push(element);
+              }
+              return true;
+            },
+            // Return the custom message for the given element and validation method
+            // specified in the element's HTML5 data attribute
+            // return the generic message if present and no method specific message is present
+            customDataMessage: function(element, method) {
+              return $2(element).data("msg" + method.charAt(0).toUpperCase() + method.substring(1).toLowerCase()) || $2(element).data("msg");
+            },
+            // Return the custom message for the given element name and validation method
+            customMessage: function(name, method) {
+              var m = this.settings.messages[name];
+              return m && (m.constructor === String ? m : m[method]);
+            },
+            // Return the first defined argument, allowing empty strings
+            findDefined: function() {
+              for (var i = 0; i < arguments.length; i++) {
+                if (arguments[i] !== void 0) {
+                  return arguments[i];
+                }
+              }
+              return void 0;
+            },
+            // The second parameter 'rule' used to be a string, and extended to an object literal
+            // of the following form:
+            // rule = {
+            //     method: "method name",
+            //     parameters: "the given method parameters"
+            // }
+            //
+            // The old behavior still supported, kept to maintain backward compatibility with
+            // old code, and will be removed in the next major release.
+            defaultMessage: function(element, rule) {
+              if (typeof rule === "string") {
+                rule = { method: rule };
+              }
+              var message = this.findDefined(
+                this.customMessage(element.name, rule.method),
+                this.customDataMessage(element, rule.method),
+                // 'title' is never undefined, so handle empty string as undefined
+                !this.settings.ignoreTitle && element.title || void 0,
+                $2.validator.messages[rule.method],
+                "<strong>Warning: No message defined for " + element.name + "</strong>"
+              ), theregex = /\$?\{(\d+)\}/g;
+              if (typeof message === "function") {
+                message = message.call(this, rule.parameters, element);
+              } else if (theregex.test(message)) {
+                message = $2.validator.format(message.replace(theregex, "{$1}"), rule.parameters);
+              }
+              return message;
+            },
+            formatAndAdd: function(element, rule) {
+              var message = this.defaultMessage(element, rule);
+              this.errorList.push({
+                message,
+                element,
+                method: rule.method
+              });
+              this.errorMap[element.name] = message;
+              this.submitted[element.name] = message;
+            },
+            addWrapper: function(toToggle) {
+              if (this.settings.wrapper) {
+                toToggle = toToggle.add(toToggle.parent(this.settings.wrapper));
+              }
+              return toToggle;
+            },
+            defaultShowErrors: function() {
+              var i, elements, error;
+              for (i = 0; this.errorList[i]; i++) {
+                error = this.errorList[i];
+                if (this.settings.highlight) {
+                  this.settings.highlight.call(this, error.element, this.settings.errorClass, this.settings.validClass);
+                }
+                this.showLabel(error.element, error.message);
+              }
+              if (this.errorList.length) {
+                this.toShow = this.toShow.add(this.containers);
+              }
+              if (this.settings.success) {
+                for (i = 0; this.successList[i]; i++) {
+                  this.showLabel(this.successList[i]);
+                }
+              }
+              if (this.settings.unhighlight) {
+                for (i = 0, elements = this.validElements(); elements[i]; i++) {
+                  this.settings.unhighlight.call(this, elements[i], this.settings.errorClass, this.settings.validClass);
+                }
+              }
+              this.toHide = this.toHide.not(this.toShow);
+              this.hideErrors();
+              this.addWrapper(this.toShow).show();
+            },
+            validElements: function() {
+              return this.currentElements.not(this.invalidElements());
+            },
+            invalidElements: function() {
+              return $2(this.errorList).map(function() {
+                return this.element;
+              });
+            },
+            showLabel: function(element, message) {
+              var place, error = this.errorsFor(element), elementID = this.idOrName(element), describedBy = $2(element).attr("aria-describedby");
+              if (error.length) {
+                if (error.closest("label[for='" + this.escapeCssMeta(elementID) + "']").length === 0 && (describedBy === void 0 || describedBy.split(" ").indexOf(error.attr("id")) === -1)) {
+                  this.addErrorAriaDescribedBy(element, error, true);
+                }
+                error.removeClass(this.settings.validClass).addClass(this.settings.errorClass);
+                if (this.settings && this.settings.escapeHtml) {
+                  error.text(message || "");
+                } else {
+                  error.html(message || "");
+                }
+              } else {
+                error = $2("<" + this.settings.errorElement + ">").attr("id", elementID + "-error").addClass(this.settings.errorClass);
+                if (this.settings && this.settings.escapeHtml) {
+                  error.text(message || "");
+                } else {
+                  error.html(message || "");
+                }
+                place = error;
+                if (this.settings.wrapper) {
+                  place = error.hide().show().wrap("<" + this.settings.wrapper + "/>").parent();
+                }
+                if (this.labelContainer.length) {
+                  this.labelContainer.append(place);
+                } else if (this.settings.errorPlacement) {
+                  this.settings.errorPlacement.call(this, place, $2(element));
+                } else {
+                  place.insertAfter(element);
+                }
+                if (error.is("label")) {
+                  error.attr("for", elementID);
+                } else if (error.parents("label[for='" + this.escapeCssMeta(elementID) + "']").length === 0) {
+                  this.addErrorAriaDescribedBy(element, error, true);
+                }
+              }
+              if (!message && this.settings.success) {
+                error.text("");
+                if (typeof this.settings.success === "string") {
+                  error.addClass(this.settings.success);
+                } else {
+                  this.settings.success(error, element);
+                }
+              }
+              this.toShow = this.toShow.add(error);
+            },
+            errorsFor: function(element) {
+              var name = this.escapeCssMeta(this.idOrName(element)), describer = $2(element).attr("aria-describedby"), selector = "label[for='" + name + "'], label[for='" + name + "'] *";
+              if (describer) {
+                selector = selector + ", #" + this.escapeCssMeta(describer).replace(/\s+/g, ", #");
+              }
+              selector = selector + ", #" + name + "-error";
+              return this.errors().filter(selector);
+            },
+            // See https://api.jquery.com/category/selectors/, for CSS
+            // meta-characters that should be escaped in order to be used with JQuery
+            // as a literal part of a name/id or any selector.
+            escapeCssMeta: function(string) {
+              if (string === void 0) {
+                return "";
+              }
+              return string.replace(/([\\!"#$%&'()*+,./:;<=>?@\[\]^`{|}~])/g, "\\$1");
+            },
+            idOrName: function(element) {
+              return this.groups[element.name] || (this.checkable(element) ? element.name : element.id || element.name);
+            },
+            validationTargetFor: function(element) {
+              if (this.checkable(element)) {
+                element = this.findByName(element.name);
+              }
+              return $2(element).not(this.settings.ignore)[0];
+            },
+            checkable: function(element) {
+              return /radio|checkbox/i.test(element.type);
+            },
+            findByName: function(name) {
+              var formId = this.currentForm.id, selector = "[name='" + this.escapeCssMeta(name) + "']", elements = $2(this.currentForm).find(selector);
+              if (formId) {
+                elements = elements.add(
+                  $2(selector).filter("[form='" + this.escapeCssMeta(formId) + "']")
+                );
+              }
+              return elements;
+            },
+            getLength: function(value, element) {
+              switch (element.nodeName.toLowerCase()) {
+                case "select":
+                  return $2("option:selected", element).length;
+                case "input":
+                  if (this.checkable(element)) {
+                    return this.findByName(element.name).filter(":checked").length;
+                  }
+              }
+              return value.length;
+            },
+            depend: function(param, element) {
+              return this.dependTypes[typeof param] ? this.dependTypes[typeof param](param, element) : true;
+            },
+            dependTypes: {
+              "boolean": function(param) {
+                return param;
+              },
+              "string": function(param, element) {
+                return !!$2(param, element.form).length;
+              },
+              "function": function(param, element) {
+                return param(element);
+              }
+            },
+            optional: function(element) {
+              var val = this.elementValue(element);
+              return !$2.validator.methods.required.call(this, val, element) && "dependency-mismatch";
+            },
+            elementAjaxPort: function(element) {
+              return "validate" + element.name;
+            },
+            startRequest: function(element) {
+              if (!this.pending[element.name]) {
+                this.pendingRequest++;
+                $2(element).addClass(this.settings.pendingClass);
+                this.pending[element.name] = true;
+              }
+            },
+            stopRequest: function(element, valid) {
+              this.pendingRequest--;
+              if (this.pendingRequest < 0) {
+                this.pendingRequest = 0;
+              }
+              delete this.pending[element.name];
+              $2(element).removeClass(this.settings.pendingClass);
+              if (valid && this.pendingRequest === 0 && this.formSubmitted && this.form() && this.pendingRequest === 0) {
+                $2(this.currentForm).trigger("submit");
+                if (this.submitButton) {
+                  $2("input:hidden[name='" + this.submitButton.name + "']", this.currentForm).remove();
+                }
+                this.formSubmitted = false;
+              } else if (!valid && this.pendingRequest === 0 && this.formSubmitted) {
+                $2(this.currentForm).triggerHandler("invalid-form", [this]);
+                this.formSubmitted = false;
+              }
+            },
+            abortRequest: function(element) {
+              var port;
+              if (this.pending[element.name]) {
+                port = this.elementAjaxPort(element);
+                $2.ajaxAbort(port);
+                this.pendingRequest--;
+                if (this.pendingRequest < 0) {
+                  this.pendingRequest = 0;
+                }
+                delete this.pending[element.name];
+                $2(element).removeClass(this.settings.pendingClass);
+              }
+            },
+            previousValue: function(element, method) {
+              method = typeof method === "string" && method || "remote";
+              return $2.data(element, "previousValue") || $2.data(element, "previousValue", {
+                old: null,
+                valid: true,
+                message: this.defaultMessage(element, { method })
+              });
+            },
+            // Cleans up all forms and elements, removes validator-specific events
+            destroy: function() {
+              this.resetForm();
+              $2(this.currentForm).off(".validate").removeData("validator").find(".validate-equalTo-blur").off(".validate-equalTo").removeClass("validate-equalTo-blur").find(".validate-lessThan-blur").off(".validate-lessThan").removeClass("validate-lessThan-blur").find(".validate-lessThanEqual-blur").off(".validate-lessThanEqual").removeClass("validate-lessThanEqual-blur").find(".validate-greaterThanEqual-blur").off(".validate-greaterThanEqual").removeClass("validate-greaterThanEqual-blur").find(".validate-greaterThan-blur").off(".validate-greaterThan").removeClass("validate-greaterThan-blur");
+            }
+          },
+          classRuleSettings: {
+            required: { required: true },
+            email: { email: true },
+            url: { url: true },
+            date: { date: true },
+            dateISO: { dateISO: true },
+            number: { number: true },
+            digits: { digits: true },
+            creditcard: { creditcard: true }
+          },
+          addClassRules: function(className, rules) {
+            if (className.constructor === String) {
+              this.classRuleSettings[className] = rules;
+            } else {
+              $2.extend(this.classRuleSettings, className);
+            }
+          },
+          classRules: function(element) {
+            var rules = {}, classes = $2(element).attr("class");
+            if (classes) {
+              $2.each(classes.split(" "), function() {
+                if (this in $2.validator.classRuleSettings) {
+                  $2.extend(rules, $2.validator.classRuleSettings[this]);
+                }
+              });
+            }
+            return rules;
+          },
+          normalizeAttributeRule: function(rules, type, method, value) {
+            if (/min|max|step/.test(method) && (type === null || /number|range|text/.test(type))) {
+              value = Number(value);
+              if (isNaN(value)) {
+                value = void 0;
+              }
+            }
+            if (value || value === 0) {
+              rules[method] = value;
+            } else if (type === method && type !== "range") {
+              rules[type === "date" ? "dateISO" : method] = true;
+            }
+          },
+          attributeRules: function(element) {
+            var rules = {}, $element = $2(element), type = element.getAttribute("type"), method, value;
+            for (method in $2.validator.methods) {
+              if (method === "required") {
+                value = element.getAttribute(method);
+                if (value === "") {
+                  value = true;
+                }
+                value = !!value;
+              } else {
+                value = $element.attr(method);
+              }
+              this.normalizeAttributeRule(rules, type, method, value);
+            }
+            if (rules.maxlength && /-1|2147483647|524288/.test(rules.maxlength)) {
+              delete rules.maxlength;
+            }
+            return rules;
+          },
+          dataRules: function(element) {
+            var rules = {}, $element = $2(element), type = element.getAttribute("type"), method, value;
+            for (method in $2.validator.methods) {
+              value = $element.data("rule" + method.charAt(0).toUpperCase() + method.substring(1).toLowerCase());
+              if (value === "") {
+                value = true;
+              }
+              this.normalizeAttributeRule(rules, type, method, value);
+            }
+            return rules;
+          },
+          staticRules: function(element) {
+            var rules = {}, validator = $2.data(element.form, "validator");
+            if (validator.settings.rules) {
+              rules = $2.validator.normalizeRule(validator.settings.rules[element.name]) || {};
+            }
+            return rules;
+          },
+          normalizeRules: function(rules, element) {
+            $2.each(rules, function(prop, val) {
+              if (val === false) {
+                delete rules[prop];
+                return;
+              }
+              if (val.param || val.depends) {
+                var keepRule = true;
+                switch (typeof val.depends) {
+                  case "string":
+                    keepRule = !!$2(val.depends, element.form).length;
+                    break;
+                  case "function":
+                    keepRule = val.depends.call(element, element);
+                    break;
+                }
+                if (keepRule) {
+                  rules[prop] = val.param !== void 0 ? val.param : true;
+                } else {
+                  $2.data(element.form, "validator").resetElements($2(element));
+                  delete rules[prop];
+                }
+              }
+            });
+            $2.each(rules, function(rule, parameter) {
+              rules[rule] = typeof parameter === "function" && rule !== "normalizer" ? parameter(element) : parameter;
+            });
+            $2.each(["minlength", "maxlength"], function() {
+              if (rules[this]) {
+                rules[this] = Number(rules[this]);
+              }
+            });
+            $2.each(["rangelength", "range"], function() {
+              var parts;
+              if (rules[this]) {
+                if (Array.isArray(rules[this])) {
+                  rules[this] = [Number(rules[this][0]), Number(rules[this][1])];
+                } else if (typeof rules[this] === "string") {
+                  parts = rules[this].replace(/[\[\]]/g, "").split(/[\s,]+/);
+                  rules[this] = [Number(parts[0]), Number(parts[1])];
+                }
+              }
+            });
+            if ($2.validator.autoCreateRanges) {
+              if (rules.min != null && rules.max != null) {
+                rules.range = [rules.min, rules.max];
+                delete rules.min;
+                delete rules.max;
+              }
+              if (rules.minlength != null && rules.maxlength != null) {
+                rules.rangelength = [rules.minlength, rules.maxlength];
+                delete rules.minlength;
+                delete rules.maxlength;
+              }
+            }
+            return rules;
+          },
+          // Converts a simple string to a {string: true} rule, e.g., "required" to {required:true}
+          normalizeRule: function(data) {
+            if (typeof data === "string") {
+              var transformed = {};
+              $2.each(data.split(/\s/), function() {
+                transformed[this] = true;
+              });
+              data = transformed;
+            }
+            return data;
+          },
+          // https://jqueryvalidation.org/jQuery.validator.addMethod/
+          addMethod: function(name, method, message) {
+            $2.validator.methods[name] = method;
+            $2.validator.messages[name] = message !== void 0 ? message : $2.validator.messages[name];
+            if (method.length < 3) {
+              $2.validator.addClassRules(name, $2.validator.normalizeRule(name));
+            }
+          },
+          // https://jqueryvalidation.org/jQuery.validator.methods/
+          methods: {
+            // https://jqueryvalidation.org/required-method/
+            required: function(value, element, param) {
+              if (!this.depend(param, element)) {
+                return "dependency-mismatch";
+              }
+              if (element.nodeName.toLowerCase() === "select") {
+                var val = $2(element).val();
+                return val && val.length > 0;
+              }
+              if (this.checkable(element)) {
+                return this.getLength(value, element) > 0;
+              }
+              return value !== void 0 && value !== null && value.length > 0;
+            },
+            // https://jqueryvalidation.org/email-method/
+            email: function(value, element) {
+              return this.optional(element) || /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(value);
+            },
+            // https://jqueryvalidation.org/url-method/
+            url: function(value, element) {
+              return this.optional(element) || /^(?:(?:(?:https?|ftp):)?\/\/)(?:(?:[^\]\[?\/<~#`!@$^&*()+=}|:";',>{ ]|%[0-9A-Fa-f]{2})+(?::(?:[^\]\[?\/<~#`!@$^&*()+=}|:";',>{ ]|%[0-9A-Fa-f]{2})*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i.test(value);
+            },
+            // https://jqueryvalidation.org/date-method/
+            date: /* @__PURE__ */ (function() {
+              var called = false;
+              return function(value, element) {
+                if (!called) {
+                  called = true;
+                  if (this.settings.debug && window.console) {
+                    console.warn(
+                      "The `date` method is deprecated and will be removed in version '2.0.0'.\nPlease don't use it, since it relies on the Date constructor, which\nbehaves very differently across browsers and locales. Use `dateISO`\ninstead or one of the locale specific methods in `localizations/`\nand `additional-methods.js`."
+                    );
+                  }
+                }
+                return this.optional(element) || !/Invalid|NaN/.test(new Date(value).toString());
+              };
+            })(),
+            // https://jqueryvalidation.org/dateISO-method/
+            dateISO: function(value, element) {
+              return this.optional(element) || /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test(value);
+            },
+            // https://jqueryvalidation.org/number-method/
+            number: function(value, element) {
+              return this.optional(element) || /^(?:-?\d+|-?\d{1,3}(?:,\d{3})+)?(?:-?\.\d+)?$/.test(value);
+            },
+            // https://jqueryvalidation.org/digits-method/
+            digits: function(value, element) {
+              return this.optional(element) || /^\d+$/.test(value);
+            },
+            // https://jqueryvalidation.org/minlength-method/
+            minlength: function(value, element, param) {
+              var length = Array.isArray(value) ? value.length : this.getLength(value, element);
+              return this.optional(element) || length >= param;
+            },
+            // https://jqueryvalidation.org/maxlength-method/
+            maxlength: function(value, element, param) {
+              var length = Array.isArray(value) ? value.length : this.getLength(value, element);
+              return this.optional(element) || length <= param;
+            },
+            // https://jqueryvalidation.org/rangelength-method/
+            rangelength: function(value, element, param) {
+              var length = Array.isArray(value) ? value.length : this.getLength(value, element);
+              return this.optional(element) || length >= param[0] && length <= param[1];
+            },
+            // https://jqueryvalidation.org/min-method/
+            min: function(value, element, param) {
+              return this.optional(element) || value >= param;
+            },
+            // https://jqueryvalidation.org/max-method/
+            max: function(value, element, param) {
+              return this.optional(element) || value <= param;
+            },
+            // https://jqueryvalidation.org/range-method/
+            range: function(value, element, param) {
+              return this.optional(element) || value >= param[0] && value <= param[1];
+            },
+            // https://jqueryvalidation.org/step-method/
+            step: function(value, element, param) {
+              var type = $2(element).attr("type"), errorMessage = "Step attribute on input type " + type + " is not supported.", supportedTypes = ["text", "number", "range"], re = new RegExp("\\b" + type + "\\b"), notSupported = type && !re.test(supportedTypes.join()), decimalPlaces = function(num) {
+                var match = ("" + num).match(/(?:\.(\d+))?$/);
+                if (!match) {
+                  return 0;
+                }
+                return match[1] ? match[1].length : 0;
+              }, toInt = function(num) {
+                return Math.round(num * Math.pow(10, decimals));
+              }, valid = true, decimals;
+              if (notSupported) {
+                throw new Error(errorMessage);
+              }
+              decimals = decimalPlaces(param);
+              if (decimalPlaces(value) > decimals || toInt(value) % toInt(param) !== 0) {
+                valid = false;
+              }
+              return this.optional(element) || valid;
+            },
+            // https://jqueryvalidation.org/equalTo-method/
+            equalTo: function(value, element, param) {
+              var target = $2(param);
+              if (this.settings.onfocusout && target.not(".validate-equalTo-blur").length) {
+                target.addClass("validate-equalTo-blur").on("blur.validate-equalTo", function() {
+                  $2(element).valid();
+                });
+              }
+              return value === target.val();
+            },
+            // https://jqueryvalidation.org/remote-method/
+            remote: function(value, element, param, method) {
+              if (this.optional(element)) {
+                return "dependency-mismatch";
+              }
+              method = typeof method === "string" && method || "remote";
+              var previous = this.previousValue(element, method), validator, data, optionDataString;
+              if (!this.settings.messages[element.name]) {
+                this.settings.messages[element.name] = {};
+              }
+              previous.originalMessage = previous.originalMessage || this.settings.messages[element.name][method];
+              this.settings.messages[element.name][method] = previous.message;
+              param = typeof param === "string" && { url: param } || param;
+              optionDataString = $2.param($2.extend({ data: value }, param.data));
+              if (previous.valid !== null && previous.old === optionDataString) {
+                return previous.valid;
+              }
+              previous.old = optionDataString;
+              previous.valid = null;
+              validator = this;
+              this.startRequest(element);
+              data = {};
+              data[element.name] = value;
+              $2.ajax($2.extend(true, {
+                mode: "abort",
+                port: this.elementAjaxPort(element),
+                dataType: "json",
+                data,
+                context: validator.currentForm,
+                success: function(response) {
+                  var valid = response === true || response === "true", errors, message, submitted;
+                  validator.settings.messages[element.name][method] = previous.originalMessage;
+                  if (valid) {
+                    submitted = validator.formSubmitted;
+                    validator.toHide = validator.errorsFor(element);
+                    validator.formSubmitted = submitted;
+                    validator.successList.push(element);
+                    validator.invalid[element.name] = false;
+                    validator.showErrors();
+                  } else {
+                    errors = {};
+                    message = response || validator.defaultMessage(element, { method, parameters: value });
+                    errors[element.name] = previous.message = message;
+                    validator.invalid[element.name] = true;
+                    validator.showErrors(errors);
+                  }
+                  previous.valid = valid;
+                  validator.stopRequest(element, valid);
+                }
+              }, param));
+              return "pending";
+            }
+          }
+        });
+        var pendingRequests = {}, ajax;
+        if ($2.ajaxPrefilter) {
+          $2.ajaxPrefilter(function(settings, _, xhr) {
+            var port = settings.port;
+            if (settings.mode === "abort") {
+              $2.ajaxAbort(port);
+              pendingRequests[port] = xhr;
+            }
+          });
+        } else {
+          ajax = $2.ajax;
+          $2.ajax = function(settings) {
+            var mode = ("mode" in settings ? settings : $2.ajaxSettings).mode, port = ("port" in settings ? settings : $2.ajaxSettings).port;
+            if (mode === "abort") {
+              $2.ajaxAbort(port);
+              pendingRequests[port] = ajax.apply(this, arguments);
+              return pendingRequests[port];
+            }
+            return ajax.apply(this, arguments);
+          };
+        }
+        $2.ajaxAbort = function(port) {
+          if (pendingRequests[port]) {
+            pendingRequests[port].abort();
+            delete pendingRequests[port];
+          }
+        };
+        return $2;
+      });
+    }
+  });
+
   // node_modules/jquery-validation-unobtrusive/dist/jquery.validate.unobtrusive.js
   var require_jquery_validate_unobtrusive = __commonJS({
     "node_modules/jquery-validation-unobtrusive/dist/jquery.validate.unobtrusive.js"(exports, module) {
@@ -7643,7 +8947,7 @@
         if (typeof define === "function" && define.amd) {
           define("jquery.validate.unobtrusive", ["jquery-validation"], factory);
         } else if (typeof module === "object" && module.exports) {
-          module.exports = factory(require_jquery_validate());
+          module.exports = factory(require_jquery_validate2());
         } else {
           jQuery.validator.unobtrusive = factory(jQuery);
         }
@@ -7941,6 +9245,16 @@ jquery-validation/dist/jquery.validate.js:
    * Released under the MIT license
    *)
 
+jquery-validation/dist/jquery.validate.js:
+  (*!
+   * jQuery Validation Plugin v1.22.0
+   *
+   * https://jqueryvalidation.org/
+   *
+   * Copyright (c) 2026 Jörn Zaefferer
+   * Released under the MIT license
+   *)
+
 jquery-validation-unobtrusive/dist/jquery.validate.unobtrusive.js:
   (**
    * @license