@visiion/forms-library 1.0.0

package/dist/index.js

@@ -0,0 +1,2840 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+var __assign$1 = function() {
+    __assign$1 = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$1.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var DefaultContext = {
+  color: undefined,
+  size: undefined,
+  className: undefined,
+  style: undefined,
+  attr: undefined
+};
+var IconContext = React.createContext && React.createContext(DefaultContext);
+
+var __assign = undefined && undefined.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __rest = undefined && undefined.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+function Tree2Element(tree) {
+  return tree && tree.map(function (node, i) {
+    return React.createElement(node.tag, __assign({
+      key: i
+    }, node.attr), Tree2Element(node.child));
+  });
+}
+function GenIcon(data) {
+  // eslint-disable-next-line react/display-name
+  return function (props) {
+    return React.createElement(IconBase, __assign({
+      attr: __assign({}, data.attr)
+    }, props), Tree2Element(data.child));
+  };
+}
+function IconBase(props) {
+  var elem = function (conf) {
+    var attr = props.attr,
+      size = props.size,
+      title = props.title,
+      svgProps = __rest(props, ["attr", "size", "title"]);
+    var computedSize = size || conf.size || "1em";
+    var className;
+    if (conf.className) className = conf.className;
+    if (props.className) className = (className ? className + " " : "") + props.className;
+    return React.createElement("svg", __assign({
+      stroke: "currentColor",
+      fill: "currentColor",
+      strokeWidth: "0"
+    }, conf.attr, attr, svgProps, {
+      className: className,
+      style: __assign(__assign({
+        color: props.color || conf.color
+      }, conf.style), props.style),
+      height: computedSize,
+      width: computedSize,
+      xmlns: "http://www.w3.org/2000/svg"
+    }), title && React.createElement("title", null, title), props.children);
+  };
+  return IconContext !== undefined ? React.createElement(IconContext.Consumer, null, function (conf) {
+    return elem(conf);
+  }) : elem(DefaultContext);
+}
+
+// THIS FILE IS AUTO GENERATED
+function IoHelpCircle (props) {
+  return GenIcon({"attr":{"viewBox":"0 0 512 512"},"child":[{"tag":"path","attr":{"d":"M256 64C150 64 64 150 64 256s86 192 192 192 192-86 192-192S362 64 256 64zm-6 304a20 20 0 1120-20 20 20 0 01-20 20zm33.44-102C267.23 276.88 265 286.85 265 296a14 14 0 01-28 0c0-21.91 10.08-39.33 30.82-53.26C287.1 229.8 298 221.6 298 203.57c0-12.26-7-21.57-21.49-28.46-3.41-1.62-11-3.2-20.34-3.09-11.72.15-20.82 2.95-27.83 8.59C215.12 191.25 214 202.83 214 203a14 14 0 11-28-1.35c.11-2.43 1.8-24.32 24.77-42.8 11.91-9.58 27.06-14.56 45-14.78 12.7-.15 24.63 2 32.72 5.82C312.7 161.34 326 180.43 326 203.57c0 33.83-22.61 49.02-42.56 62.43z"}}]})(props);
+}
+
+var InputWrapper = function (_a) {
+    var label = _a.label, error = _a.error, tooltip = _a.tooltip, required = _a.required, children = _a.children, _b = _a.className, className = _b === void 0 ? '' : _b;
+    return (jsxRuntime.jsxs("fieldset", { className: "flex max-w-1xl mx-auto flex-col gap-4 w-full ".concat(className), children: [label && (jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [jsxRuntime.jsxs("label", { className: "font-roboto font-medium text-gray-700 text-sm leading-4", children: [label, required && jsxRuntime.jsx("span", { className: "text-red-500 ml-1", children: "*" })] }), tooltip && (jsxRuntime.jsxs("div", { className: "relative group flex-shrink-0", children: [jsxRuntime.jsx(IoHelpCircle, { className: "w-5 h-5 text-gray-400 cursor-help" }), jsxRuntime.jsxs("div", { className: "absolute left-full top-1/2 transform -translate-y-1/2 ml-2 px-3 py-2 bg-gray-800 text-white text-sm rounded-lg opacity-0 group-hover:opacity-100 transition-opacity duration-200 pointer-events-none whitespace-nowrap z-10", children: [tooltip, jsxRuntime.jsx("div", { className: "absolute top-1/2 right-full transform -translate-y-1/2 w-0 h-0 border-t-4 border-b-4 border-r-4 border-transparent border-r-gray-800" })] })] }))] })), children, error && (jsxRuntime.jsx("p", { className: "text-red-500 text-xs mt-1", children: error }))] }));
+};
+
+var TextInput = function (_a) {
+    var field = _a.field, value = _a.value, onChange = _a.onChange, error = _a.error;
+    return (jsxRuntime.jsx(InputWrapper, { label: field.label, error: error, tooltip: field.tooltip, required: field.required, children: jsxRuntime.jsxs("div", { className: "relative", children: [jsxRuntime.jsx("input", { id: field.id, name: field.name, type: "text", placeholder: field.placeholder, value: value || '', onChange: onChange, disabled: field.disabled, required: field.required, minLength: field.minLength, maxLength: field.maxLength, className: "w-full px-3 py-2 font-roboto font-normal text-gray-800 text-sm border rounded-md focus:outline-none focus:ring-2 focus:ring-orange-500 ".concat(error ? 'border-red-500' : 'border-gray-300', " ").concat(field.disabled ? 'bg-gray-100 cursor-not-allowed' : '') }), field.addon && (jsxRuntime.jsx("span", { className: "absolute right-3 top-1/2 transform -translate-y-1/2 text-gray-500 text-sm", children: field.addon }))] }) }));
+};
+
+var SelectInput = function (_a) {
+    var _b;
+    var field = _a.field, value = _a.value, onChange = _a.onChange, error = _a.error;
+    return (jsxRuntime.jsx(InputWrapper, { label: field.label, error: error, tooltip: field.tooltip, required: field.required, children: jsxRuntime.jsxs("select", { id: field.id, name: field.name, value: value || '', onChange: onChange, disabled: field.disabled, required: field.required, className: "w-full px-3 py-2 font-roboto font-normal text-gray-800 text-sm border rounded-md focus:outline-none focus:ring-2 focus:ring-orange-500 ".concat(error ? 'border-red-500' : 'border-gray-300', " ").concat(field.disabled ? 'bg-gray-100 cursor-not-allowed' : ''), children: [jsxRuntime.jsx("option", { value: "", children: field.placeholder || 'Seleccione una opción' }), Array.isArray(field === null || field === void 0 ? void 0 : field.options) &&
+                    ((_b = field === null || field === void 0 ? void 0 : field.options) === null || _b === void 0 ? void 0 : _b.map(function (option) { return (jsxRuntime.jsx("option", { value: option.value, children: option.label }, option.value)); }))] }) }));
+};
+
+var CheckboxInput = function (_a) {
+    var field = _a.field, value = _a.value, onChange = _a.onChange, error = _a.error;
+    return (jsxRuntime.jsxs("div", { className: "flex flex-col gap-2", children: [jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [jsxRuntime.jsx("input", { id: field.id, name: field.name, type: "checkbox", checked: value || false, onChange: onChange, disabled: field.disabled, required: field.required, className: "w-4 h-4 text-orange-600 border-gray-300 rounded focus:ring-orange-500" }), jsxRuntime.jsxs("label", { htmlFor: field.id, className: "font-medium text-gray-700 cursor-pointer", children: [field.label, field.required && jsxRuntime.jsx("span", { className: "text-red-500 ml-1", children: "*" })] })] }), error && jsxRuntime.jsx("span", { className: "text-red-500 text-xs", children: error })] }));
+};
+
+var TextareaInput = function (_a) {
+    var field = _a.field, _b = _a.value, value = _b === void 0 ? '' : _b, onChange = _a.onChange, error = _a.error, id = _a.id, name = _a.name, label = _a.label, placeholder = _a.placeholder, className = _a.className, disabled = _a.disabled, required = _a.required, _c = _a.maxLength, maxLength = _c === void 0 ? 500 : _c, _d = _a.rows, rows = _d === void 0 ? 4 : _d, tooltip = _a.tooltip;
+    var _e = React.useState(value.length), charCount = _e[0], setCharCount = _e[1];
+    // Si se pasa un field, usar sus propiedades
+    var finalId = id || (field === null || field === void 0 ? void 0 : field.id);
+    var finalName = name || (field === null || field === void 0 ? void 0 : field.name);
+    var finalLabel = label || (field === null || field === void 0 ? void 0 : field.label);
+    var finalPlaceholder = placeholder || (field === null || field === void 0 ? void 0 : field.placeholder);
+    var finalDisabled = disabled !== undefined ? disabled : field === null || field === void 0 ? void 0 : field.disabled;
+    var finalRequired = required !== undefined ? required : field === null || field === void 0 ? void 0 : field.required;
+    var finalMaxLength = maxLength || (field === null || field === void 0 ? void 0 : field.maxLength) || 500;
+    var finalTooltip = tooltip || (field === null || field === void 0 ? void 0 : field.tooltip);
+    React.useEffect(function () {
+        setCharCount(value.length);
+    }, [value]);
+    var handleChange = function (e) {
+        var newValue = e.target.value;
+        if (newValue.length <= finalMaxLength) {
+            setCharCount(newValue.length);
+            if (onChange) {
+                // Crear un evento sintético compatible
+                var syntheticEvent = __assign$1(__assign$1({}, e), { target: __assign$1(__assign$1({}, e.target), { name: finalName || '', value: newValue }) });
+                onChange(syntheticEvent);
+            }
+        }
+    };
+    return (jsxRuntime.jsx(InputWrapper, { label: finalLabel, tooltip: finalTooltip, required: finalRequired, error: error, children: jsxRuntime.jsxs("div", { className: "space-y-2", children: [jsxRuntime.jsx("textarea", { id: finalId, name: finalName, placeholder: finalPlaceholder, value: value, onChange: handleChange, disabled: finalDisabled, required: finalRequired, rows: rows, className: "w-full px-3 py-2 font-roboto font-normal text-gray-800 text-sm border rounded-md focus:outline-none focus:ring-2 focus:ring-orange-500 resize-none ".concat(error ? 'border-red-500' : 'border-gray-300', " ").concat(finalDisabled ? 'bg-gray-100 cursor-not-allowed' : '', " ").concat(className || '') }), jsxRuntime.jsxs("div", { className: "flex justify-end text-gray-400 text-sm", children: [charCount, "/", finalMaxLength] })] }) }));
+};
+
+function clean(rut) {
+    return typeof rut === 'string' ? rut.replace(/^0+|[^0-9kK]+/g, '').toUpperCase() : '';
+}
+function formatRut(rut) {
+    rut = clean(rut);
+    var result = '';
+    if (rut.length > 0) {
+        result = "".concat(rut.slice(-4, -1), "-").concat(rut.substr(rut.length - 1));
+    }
+    for (var i = 4; i < rut.length; i += 3) {
+        result = "".concat(rut.slice(-3 - i, -i), ".").concat(result);
+    }
+    return result;
+}
+var serialRegex = /^[a-zA-Z0-9]+$/;
+var validateOnlyNumbersAndLetters = function (value) {
+    if (value === '')
+        return true;
+    return serialRegex.test(value);
+};
+function validate(rut) {
+    if (typeof rut !== 'string') {
+        return false;
+    }
+    if (!/^0*(\d{1,3}(\.?\d{3})*)-?([\dkK])$/.test(rut)) {
+        return false;
+    }
+    rut = clean(rut);
+    var t = parseInt(rut.slice(0, -1), 10);
+    var m = 0;
+    var s = 1;
+    while (t > 0) {
+        // eslint-disable-next-line
+        s = (s + (t % 10) * (9 - (m++ % 6))) % 11;
+        t = Math.floor(t / 10);
+    }
+    var v = s > 0 ? "".concat(s - 1) : 'k';
+    return v.toLowerCase() === rut.slice(-1).toLowerCase();
+}
+/**
+ * Enmascara un RUT ocultando los dígitos del medio
+ * @param rut - RUT formateado (ej: "19.178.946-6")
+ * @returns RUT enmascarado (ej: "19.178.XXX-6")
+ */
+function maskRut(rut) {
+    if (!rut || typeof rut !== 'string') {
+        return '';
+    }
+    // Limpiar el RUT para obtener solo números y dígito verificador
+    var cleanRut = clean(rut);
+    if (cleanRut.length < 2) {
+        return rut;
+    }
+    // Separar el dígito verificador
+    var numbers = cleanRut.slice(0, -1);
+    // Si el RUT tiene menos de 4 dígitos, no enmascarar
+    if (numbers.length < 4) {
+        return formatRut(cleanRut);
+    }
+    // Mantener la estructura completa pero enmascarar los dígitos del medio
+    var maskedRut = '';
+    if (numbers.length <= 3) {
+        // Para RUTs de 3 dígitos o menos
+        maskedRut = "".concat(numbers, "XXX-X");
+    }
+    else if (numbers.length <= 6) {
+        // Para RUTs de 4-6 dígitos: XX.XXX-X
+        var firstPart = numbers.slice(0, 2);
+        maskedRut = "".concat(firstPart, ".XXX-X");
+    }
+    else if (numbers.length === 7) {
+        // Para RUTs de 7 dígitos: X.XXX.XXX-X
+        var firstPart = numbers.slice(0, 1);
+        var secondPart = numbers.slice(1, 4);
+        maskedRut = "".concat(firstPart, ".").concat(secondPart, ".XXX-X");
+    }
+    else if (numbers.length === 8) {
+        // Para RUTs de 8 dígitos: XX.XXX.XXX-X
+        var firstPart = numbers.slice(0, 2);
+        var secondPart = numbers.slice(2, 5);
+        maskedRut = "".concat(firstPart, ".").concat(secondPart, ".XXX-X");
+    }
+    else if (numbers.length <= 9) {
+        // Para RUTs de 9 dígitos: XXX.XXX-X
+        var firstPart = numbers.slice(0, 3);
+        maskedRut = "".concat(firstPart, ".XXX-X");
+    }
+    else {
+        // Para RUTs de más de 9 dígitos: XX.XXX.XXX-X
+        var firstPart = numbers.slice(0, 2);
+        var secondPart = numbers.slice(2, 5);
+        maskedRut = "".concat(firstPart, ".").concat(secondPart, ".XXX-X");
+    }
+    return maskedRut;
+}
+
+var RutInput = function (_a) {
+    var field = _a.field, value = _a.value, onChange = _a.onChange, error = _a.error, onSearch = _a.onSearch, _b = _a.disabled, disabled = _b === void 0 ? false : _b, _c = _a.placeholder, placeholder = _c === void 0 ? '0.000.000-0' : _c, _d = _a.minLength, minLength = _d === void 0 ? 12 : _d, _e = _a.maxLength, maxLength = _e === void 0 ? 12 : _e;
+    var inputRef = React.useRef(null);
+    var _f = React.useState(false), isValidRut = _f[0], setIsValidRut = _f[1];
+    var _g = React.useState(clean(value)), displayValue = _g[0], setDisplayValue = _g[1];
+    React.useEffect(function () {
+        setIsValidRut(validate(clean(value)));
+        setDisplayValue(formatRut(clean(value)));
+    }, [value]);
+    // Validar RUT en tiempo real
+    var handleRutChange = function (e) {
+        var rutValue = e.target.value;
+        setIsValidRut(validate(clean(rutValue)));
+        onChange(e);
+    };
+    // Manejar búsqueda
+    var handleSearch = function () {
+        if (onSearch && value && isValidRut) {
+            onSearch(clean(displayValue));
+        }
+    };
+    // Manejar tecla Enter para búsqueda
+    var handleKeyDown = function (e) {
+        if (e.key === 'Enter' && onSearch && value && isValidRut) {
+            e.preventDefault();
+            onSearch(clean(displayValue));
+        }
+    };
+    return (jsxRuntime.jsxs(InputWrapper, { label: field.label, tooltip: field.tooltip, required: field.required, error: error, children: [jsxRuntime.jsxs("div", { className: "flex", children: [jsxRuntime.jsx("input", { ref: inputRef, id: field.id, name: field.name, type: "text", value: displayValue || '', onChange: handleRutChange, onKeyDown: handleKeyDown, placeholder: placeholder, minLength: minLength, maxLength: maxLength, disabled: disabled, className: "flex-1 px-3 py-2 border rounded-l-md focus:outline-none focus:ring-2 focus:ring-orange-500 h-10 ".concat(error ? 'border-red-500' : 'border-gray-300', " ").concat(disabled ? 'bg-gray-100 cursor-not-allowed' : '') }), onSearch && (jsxRuntime.jsx("button", { type: "button", onClick: handleSearch, disabled: !isValidRut || disabled, className: "flex items-center justify-center w-10 h-10 rounded-r-md border-l-0 border bg-blue-600 text-white hover:bg-blue-700 disabled:bg-gray-400 disabled:cursor-not-allowed ".concat(error ? 'border-red-500' : 'border-gray-300'), children: jsxRuntime.jsx("svg", { className: "w-5 h-5", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z" }) }) }))] }), displayValue && !error && (jsxRuntime.jsx("span", { className: "text-sm ".concat(isValidRut ? 'text-green-600' : 'text-orange-600'), children: isValidRut ? '✓ RUT válido' : '⚠ Verificar formato del RUT' }))] }));
+};
+
+var Alert = function (_a) {
+    var _b = _a.type, type = _b === void 0 ? 'info' : _b, text = _a.text, icon = _a.icon, _c = _a.className, className = _c === void 0 ? '' : _c, _d = _a.iconClassName, iconClassName = _d === void 0 ? 'w-5 h-5' : _d, _e = _a.textClassName, textClassName = _e === void 0 ? 'ml-2 text-sm' : _e;
+    var getAlertStyles = function () {
+        switch (type) {
+            case 'info':
+                return 'bg-blue-50 border-blue-200 text-blue-800';
+            case 'warning':
+                return 'bg-yellow-50 border-yellow-200 text-yellow-800';
+            case 'error':
+                return 'bg-red-50 border-red-200 text-red-800';
+            default:
+                return 'bg-blue-50 border-blue-200 text-blue-800';
+        }
+    };
+    var getIcon = function () {
+        if (icon) {
+            if (typeof icon === 'string') {
+                return (jsxRuntime.jsx("span", { className: iconClassName, dangerouslySetInnerHTML: { __html: icon } }));
+            }
+            return React.createElement(icon, { className: iconClassName });
+        }
+        // Iconos por defecto
+        switch (type) {
+            case 'info':
+                return (jsxRuntime.jsx("svg", { className: iconClassName, fill: "currentColor", viewBox: "0 0 20 20", children: jsxRuntime.jsx("path", { fillRule: "evenodd", d: "M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a1 1 0 000 2v3a1 1 0 001 1h1a1 1 0 100-2v-3a1 1 0 00-1-1H9z", clipRule: "evenodd" }) }));
+            case 'warning':
+                return (jsxRuntime.jsx("svg", { className: iconClassName, fill: "currentColor", viewBox: "0 0 20 20", children: jsxRuntime.jsx("path", { fillRule: "evenodd", d: "M8.257 3.099c.765-1.36 2.722-1.36 3.486 0l5.58 9.92c.75 1.334-.213 2.98-1.742 2.98H4.42c-1.53 0-2.493-1.646-1.743-2.98l5.58-9.92zM11 13a1 1 0 11-2 0 1 1 0 012 0zm-1-8a1 1 0 00-1 1v3a1 1 0 002 0V6a1 1 0 00-1-1z", clipRule: "evenodd" }) }));
+            case 'error':
+                return (jsxRuntime.jsx("svg", { className: iconClassName, fill: "currentColor", viewBox: "0 0 20 20", children: jsxRuntime.jsx("path", { fillRule: "evenodd", d: "M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z", clipRule: "evenodd" }) }));
+            default:
+                return null;
+        }
+    };
+    return (jsxRuntime.jsxs("div", { className: "flex items-center p-4 border rounded-lg ".concat(getAlertStyles(), " ").concat(className), children: [getIcon(), jsxRuntime.jsx("span", { className: textClassName, dangerouslySetInnerHTML: { __html: text || '' } })] }));
+};
+
+var DynamicInput = function (_a) {
+    var _b, _c;
+    var field = _a.field, value = _a.value, onChange = _a.onChange, error = _a.error;
+    switch (field.type) {
+        case 'select':
+            return (jsxRuntime.jsx(SelectInput, { field: field, value: value, onChange: onChange, error: error }));
+        case 'textarea':
+            return (jsxRuntime.jsx(TextareaInput, { field: field, value: value, onChange: onChange, error: error }));
+        case 'checkbox':
+            return (jsxRuntime.jsx(CheckboxInput, { field: field, value: value, onChange: onChange, error: error }));
+        case 'rut':
+            return (jsxRuntime.jsx(RutInput, { field: field, value: value, onChange: onChange, error: error, onSearch: field.onSearch, disabled: field.disabled, placeholder: field.placeholder, minLength: field.minLength, maxLength: field.maxLength }));
+        case 'alert':
+            return jsxRuntime.jsx(Alert, __assign$1({}, field.props));
+        case 'subtitle':
+            return (jsxRuntime.jsxs("div", { className: "col-span-12", children: [jsxRuntime.jsx("h3", { className: "text-xl font-bold text-gray-800 mb-2", children: ((_b = field.props) === null || _b === void 0 ? void 0 : _b.title) || field.label }), ((_c = field.props) === null || _c === void 0 ? void 0 : _c.description) && (jsxRuntime.jsx("p", { className: "text-gray-600", children: field.props.description }))] }));
+        case 'text':
+        default:
+            return (jsxRuntime.jsx(TextInput, { field: field, value: value, onChange: onChange, error: error }));
+    }
+};
+
+var NavigationButton = function (_a) {
+    var direction = _a.direction, onClick = _a.onClick, _b = _a.disabled, disabled = _b === void 0 ? false : _b, _c = _a.label, label = _c === void 0 ? '' : _c;
+    var getButtonProps = function () {
+        switch (direction) {
+            case 'default':
+                return {
+                    className: "flex items-center align-middle text-nowrap w-fit h-[40px] px-4 py-2 bg-white text-[16px] rounded border border-blue-600 text-blue-600 font-medium font-['Roboto'] hover:bg-blue-50 disabled:opacity-50 disabled:cursor-not-allowed",
+                    label: label || 'Volver',
+                };
+            case 'next':
+                return {
+                    className: "flex items-center align-middle text-nowrap bg-blue-600 disabled:bg-gray-400 w-fit h-[40px] px-4 py-2 rounded border text-lg font-medium font-['Roboto'] text-white hover:bg-blue-700 disabled:cursor-not-allowed",
+                    label: label || 'Siguiente',
+                    icon: (jsxRuntime.jsx("svg", { className: "ml-2 h-4 w-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M9 5l7 7-7 7" }) })),
+                };
+            case 'back':
+                return {
+                    className: "flex items-center align-middle text-nowrap w-fit h-[40px] px-4 py-2 bg-white text-[16px] rounded border border-blue-600 text-blue-600 font-medium font-['Roboto'] hover:bg-blue-50 disabled:opacity-50 disabled:cursor-not-allowed",
+                    label: label || 'Volver',
+                    icon: (jsxRuntime.jsx("svg", { className: "mr-2 h-4 w-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M15 19l-7-7 7-7" }) })),
+                };
+            case 'guardar':
+                return {
+                    className: "flex items-center align-middle text-nowrap bg-blue-600 disabled:bg-gray-400 w-fit h-[40px] px-4 py-2 rounded border text-lg font-medium font-['Roboto'] text-white hover:bg-blue-700 disabled:cursor-not-allowed",
+                    label: label || 'Guardar',
+                    icon: (jsxRuntime.jsx("svg", { className: "mr-2 h-4 w-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M8 7H5a2 2 0 00-2 2v9a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-3m-1 4l-3 3m0 0l-3-3m3 3V4" }) })),
+                };
+            case 'success':
+                return {
+                    className: "flex items-center align-middle text-nowrap disabled:bg-gray-400 min-w-40 h-[40px] px-4 py-2 rounded border text-lg font-medium font-['Roboto'] bg-green-600 text-white hover:bg-green-700 disabled:cursor-not-allowed",
+                    label: label,
+                    icon: null,
+                };
+            case 'out-light':
+                return {
+                    className: "flex items-center align-middle text-nowrap w-fit h-[40px] px-4 py-2 bg-white text-[16px] rounded border border-blue-600 text-blue-600 font-medium font-['Roboto'] hover:bg-blue-50 disabled:opacity-50 disabled:cursor-not-allowed",
+                    label: label || 'Salir',
+                    icon: (jsxRuntime.jsx("svg", { className: "mr-2 h-4 w-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1" }) })),
+                };
+            case 'out':
+                return {
+                    className: "flex items-center align-middle text-nowrap bg-blue-600 disabled:bg-gray-400 w-fit h-[40px] px-4 py-2 rounded border text-lg font-medium font-['Roboto'] text-white hover:bg-blue-700 disabled:cursor-not-allowed",
+                    label: 'Salir',
+                    icon: (jsxRuntime.jsx("svg", { className: "ml-2 h-4 w-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1" }) })),
+                };
+            default:
+                return {
+                    className: "flex items-center align-middle text-nowrap bg-blue-600 disabled:bg-gray-400 w-fit h-[40px] px-4 py-2 rounded border text-lg font-medium font-['Roboto'] text-white hover:bg-blue-700 disabled:cursor-not-allowed",
+                    label: label || 'Siguiente',
+                    icon: (jsxRuntime.jsx("svg", { className: "ml-2 h-4 w-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: jsxRuntime.jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M9 5l7 7-7 7" }) })),
+                };
+        }
+    };
+    var _d = getButtonProps(), className = _d.className, buttonLabel = _d.label, icon = _d.icon;
+    return (jsxRuntime.jsxs("button", { onClick: onClick, disabled: disabled, className: className, children: [(direction === 'back' || direction === 'out-light' || direction === 'guardar') && icon, buttonLabel, (direction === 'next' || direction === 'out') && icon] }));
+};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/**
+ * Based on Kendo UI Core expression code <https://github.com/telerik/kendo-ui-core#license-information>
+ */
+
+function Cache(maxSize) {
+  this._maxSize = maxSize;
+  this.clear();
+}
+Cache.prototype.clear = function () {
+  this._size = 0;
+  this._values = Object.create(null);
+};
+Cache.prototype.get = function (key) {
+  return this._values[key]
+};
+Cache.prototype.set = function (key, value) {
+  this._size >= this._maxSize && this.clear();
+  if (!(key in this._values)) this._size++;
+
+  return (this._values[key] = value)
+};
+
+var SPLIT_REGEX = /[^.^\]^[]+|(?=\[\]|\.\.)/g,
+  DIGIT_REGEX = /^\d+$/,
+  LEAD_DIGIT_REGEX = /^\d/,
+  SPEC_CHAR_REGEX = /[~`!#$%\^&*+=\-\[\]\\';,/{}|\\":<>\?]/g,
+  CLEAN_QUOTES_REGEX = /^\s*(['"]?)(.*?)(\1)\s*$/,
+  MAX_CACHE_SIZE = 512;
+
+var pathCache = new Cache(MAX_CACHE_SIZE),
+  setCache = new Cache(MAX_CACHE_SIZE),
+  getCache = new Cache(MAX_CACHE_SIZE);
+
+var propertyExpr = {
+  Cache: Cache,
+
+  split: split,
+
+  normalizePath: normalizePath,
+
+  setter: function (path) {
+    var parts = normalizePath(path);
+
+    return (
+      setCache.get(path) ||
+      setCache.set(path, function setter(obj, value) {
+        var index = 0;
+        var len = parts.length;
+        var data = obj;
+
+        while (index < len - 1) {
+          var part = parts[index];
+          if (
+            part === '__proto__' ||
+            part === 'constructor' ||
+            part === 'prototype'
+          ) {
+            return obj
+          }
+
+          data = data[parts[index++]];
+        }
+        data[parts[index]] = value;
+      })
+    )
+  },
+
+  getter: function (path, safe) {
+    var parts = normalizePath(path);
+    return (
+      getCache.get(path) ||
+      getCache.set(path, function getter(data) {
+        var index = 0,
+          len = parts.length;
+        while (index < len) {
+          if (data != null || !safe) data = data[parts[index++]];
+          else return
+        }
+        return data
+      })
+    )
+  },
+
+  join: function (segments) {
+    return segments.reduce(function (path, part) {
+      return (
+        path +
+        (isQuoted(part) || DIGIT_REGEX.test(part)
+          ? '[' + part + ']'
+          : (path ? '.' : '') + part)
+      )
+    }, '')
+  },
+
+  forEach: function (path, cb, thisArg) {
+    forEach(Array.isArray(path) ? path : split(path), cb, thisArg);
+  },
+};
+
+function normalizePath(path) {
+  return (
+    pathCache.get(path) ||
+    pathCache.set(
+      path,
+      split(path).map(function (part) {
+        return part.replace(CLEAN_QUOTES_REGEX, '$2')
+      })
+    )
+  )
+}
+
+function split(path) {
+  return path.match(SPLIT_REGEX) || ['']
+}
+
+function forEach(parts, iter, thisArg) {
+  var len = parts.length,
+    part,
+    idx,
+    isArray,
+    isBracket;
+
+  for (idx = 0; idx < len; idx++) {
+    part = parts[idx];
+
+    if (part) {
+      if (shouldBeQuoted(part)) {
+        part = '"' + part + '"';
+      }
+
+      isBracket = isQuoted(part);
+      isArray = !isBracket && /^\d+$/.test(part);
+
+      iter.call(thisArg, part, isBracket, isArray, idx, parts);
+    }
+  }
+}
+
+function isQuoted(str) {
+  return (
+    typeof str === 'string' && str && ["'", '"'].indexOf(str.charAt(0)) !== -1
+  )
+}
+
+function hasLeadingNumber(part) {
+  return part.match(LEAD_DIGIT_REGEX) && !part.match(DIGIT_REGEX)
+}
+
+function hasSpecialChars(part) {
+  return SPEC_CHAR_REGEX.test(part)
+}
+
+function shouldBeQuoted(part) {
+  return !isQuoted(part) && (hasLeadingNumber(part) || hasSpecialChars(part))
+}
+
+const reWords = /[A-Z\xc0-\xd6\xd8-\xde]?[a-z\xdf-\xf6\xf8-\xff]+(?:['’](?:d|ll|m|re|s|t|ve))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde]|$)|(?:[A-Z\xc0-\xd6\xd8-\xde]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:D|LL|M|RE|S|T|VE))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde](?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])|$)|[A-Z\xc0-\xd6\xd8-\xde]?(?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:d|ll|m|re|s|t|ve))?|[A-Z\xc0-\xd6\xd8-\xde]+(?:['’](?:D|LL|M|RE|S|T|VE))?|\d*(?:1ST|2ND|3RD|(?![123])\dTH)(?=\b|[a-z_])|\d*(?:1st|2nd|3rd|(?![123])\dth)(?=\b|[A-Z_])|\d+|(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]|\ud83c[\udffb-\udfff])?(?:\u200d(?:[^\ud800-\udfff]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]|\ud83c[\udffb-\udfff])?)*/g;
+
+const words = (str) => str.match(reWords) || [];
+
+const upperFirst = (str) => str[0].toUpperCase() + str.slice(1);
+
+const join = (str, d) => words(str).join(d).toLowerCase();
+
+const camelCase = (str) =>
+  words(str).reduce(
+    (acc, next) =>
+      `${acc}${
+        !acc
+          ? next.toLowerCase()
+          : next[0].toUpperCase() + next.slice(1).toLowerCase()
+      }`,
+    '',
+  );
+
+const pascalCase = (str) => upperFirst(camelCase(str));
+
+const snakeCase = (str) => join(str, '_');
+
+const kebabCase = (str) => join(str, '-');
+
+const sentenceCase = (str) => upperFirst(join(str, ' '));
+
+const titleCase = (str) => words(str).map(upperFirst).join(' ');
+
+var tinyCase = {
+  words,
+  upperFirst,
+  camelCase,
+  pascalCase,
+  snakeCase,
+  kebabCase,
+  sentenceCase,
+  titleCase,
+};
+
+var toposort$2 = {exports: {}};
+
+/**
+ * Topological sorting function
+ *
+ * @param {Array} edges
+ * @returns {Array}
+ */
+
+toposort$2.exports = function(edges) {
+  return toposort(uniqueNodes(edges), edges)
+};
+
+toposort$2.exports.array = toposort;
+
+function toposort(nodes, edges) {
+  var cursor = nodes.length
+    , sorted = new Array(cursor)
+    , visited = {}
+    , i = cursor
+    // Better data structures make algorithm much faster.
+    , outgoingEdges = makeOutgoingEdges(edges)
+    , nodesHash = makeNodesHash(nodes);
+
+  // check for unknown nodes
+  edges.forEach(function(edge) {
+    if (!nodesHash.has(edge[0]) || !nodesHash.has(edge[1])) {
+      throw new Error('Unknown node. There is an unknown node in the supplied edges.')
+    }
+  });
+
+  while (i--) {
+    if (!visited[i]) visit(nodes[i], i, new Set());
+  }
+
+  return sorted
+
+  function visit(node, i, predecessors) {
+    if(predecessors.has(node)) {
+      var nodeRep;
+      try {
+        nodeRep = ", node was:" + JSON.stringify(node);
+      } catch(e) {
+        nodeRep = "";
+      }
+      throw new Error('Cyclic dependency' + nodeRep)
+    }
+
+    if (!nodesHash.has(node)) {
+      throw new Error('Found unknown node. Make sure to provided all involved nodes. Unknown node: '+JSON.stringify(node))
+    }
+
+    if (visited[i]) return;
+    visited[i] = true;
+
+    var outgoing = outgoingEdges.get(node) || new Set();
+    outgoing = Array.from(outgoing);
+
+    if (i = outgoing.length) {
+      predecessors.add(node);
+      do {
+        var child = outgoing[--i];
+        visit(child, nodesHash.get(child), predecessors);
+      } while (i)
+      predecessors.delete(node);
+    }
+
+    sorted[--cursor] = node;
+  }
+}
+
+function uniqueNodes(arr){
+  var res = new Set();
+  for (var i = 0, len = arr.length; i < len; i++) {
+    var edge = arr[i];
+    res.add(edge[0]);
+    res.add(edge[1]);
+  }
+  return Array.from(res)
+}
+
+function makeOutgoingEdges(arr){
+  var edges = new Map();
+  for (var i = 0, len = arr.length; i < len; i++) {
+    var edge = arr[i];
+    if (!edges.has(edge[0])) edges.set(edge[0], new Set());
+    if (!edges.has(edge[1])) edges.set(edge[1], new Set());
+    edges.get(edge[0]).add(edge[1]);
+  }
+  return edges
+}
+
+function makeNodesHash(arr){
+  var res = new Map();
+  for (var i = 0, len = arr.length; i < len; i++) {
+    res.set(arr[i], i);
+  }
+  return res
+}
+
+var toposortExports = toposort$2.exports;
+var toposort$1 = /*@__PURE__*/getDefaultExportFromCjs(toposortExports);
+
+const toString = Object.prototype.toString;
+const errorToString = Error.prototype.toString;
+const regExpToString = RegExp.prototype.toString;
+const symbolToString = typeof Symbol !== 'undefined' ? Symbol.prototype.toString : () => '';
+const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+function printNumber(val) {
+  if (val != +val) return 'NaN';
+  const isNegativeZero = val === 0 && 1 / val < 0;
+  return isNegativeZero ? '-0' : '' + val;
+}
+function printSimpleValue(val, quoteStrings = false) {
+  if (val == null || val === true || val === false) return '' + val;
+  const typeOf = typeof val;
+  if (typeOf === 'number') return printNumber(val);
+  if (typeOf === 'string') return quoteStrings ? `"${val}"` : val;
+  if (typeOf === 'function') return '[Function ' + (val.name || 'anonymous') + ']';
+  if (typeOf === 'symbol') return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
+  const tag = toString.call(val).slice(8, -1);
+  if (tag === 'Date') return isNaN(val.getTime()) ? '' + val : val.toISOString(val);
+  if (tag === 'Error' || val instanceof Error) return '[' + errorToString.call(val) + ']';
+  if (tag === 'RegExp') return regExpToString.call(val);
+  return null;
+}
+function printValue(value, quoteStrings) {
+  let result = printSimpleValue(value, quoteStrings);
+  if (result !== null) return result;
+  return JSON.stringify(value, function (key, value) {
+    let result = printSimpleValue(this[key], quoteStrings);
+    if (result !== null) return result;
+    return value;
+  }, 2);
+}
+
+function toArray(value) {
+  return value == null ? [] : [].concat(value);
+}
+
+let _Symbol$toStringTag, _Symbol$hasInstance, _Symbol$toStringTag2;
+let strReg = /\$\{\s*(\w+)\s*\}/g;
+_Symbol$toStringTag = Symbol.toStringTag;
+class ValidationErrorNoStack {
+  constructor(errorOrErrors, value, field, type) {
+    this.name = void 0;
+    this.message = void 0;
+    this.value = void 0;
+    this.path = void 0;
+    this.type = void 0;
+    this.params = void 0;
+    this.errors = void 0;
+    this.inner = void 0;
+    this[_Symbol$toStringTag] = 'Error';
+    this.name = 'ValidationError';
+    this.value = value;
+    this.path = field;
+    this.type = type;
+    this.errors = [];
+    this.inner = [];
+    toArray(errorOrErrors).forEach(err => {
+      if (ValidationError.isError(err)) {
+        this.errors.push(...err.errors);
+        const innerErrors = err.inner.length ? err.inner : [err];
+        this.inner.push(...innerErrors);
+      } else {
+        this.errors.push(err);
+      }
+    });
+    this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];
+  }
+}
+_Symbol$hasInstance = Symbol.hasInstance;
+_Symbol$toStringTag2 = Symbol.toStringTag;
+class ValidationError extends Error {
+  static formatError(message, params) {
+    // Attempt to make the path more friendly for error message interpolation.
+    const path = params.label || params.path || 'this';
+    // Store the original path under `originalPath` so it isn't lost to custom
+    // message functions; e.g., ones provided in `setLocale()` calls.
+    params = Object.assign({}, params, {
+      path,
+      originalPath: params.path
+    });
+    if (typeof message === 'string') return message.replace(strReg, (_, key) => printValue(params[key]));
+    if (typeof message === 'function') return message(params);
+    return message;
+  }
+  static isError(err) {
+    return err && err.name === 'ValidationError';
+  }
+  constructor(errorOrErrors, value, field, type, disableStack) {
+    const errorNoStack = new ValidationErrorNoStack(errorOrErrors, value, field, type);
+    if (disableStack) {
+      return errorNoStack;
+    }
+    super();
+    this.value = void 0;
+    this.path = void 0;
+    this.type = void 0;
+    this.params = void 0;
+    this.errors = [];
+    this.inner = [];
+    this[_Symbol$toStringTag2] = 'Error';
+    this.name = errorNoStack.name;
+    this.message = errorNoStack.message;
+    this.type = errorNoStack.type;
+    this.value = errorNoStack.value;
+    this.path = errorNoStack.path;
+    this.errors = errorNoStack.errors;
+    this.inner = errorNoStack.inner;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ValidationError);
+    }
+  }
+  static [_Symbol$hasInstance](inst) {
+    return ValidationErrorNoStack[Symbol.hasInstance](inst) || super[Symbol.hasInstance](inst);
+  }
+}
+
+let mixed = {
+  default: '${path} is invalid',
+  required: '${path} is a required field',
+  defined: '${path} must be defined',
+  notNull: '${path} cannot be null',
+  oneOf: '${path} must be one of the following values: ${values}',
+  notOneOf: '${path} must not be one of the following values: ${values}',
+  notType: ({
+    path,
+    type,
+    value,
+    originalValue
+  }) => {
+    const castMsg = originalValue != null && originalValue !== value ? ` (cast from the value \`${printValue(originalValue, true)}\`).` : '.';
+    return type !== 'mixed' ? `${path} must be a \`${type}\` type, ` + `but the final value was: \`${printValue(value, true)}\`` + castMsg : `${path} must match the configured type. ` + `The validated value was: \`${printValue(value, true)}\`` + castMsg;
+  }
+};
+let string = {
+  length: '${path} must be exactly ${length} characters',
+  min: '${path} must be at least ${min} characters',
+  max: '${path} must be at most ${max} characters',
+  matches: '${path} must match the following: "${regex}"',
+  email: '${path} must be a valid email',
+  url: '${path} must be a valid URL',
+  uuid: '${path} must be a valid UUID',
+  datetime: '${path} must be a valid ISO date-time',
+  datetime_precision: '${path} must be a valid ISO date-time with a sub-second precision of exactly ${precision} digits',
+  datetime_offset: '${path} must be a valid ISO date-time with UTC "Z" timezone',
+  trim: '${path} must be a trimmed string',
+  lowercase: '${path} must be a lowercase string',
+  uppercase: '${path} must be a upper case string'
+};
+let number = {
+  min: '${path} must be greater than or equal to ${min}',
+  max: '${path} must be less than or equal to ${max}',
+  lessThan: '${path} must be less than ${less}',
+  moreThan: '${path} must be greater than ${more}',
+  positive: '${path} must be a positive number',
+  negative: '${path} must be a negative number',
+  integer: '${path} must be an integer'
+};
+let date = {
+  min: '${path} field must be later than ${min}',
+  max: '${path} field must be at earlier than ${max}'
+};
+let boolean = {
+  isValue: '${path} field must be ${value}'
+};
+let object = {
+  noUnknown: '${path} field has unspecified keys: ${unknown}',
+  exact: '${path} object contains unknown properties: ${properties}'
+};
+let array = {
+  min: '${path} field must have at least ${min} items',
+  max: '${path} field must have less than or equal to ${max} items',
+  length: '${path} must have ${length} items'
+};
+let tuple = {
+  notType: params => {
+    const {
+      path,
+      value,
+      spec
+    } = params;
+    const typeLen = spec.types.length;
+    if (Array.isArray(value)) {
+      if (value.length < typeLen) return `${path} tuple value has too few items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+      if (value.length > typeLen) return `${path} tuple value has too many items, expected a length of ${typeLen} but got ${value.length} for value: \`${printValue(value, true)}\``;
+    }
+    return ValidationError.formatError(mixed.notType, params);
+  }
+};
+Object.assign(Object.create(null), {
+  mixed,
+  string,
+  number,
+  date,
+  object,
+  array,
+  boolean,
+  tuple
+});
+
+const isSchema = obj => obj && obj.__isYupSchema__;
+
+class Condition {
+  static fromOptions(refs, config) {
+    if (!config.then && !config.otherwise) throw new TypeError('either `then:` or `otherwise:` is required for `when()` conditions');
+    let {
+      is,
+      then,
+      otherwise
+    } = config;
+    let check = typeof is === 'function' ? is : (...values) => values.every(value => value === is);
+    return new Condition(refs, (values, schema) => {
+      var _branch;
+      let branch = check(...values) ? then : otherwise;
+      return (_branch = branch == null ? void 0 : branch(schema)) != null ? _branch : schema;
+    });
+  }
+  constructor(refs, builder) {
+    this.fn = void 0;
+    this.refs = refs;
+    this.refs = refs;
+    this.fn = builder;
+  }
+  resolve(base, options) {
+    let values = this.refs.map(ref =>
+    // TODO: ? operator here?
+    ref.getValue(options == null ? void 0 : options.value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context));
+    let schema = this.fn(values, base, options);
+    if (schema === undefined ||
+    // @ts-ignore this can be base
+    schema === base) {
+      return base;
+    }
+    if (!isSchema(schema)) throw new TypeError('conditions must return a schema object');
+    return schema.resolve(options);
+  }
+}
+
+const prefixes = {
+  context: '$',
+  value: '.'
+};
+class Reference {
+  constructor(key, options = {}) {
+    this.key = void 0;
+    this.isContext = void 0;
+    this.isValue = void 0;
+    this.isSibling = void 0;
+    this.path = void 0;
+    this.getter = void 0;
+    this.map = void 0;
+    if (typeof key !== 'string') throw new TypeError('ref must be a string, got: ' + key);
+    this.key = key.trim();
+    if (key === '') throw new TypeError('ref must be a non-empty string');
+    this.isContext = this.key[0] === prefixes.context;
+    this.isValue = this.key[0] === prefixes.value;
+    this.isSibling = !this.isContext && !this.isValue;
+    let prefix = this.isContext ? prefixes.context : this.isValue ? prefixes.value : '';
+    this.path = this.key.slice(prefix.length);
+    this.getter = this.path && propertyExpr.getter(this.path, true);
+    this.map = options.map;
+  }
+  getValue(value, parent, context) {
+    let result = this.isContext ? context : this.isValue ? value : parent;
+    if (this.getter) result = this.getter(result || {});
+    if (this.map) result = this.map(result);
+    return result;
+  }
+
+  /**
+   *
+   * @param {*} value
+   * @param {Object} options
+   * @param {Object=} options.context
+   * @param {Object=} options.parent
+   */
+  cast(value, options) {
+    return this.getValue(value, options == null ? void 0 : options.parent, options == null ? void 0 : options.context);
+  }
+  resolve() {
+    return this;
+  }
+  describe() {
+    return {
+      type: 'ref',
+      key: this.key
+    };
+  }
+  toString() {
+    return `Ref(${this.key})`;
+  }
+  static isRef(value) {
+    return value && value.__isYupRef;
+  }
+}
+
+// @ts-ignore
+Reference.prototype.__isYupRef = true;
+
+const isAbsent = value => value == null;
+
+function createValidation(config) {
+  function validate({
+    value,
+    path = '',
+    options,
+    originalValue,
+    schema
+  }, panic, next) {
+    const {
+      name,
+      test,
+      params,
+      message,
+      skipAbsent
+    } = config;
+    let {
+      parent,
+      context,
+      abortEarly = schema.spec.abortEarly,
+      disableStackTrace = schema.spec.disableStackTrace
+    } = options;
+    function resolve(item) {
+      return Reference.isRef(item) ? item.getValue(value, parent, context) : item;
+    }
+    function createError(overrides = {}) {
+      const nextParams = Object.assign({
+        value,
+        originalValue,
+        label: schema.spec.label,
+        path: overrides.path || path,
+        spec: schema.spec,
+        disableStackTrace: overrides.disableStackTrace || disableStackTrace
+      }, params, overrides.params);
+      for (const key of Object.keys(nextParams)) nextParams[key] = resolve(nextParams[key]);
+      const error = new ValidationError(ValidationError.formatError(overrides.message || message, nextParams), value, nextParams.path, overrides.type || name, nextParams.disableStackTrace);
+      error.params = nextParams;
+      return error;
+    }
+    const invalid = abortEarly ? panic : next;
+    let ctx = {
+      path,
+      parent,
+      type: name,
+      from: options.from,
+      createError,
+      resolve,
+      options,
+      originalValue,
+      schema
+    };
+    const handleResult = validOrError => {
+      if (ValidationError.isError(validOrError)) invalid(validOrError);else if (!validOrError) invalid(createError());else next(null);
+    };
+    const handleError = err => {
+      if (ValidationError.isError(err)) invalid(err);else panic(err);
+    };
+    const shouldSkip = skipAbsent && isAbsent(value);
+    if (shouldSkip) {
+      return handleResult(true);
+    }
+    let result;
+    try {
+      var _result;
+      result = test.call(ctx, value, ctx);
+      if (typeof ((_result = result) == null ? void 0 : _result.then) === 'function') {
+        if (options.sync) {
+          throw new Error(`Validation test of type: "${ctx.type}" returned a Promise during a synchronous validate. ` + `This test will finish after the validate call has returned`);
+        }
+        return Promise.resolve(result).then(handleResult, handleError);
+      }
+    } catch (err) {
+      handleError(err);
+      return;
+    }
+    handleResult(result);
+  }
+  validate.OPTIONS = config;
+  return validate;
+}
+
+function getIn(schema, path, value, context = value) {
+  let parent, lastPart, lastPartDebug;
+
+  // root path: ''
+  if (!path) return {
+    parent,
+    parentPath: path,
+    schema
+  };
+  propertyExpr.forEach(path, (_part, isBracket, isArray) => {
+    let part = isBracket ? _part.slice(1, _part.length - 1) : _part;
+    schema = schema.resolve({
+      context,
+      parent,
+      value
+    });
+    let isTuple = schema.type === 'tuple';
+    let idx = isArray ? parseInt(part, 10) : 0;
+    if (schema.innerType || isTuple) {
+      if (isTuple && !isArray) throw new Error(`Yup.reach cannot implicitly index into a tuple type. the path part "${lastPartDebug}" must contain an index to the tuple element, e.g. "${lastPartDebug}[0]"`);
+      if (value && idx >= value.length) {
+        throw new Error(`Yup.reach cannot resolve an array item at index: ${_part}, in the path: ${path}. ` + `because there is no value at that index. `);
+      }
+      parent = value;
+      value = value && value[idx];
+      schema = isTuple ? schema.spec.types[idx] : schema.innerType;
+    }
+
+    // sometimes the array index part of a path doesn't exist: "nested.arr.child"
+    // in these cases the current part is the next schema and should be processed
+    // in this iteration. For cases where the index signature is included this
+    // check will fail and we'll handle the `child` part on the next iteration like normal
+    if (!isArray) {
+      if (!schema.fields || !schema.fields[part]) throw new Error(`The schema does not contain the path: ${path}. ` + `(failed at: ${lastPartDebug} which is a type: "${schema.type}")`);
+      parent = value;
+      value = value && value[part];
+      schema = schema.fields[part];
+    }
+    lastPart = part;
+    lastPartDebug = isBracket ? '[' + _part + ']' : '.' + _part;
+  });
+  return {
+    schema,
+    parent,
+    parentPath: lastPart
+  };
+}
+
+class ReferenceSet extends Set {
+  describe() {
+    const description = [];
+    for (const item of this.values()) {
+      description.push(Reference.isRef(item) ? item.describe() : item);
+    }
+    return description;
+  }
+  resolveAll(resolve) {
+    let result = [];
+    for (const item of this.values()) {
+      result.push(resolve(item));
+    }
+    return result;
+  }
+  clone() {
+    return new ReferenceSet(this.values());
+  }
+  merge(newItems, removeItems) {
+    const next = this.clone();
+    newItems.forEach(value => next.add(value));
+    removeItems.forEach(value => next.delete(value));
+    return next;
+  }
+}
+
+// tweaked from https://github.com/Kelin2025/nanoclone/blob/0abeb7635bda9b68ef2277093f76dbe3bf3948e1/src/index.js
+function clone(src, seen = new Map()) {
+  if (isSchema(src) || !src || typeof src !== 'object') return src;
+  if (seen.has(src)) return seen.get(src);
+  let copy;
+  if (src instanceof Date) {
+    // Date
+    copy = new Date(src.getTime());
+    seen.set(src, copy);
+  } else if (src instanceof RegExp) {
+    // RegExp
+    copy = new RegExp(src);
+    seen.set(src, copy);
+  } else if (Array.isArray(src)) {
+    // Array
+    copy = new Array(src.length);
+    seen.set(src, copy);
+    for (let i = 0; i < src.length; i++) copy[i] = clone(src[i], seen);
+  } else if (src instanceof Map) {
+    // Map
+    copy = new Map();
+    seen.set(src, copy);
+    for (const [k, v] of src.entries()) copy.set(k, clone(v, seen));
+  } else if (src instanceof Set) {
+    // Set
+    copy = new Set();
+    seen.set(src, copy);
+    for (const v of src) copy.add(clone(v, seen));
+  } else if (src instanceof Object) {
+    // Object
+    copy = {};
+    seen.set(src, copy);
+    for (const [k, v] of Object.entries(src)) copy[k] = clone(v, seen);
+  } else {
+    throw Error(`Unable to clone ${src}`);
+  }
+  return copy;
+}
+
+// If `CustomSchemaMeta` isn't extended with any keys, we'll fall back to a
+// loose Record definition allowing free form usage.
+class Schema {
+  constructor(options) {
+    this.type = void 0;
+    this.deps = [];
+    this.tests = void 0;
+    this.transforms = void 0;
+    this.conditions = [];
+    this._mutate = void 0;
+    this.internalTests = {};
+    this._whitelist = new ReferenceSet();
+    this._blacklist = new ReferenceSet();
+    this.exclusiveTests = Object.create(null);
+    this._typeCheck = void 0;
+    this.spec = void 0;
+    this.tests = [];
+    this.transforms = [];
+    this.withMutation(() => {
+      this.typeError(mixed.notType);
+    });
+    this.type = options.type;
+    this._typeCheck = options.check;
+    this.spec = Object.assign({
+      strip: false,
+      strict: false,
+      abortEarly: true,
+      recursive: true,
+      disableStackTrace: false,
+      nullable: false,
+      optional: true,
+      coerce: true
+    }, options == null ? void 0 : options.spec);
+    this.withMutation(s => {
+      s.nonNullable();
+    });
+  }
+
+  // TODO: remove
+  get _type() {
+    return this.type;
+  }
+  clone(spec) {
+    if (this._mutate) {
+      if (spec) Object.assign(this.spec, spec);
+      return this;
+    }
+
+    // if the nested value is a schema we can skip cloning, since
+    // they are already immutable
+    const next = Object.create(Object.getPrototypeOf(this));
+
+    // @ts-expect-error this is readonly
+    next.type = this.type;
+    next._typeCheck = this._typeCheck;
+    next._whitelist = this._whitelist.clone();
+    next._blacklist = this._blacklist.clone();
+    next.internalTests = Object.assign({}, this.internalTests);
+    next.exclusiveTests = Object.assign({}, this.exclusiveTests);
+
+    // @ts-expect-error this is readonly
+    next.deps = [...this.deps];
+    next.conditions = [...this.conditions];
+    next.tests = [...this.tests];
+    next.transforms = [...this.transforms];
+    next.spec = clone(Object.assign({}, this.spec, spec));
+    return next;
+  }
+  label(label) {
+    let next = this.clone();
+    next.spec.label = label;
+    return next;
+  }
+  meta(...args) {
+    if (args.length === 0) return this.spec.meta;
+    let next = this.clone();
+    next.spec.meta = Object.assign(next.spec.meta || {}, args[0]);
+    return next;
+  }
+  withMutation(fn) {
+    let before = this._mutate;
+    this._mutate = true;
+    let result = fn(this);
+    this._mutate = before;
+    return result;
+  }
+  concat(schema) {
+    if (!schema || schema === this) return this;
+    if (schema.type !== this.type && this.type !== 'mixed') throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${schema.type}`);
+    let base = this;
+    let combined = schema.clone();
+    const mergedSpec = Object.assign({}, base.spec, combined.spec);
+    combined.spec = mergedSpec;
+    combined.internalTests = Object.assign({}, base.internalTests, combined.internalTests);
+
+    // manually merge the blacklist/whitelist (the other `schema` takes
+    // precedence in case of conflicts)
+    combined._whitelist = base._whitelist.merge(schema._whitelist, schema._blacklist);
+    combined._blacklist = base._blacklist.merge(schema._blacklist, schema._whitelist);
+
+    // start with the current tests
+    combined.tests = base.tests;
+    combined.exclusiveTests = base.exclusiveTests;
+
+    // manually add the new tests to ensure
+    // the deduping logic is consistent
+    combined.withMutation(next => {
+      schema.tests.forEach(fn => {
+        next.test(fn.OPTIONS);
+      });
+    });
+    combined.transforms = [...base.transforms, ...combined.transforms];
+    return combined;
+  }
+  isType(v) {
+    if (v == null) {
+      if (this.spec.nullable && v === null) return true;
+      if (this.spec.optional && v === undefined) return true;
+      return false;
+    }
+    return this._typeCheck(v);
+  }
+  resolve(options) {
+    let schema = this;
+    if (schema.conditions.length) {
+      let conditions = schema.conditions;
+      schema = schema.clone();
+      schema.conditions = [];
+      schema = conditions.reduce((prevSchema, condition) => condition.resolve(prevSchema, options), schema);
+      schema = schema.resolve(options);
+    }
+    return schema;
+  }
+  resolveOptions(options) {
+    var _options$strict, _options$abortEarly, _options$recursive, _options$disableStack;
+    return Object.assign({}, options, {
+      from: options.from || [],
+      strict: (_options$strict = options.strict) != null ? _options$strict : this.spec.strict,
+      abortEarly: (_options$abortEarly = options.abortEarly) != null ? _options$abortEarly : this.spec.abortEarly,
+      recursive: (_options$recursive = options.recursive) != null ? _options$recursive : this.spec.recursive,
+      disableStackTrace: (_options$disableStack = options.disableStackTrace) != null ? _options$disableStack : this.spec.disableStackTrace
+    });
+  }
+
+  /**
+   * Run the configured transform pipeline over an input value.
+   */
+
+  cast(value, options = {}) {
+    let resolvedSchema = this.resolve(Object.assign({
+      value
+    }, options));
+    let allowOptionality = options.assert === 'ignore-optionality';
+    let result = resolvedSchema._cast(value, options);
+    if (options.assert !== false && !resolvedSchema.isType(result)) {
+      if (allowOptionality && isAbsent(result)) {
+        return result;
+      }
+      let formattedValue = printValue(value);
+      let formattedResult = printValue(result);
+      throw new TypeError(`The value of ${options.path || 'field'} could not be cast to a value ` + `that satisfies the schema type: "${resolvedSchema.type}". \n\n` + `attempted value: ${formattedValue} \n` + (formattedResult !== formattedValue ? `result of cast: ${formattedResult}` : ''));
+    }
+    return result;
+  }
+  _cast(rawValue, options) {
+    let value = rawValue === undefined ? rawValue : this.transforms.reduce((prevValue, fn) => fn.call(this, prevValue, rawValue, this), rawValue);
+    if (value === undefined) {
+      value = this.getDefault(options);
+    }
+    return value;
+  }
+  _validate(_value, options = {}, panic, next) {
+    let {
+      path,
+      originalValue = _value,
+      strict = this.spec.strict
+    } = options;
+    let value = _value;
+    if (!strict) {
+      value = this._cast(value, Object.assign({
+        assert: false
+      }, options));
+    }
+    let initialTests = [];
+    for (let test of Object.values(this.internalTests)) {
+      if (test) initialTests.push(test);
+    }
+    this.runTests({
+      path,
+      value,
+      originalValue,
+      options,
+      tests: initialTests
+    }, panic, initialErrors => {
+      // even if we aren't ending early we can't proceed further if the types aren't correct
+      if (initialErrors.length) {
+        return next(initialErrors, value);
+      }
+      this.runTests({
+        path,
+        value,
+        originalValue,
+        options,
+        tests: this.tests
+      }, panic, next);
+    });
+  }
+
+  /**
+   * Executes a set of validations, either schema, produced Tests or a nested
+   * schema validate result.
+   */
+  runTests(runOptions, panic, next) {
+    let fired = false;
+    let {
+      tests,
+      value,
+      originalValue,
+      path,
+      options
+    } = runOptions;
+    let panicOnce = arg => {
+      if (fired) return;
+      fired = true;
+      panic(arg, value);
+    };
+    let nextOnce = arg => {
+      if (fired) return;
+      fired = true;
+      next(arg, value);
+    };
+    let count = tests.length;
+    let nestedErrors = [];
+    if (!count) return nextOnce([]);
+    let args = {
+      value,
+      originalValue,
+      path,
+      options,
+      schema: this
+    };
+    for (let i = 0; i < tests.length; i++) {
+      const test = tests[i];
+      test(args, panicOnce, function finishTestRun(err) {
+        if (err) {
+          Array.isArray(err) ? nestedErrors.push(...err) : nestedErrors.push(err);
+        }
+        if (--count <= 0) {
+          nextOnce(nestedErrors);
+        }
+      });
+    }
+  }
+  asNestedTest({
+    key,
+    index,
+    parent,
+    parentPath,
+    originalParent,
+    options
+  }) {
+    const k = key != null ? key : index;
+    if (k == null) {
+      throw TypeError('Must include `key` or `index` for nested validations');
+    }
+    const isIndex = typeof k === 'number';
+    let value = parent[k];
+    const testOptions = Object.assign({}, options, {
+      // Nested validations fields are always strict:
+      //    1. parent isn't strict so the casting will also have cast inner values
+      //    2. parent is strict in which case the nested values weren't cast either
+      strict: true,
+      parent,
+      value,
+      originalValue: originalParent[k],
+      // FIXME: tests depend on `index` being passed around deeply,
+      //   we should not let the options.key/index bleed through
+      key: undefined,
+      // index: undefined,
+      [isIndex ? 'index' : 'key']: k,
+      path: isIndex || k.includes('.') ? `${parentPath || ''}[${isIndex ? k : `"${k}"`}]` : (parentPath ? `${parentPath}.` : '') + key
+    });
+    return (_, panic, next) => this.resolve(testOptions)._validate(value, testOptions, panic, next);
+  }
+  validate(value, options) {
+    var _options$disableStack2;
+    let schema = this.resolve(Object.assign({}, options, {
+      value
+    }));
+    let disableStackTrace = (_options$disableStack2 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack2 : schema.spec.disableStackTrace;
+    return new Promise((resolve, reject) => schema._validate(value, options, (error, parsed) => {
+      if (ValidationError.isError(error)) error.value = parsed;
+      reject(error);
+    }, (errors, validated) => {
+      if (errors.length) reject(new ValidationError(errors, validated, undefined, undefined, disableStackTrace));else resolve(validated);
+    }));
+  }
+  validateSync(value, options) {
+    var _options$disableStack3;
+    let schema = this.resolve(Object.assign({}, options, {
+      value
+    }));
+    let result;
+    let disableStackTrace = (_options$disableStack3 = options == null ? void 0 : options.disableStackTrace) != null ? _options$disableStack3 : schema.spec.disableStackTrace;
+    schema._validate(value, Object.assign({}, options, {
+      sync: true
+    }), (error, parsed) => {
+      if (ValidationError.isError(error)) error.value = parsed;
+      throw error;
+    }, (errors, validated) => {
+      if (errors.length) throw new ValidationError(errors, value, undefined, undefined, disableStackTrace);
+      result = validated;
+    });
+    return result;
+  }
+  isValid(value, options) {
+    return this.validate(value, options).then(() => true, err => {
+      if (ValidationError.isError(err)) return false;
+      throw err;
+    });
+  }
+  isValidSync(value, options) {
+    try {
+      this.validateSync(value, options);
+      return true;
+    } catch (err) {
+      if (ValidationError.isError(err)) return false;
+      throw err;
+    }
+  }
+  _getDefault(options) {
+    let defaultValue = this.spec.default;
+    if (defaultValue == null) {
+      return defaultValue;
+    }
+    return typeof defaultValue === 'function' ? defaultValue.call(this, options) : clone(defaultValue);
+  }
+  getDefault(options
+  // If schema is defaulted we know it's at least not undefined
+  ) {
+    let schema = this.resolve(options || {});
+    return schema._getDefault(options);
+  }
+  default(def) {
+    if (arguments.length === 0) {
+      return this._getDefault();
+    }
+    let next = this.clone({
+      default: def
+    });
+    return next;
+  }
+  strict(isStrict = true) {
+    return this.clone({
+      strict: isStrict
+    });
+  }
+  nullability(nullable, message) {
+    const next = this.clone({
+      nullable
+    });
+    next.internalTests.nullable = createValidation({
+      message,
+      name: 'nullable',
+      test(value) {
+        return value === null ? this.schema.spec.nullable : true;
+      }
+    });
+    return next;
+  }
+  optionality(optional, message) {
+    const next = this.clone({
+      optional
+    });
+    next.internalTests.optionality = createValidation({
+      message,
+      name: 'optionality',
+      test(value) {
+        return value === undefined ? this.schema.spec.optional : true;
+      }
+    });
+    return next;
+  }
+  optional() {
+    return this.optionality(true);
+  }
+  defined(message = mixed.defined) {
+    return this.optionality(false, message);
+  }
+  nullable() {
+    return this.nullability(true);
+  }
+  nonNullable(message = mixed.notNull) {
+    return this.nullability(false, message);
+  }
+  required(message = mixed.required) {
+    return this.clone().withMutation(next => next.nonNullable(message).defined(message));
+  }
+  notRequired() {
+    return this.clone().withMutation(next => next.nullable().optional());
+  }
+  transform(fn) {
+    let next = this.clone();
+    next.transforms.push(fn);
+    return next;
+  }
+
+  /**
+   * Adds a test function to the schema's queue of tests.
+   * tests can be exclusive or non-exclusive.
+   *
+   * - exclusive tests, will replace any existing tests of the same name.
+   * - non-exclusive: can be stacked
+   *
+   * If a non-exclusive test is added to a schema with an exclusive test of the same name
+   * the exclusive test is removed and further tests of the same name will be stacked.
+   *
+   * If an exclusive test is added to a schema with non-exclusive tests of the same name
+   * the previous tests are removed and further tests of the same name will replace each other.
+   */
+
+  test(...args) {
+    let opts;
+    if (args.length === 1) {
+      if (typeof args[0] === 'function') {
+        opts = {
+          test: args[0]
+        };
+      } else {
+        opts = args[0];
+      }
+    } else if (args.length === 2) {
+      opts = {
+        name: args[0],
+        test: args[1]
+      };
+    } else {
+      opts = {
+        name: args[0],
+        message: args[1],
+        test: args[2]
+      };
+    }
+    if (opts.message === undefined) opts.message = mixed.default;
+    if (typeof opts.test !== 'function') throw new TypeError('`test` is a required parameters');
+    let next = this.clone();
+    let validate = createValidation(opts);
+    let isExclusive = opts.exclusive || opts.name && next.exclusiveTests[opts.name] === true;
+    if (opts.exclusive) {
+      if (!opts.name) throw new TypeError('Exclusive tests must provide a unique `name` identifying the test');
+    }
+    if (opts.name) next.exclusiveTests[opts.name] = !!opts.exclusive;
+    next.tests = next.tests.filter(fn => {
+      if (fn.OPTIONS.name === opts.name) {
+        if (isExclusive) return false;
+        if (fn.OPTIONS.test === validate.OPTIONS.test) return false;
+      }
+      return true;
+    });
+    next.tests.push(validate);
+    return next;
+  }
+  when(keys, options) {
+    if (!Array.isArray(keys) && typeof keys !== 'string') {
+      options = keys;
+      keys = '.';
+    }
+    let next = this.clone();
+    let deps = toArray(keys).map(key => new Reference(key));
+    deps.forEach(dep => {
+      // @ts-ignore readonly array
+      if (dep.isSibling) next.deps.push(dep.key);
+    });
+    next.conditions.push(typeof options === 'function' ? new Condition(deps, options) : Condition.fromOptions(deps, options));
+    return next;
+  }
+  typeError(message) {
+    let next = this.clone();
+    next.internalTests.typeError = createValidation({
+      message,
+      name: 'typeError',
+      skipAbsent: true,
+      test(value) {
+        if (!this.schema._typeCheck(value)) return this.createError({
+          params: {
+            type: this.schema.type
+          }
+        });
+        return true;
+      }
+    });
+    return next;
+  }
+  oneOf(enums, message = mixed.oneOf) {
+    let next = this.clone();
+    enums.forEach(val => {
+      next._whitelist.add(val);
+      next._blacklist.delete(val);
+    });
+    next.internalTests.whiteList = createValidation({
+      message,
+      name: 'oneOf',
+      skipAbsent: true,
+      test(value) {
+        let valids = this.schema._whitelist;
+        let resolved = valids.resolveAll(this.resolve);
+        return resolved.includes(value) ? true : this.createError({
+          params: {
+            values: Array.from(valids).join(', '),
+            resolved
+          }
+        });
+      }
+    });
+    return next;
+  }
+  notOneOf(enums, message = mixed.notOneOf) {
+    let next = this.clone();
+    enums.forEach(val => {
+      next._blacklist.add(val);
+      next._whitelist.delete(val);
+    });
+    next.internalTests.blacklist = createValidation({
+      message,
+      name: 'notOneOf',
+      test(value) {
+        let invalids = this.schema._blacklist;
+        let resolved = invalids.resolveAll(this.resolve);
+        if (resolved.includes(value)) return this.createError({
+          params: {
+            values: Array.from(invalids).join(', '),
+            resolved
+          }
+        });
+        return true;
+      }
+    });
+    return next;
+  }
+  strip(strip = true) {
+    let next = this.clone();
+    next.spec.strip = strip;
+    return next;
+  }
+
+  /**
+   * Return a serialized description of the schema including validations, flags, types etc.
+   *
+   * @param options Provide any needed context for resolving runtime schema alterations (lazy, when conditions, etc).
+   */
+  describe(options) {
+    const next = (options ? this.resolve(options) : this).clone();
+    const {
+      label,
+      meta,
+      optional,
+      nullable
+    } = next.spec;
+    const description = {
+      meta,
+      label,
+      optional,
+      nullable,
+      default: next.getDefault(options),
+      type: next.type,
+      oneOf: next._whitelist.describe(),
+      notOneOf: next._blacklist.describe(),
+      tests: next.tests.map(fn => ({
+        name: fn.OPTIONS.name,
+        params: fn.OPTIONS.params
+      })).filter((n, idx, list) => list.findIndex(c => c.name === n.name) === idx)
+    };
+    return description;
+  }
+}
+// @ts-expect-error
+Schema.prototype.__isYupSchema__ = true;
+for (const method of ['validate', 'validateSync']) Schema.prototype[`${method}At`] = function (path, value, options = {}) {
+  const {
+    parent,
+    parentPath,
+    schema
+  } = getIn(this, path, value, options.context);
+  return schema[method](parent && parent[parentPath], Object.assign({}, options, {
+    parent,
+    path
+  }));
+};
+for (const alias of ['equals', 'is']) Schema.prototype[alias] = Schema.prototype.oneOf;
+for (const alias of ['not', 'nope']) Schema.prototype[alias] = Schema.prototype.notOneOf;
+
+/**
+ * This file is a modified version of the file from the following repository:
+ * Date.parse with progressive enhancement for ISO 8601 <https://github.com/csnover/js-iso8601>
+ * NON-CONFORMANT EDITION.
+ * © 2011 Colin Snover <http://zetafleet.com>
+ * Released under MIT license.
+ */
+
+// prettier-ignore
+//                1 YYYY                2 MM        3 DD              4 HH     5 mm        6 ss           7 msec         8 Z 9 ±   10 tzHH    11 tzmm
+const isoReg = /^(\d{4}|[+-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,.](\d{1,}))?)?(?:(Z)|([+-])(\d{2})(?::?(\d{2}))?)?)?$/;
+function parseIsoDate(date) {
+  const struct = parseDateStruct(date);
+  if (!struct) return Date.parse ? Date.parse(date) : Number.NaN;
+
+  // timestamps without timezone identifiers should be considered local time
+  if (struct.z === undefined && struct.plusMinus === undefined) {
+    return new Date(struct.year, struct.month, struct.day, struct.hour, struct.minute, struct.second, struct.millisecond).valueOf();
+  }
+  let totalMinutesOffset = 0;
+  if (struct.z !== 'Z' && struct.plusMinus !== undefined) {
+    totalMinutesOffset = struct.hourOffset * 60 + struct.minuteOffset;
+    if (struct.plusMinus === '+') totalMinutesOffset = 0 - totalMinutesOffset;
+  }
+  return Date.UTC(struct.year, struct.month, struct.day, struct.hour, struct.minute + totalMinutesOffset, struct.second, struct.millisecond);
+}
+function parseDateStruct(date) {
+  var _regexResult$7$length, _regexResult$;
+  const regexResult = isoReg.exec(date);
+  if (!regexResult) return null;
+
+  // use of toNumber() avoids NaN timestamps caused by “undefined”
+  // values being passed to Date constructor
+  return {
+    year: toNumber(regexResult[1]),
+    month: toNumber(regexResult[2], 1) - 1,
+    day: toNumber(regexResult[3], 1),
+    hour: toNumber(regexResult[4]),
+    minute: toNumber(regexResult[5]),
+    second: toNumber(regexResult[6]),
+    millisecond: regexResult[7] ?
+    // allow arbitrary sub-second precision beyond milliseconds
+    toNumber(regexResult[7].substring(0, 3)) : 0,
+    precision: (_regexResult$7$length = (_regexResult$ = regexResult[7]) == null ? void 0 : _regexResult$.length) != null ? _regexResult$7$length : undefined,
+    z: regexResult[8] || undefined,
+    plusMinus: regexResult[9] || undefined,
+    hourOffset: toNumber(regexResult[10]),
+    minuteOffset: toNumber(regexResult[11])
+  };
+}
+function toNumber(str, defaultValue = 0) {
+  return Number(str) || defaultValue;
+}
+
+// Taken from HTML spec: https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
+let rEmail =
+// eslint-disable-next-line
+/^[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])?)*$/;
+let rUrl =
+// eslint-disable-next-line
+/^((https?|ftp):)?\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i;
+
+// eslint-disable-next-line
+let rUUID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+let yearMonthDay = '^\\d{4}-\\d{2}-\\d{2}';
+let hourMinuteSecond = '\\d{2}:\\d{2}:\\d{2}';
+let zOrOffset = '(([+-]\\d{2}(:?\\d{2})?)|Z)';
+let rIsoDateTime = new RegExp(`${yearMonthDay}T${hourMinuteSecond}(\\.\\d+)?${zOrOffset}$`);
+let isTrimmed = value => isAbsent(value) || value === value.trim();
+let objStringTag = {}.toString();
+function create$6() {
+  return new StringSchema();
+}
+class StringSchema extends Schema {
+  constructor() {
+    super({
+      type: 'string',
+      check(value) {
+        if (value instanceof String) value = value.valueOf();
+        return typeof value === 'string';
+      }
+    });
+    this.withMutation(() => {
+      this.transform((value, _raw, ctx) => {
+        if (!ctx.spec.coerce || ctx.isType(value)) return value;
+
+        // don't ever convert arrays
+        if (Array.isArray(value)) return value;
+        const strValue = value != null && value.toString ? value.toString() : value;
+
+        // no one wants plain objects converted to [Object object]
+        if (strValue === objStringTag) return value;
+        return strValue;
+      });
+    });
+  }
+  required(message) {
+    return super.required(message).withMutation(schema => schema.test({
+      message: message || mixed.required,
+      name: 'required',
+      skipAbsent: true,
+      test: value => !!value.length
+    }));
+  }
+  notRequired() {
+    return super.notRequired().withMutation(schema => {
+      schema.tests = schema.tests.filter(t => t.OPTIONS.name !== 'required');
+      return schema;
+    });
+  }
+  length(length, message = string.length) {
+    return this.test({
+      message,
+      name: 'length',
+      exclusive: true,
+      params: {
+        length
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length === this.resolve(length);
+      }
+    });
+  }
+  min(min, message = string.min) {
+    return this.test({
+      message,
+      name: 'min',
+      exclusive: true,
+      params: {
+        min
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length >= this.resolve(min);
+      }
+    });
+  }
+  max(max, message = string.max) {
+    return this.test({
+      name: 'max',
+      exclusive: true,
+      message,
+      params: {
+        max
+      },
+      skipAbsent: true,
+      test(value) {
+        return value.length <= this.resolve(max);
+      }
+    });
+  }
+  matches(regex, options) {
+    let excludeEmptyString = false;
+    let message;
+    let name;
+    if (options) {
+      if (typeof options === 'object') {
+        ({
+          excludeEmptyString = false,
+          message,
+          name
+        } = options);
+      } else {
+        message = options;
+      }
+    }
+    return this.test({
+      name: name || 'matches',
+      message: message || string.matches,
+      params: {
+        regex
+      },
+      skipAbsent: true,
+      test: value => value === '' && excludeEmptyString || value.search(regex) !== -1
+    });
+  }
+  email(message = string.email) {
+    return this.matches(rEmail, {
+      name: 'email',
+      message,
+      excludeEmptyString: true
+    });
+  }
+  url(message = string.url) {
+    return this.matches(rUrl, {
+      name: 'url',
+      message,
+      excludeEmptyString: true
+    });
+  }
+  uuid(message = string.uuid) {
+    return this.matches(rUUID, {
+      name: 'uuid',
+      message,
+      excludeEmptyString: false
+    });
+  }
+  datetime(options) {
+    let message = '';
+    let allowOffset;
+    let precision;
+    if (options) {
+      if (typeof options === 'object') {
+        ({
+          message = '',
+          allowOffset = false,
+          precision = undefined
+        } = options);
+      } else {
+        message = options;
+      }
+    }
+    return this.matches(rIsoDateTime, {
+      name: 'datetime',
+      message: message || string.datetime,
+      excludeEmptyString: true
+    }).test({
+      name: 'datetime_offset',
+      message: message || string.datetime_offset,
+      params: {
+        allowOffset
+      },
+      skipAbsent: true,
+      test: value => {
+        if (!value || allowOffset) return true;
+        const struct = parseDateStruct(value);
+        if (!struct) return false;
+        return !!struct.z;
+      }
+    }).test({
+      name: 'datetime_precision',
+      message: message || string.datetime_precision,
+      params: {
+        precision
+      },
+      skipAbsent: true,
+      test: value => {
+        if (!value || precision == undefined) return true;
+        const struct = parseDateStruct(value);
+        if (!struct) return false;
+        return struct.precision === precision;
+      }
+    });
+  }
+
+  //-- transforms --
+  ensure() {
+    return this.default('').transform(val => val === null ? '' : val);
+  }
+  trim(message = string.trim) {
+    return this.transform(val => val != null ? val.trim() : val).test({
+      message,
+      name: 'trim',
+      test: isTrimmed
+    });
+  }
+  lowercase(message = string.lowercase) {
+    return this.transform(value => !isAbsent(value) ? value.toLowerCase() : value).test({
+      message,
+      name: 'string_case',
+      exclusive: true,
+      skipAbsent: true,
+      test: value => isAbsent(value) || value === value.toLowerCase()
+    });
+  }
+  uppercase(message = string.uppercase) {
+    return this.transform(value => !isAbsent(value) ? value.toUpperCase() : value).test({
+      message,
+      name: 'string_case',
+      exclusive: true,
+      skipAbsent: true,
+      test: value => isAbsent(value) || value === value.toUpperCase()
+    });
+  }
+}
+create$6.prototype = StringSchema.prototype;
+
+//
+// Number Interfaces
+//
+
+let invalidDate = new Date('');
+let isDate = obj => Object.prototype.toString.call(obj) === '[object Date]';
+class DateSchema extends Schema {
+  constructor() {
+    super({
+      type: 'date',
+      check(v) {
+        return isDate(v) && !isNaN(v.getTime());
+      }
+    });
+    this.withMutation(() => {
+      this.transform((value, _raw, ctx) => {
+        // null -> InvalidDate isn't useful; treat all nulls as null and let it fail on
+        // nullability check vs TypeErrors
+        if (!ctx.spec.coerce || ctx.isType(value) || value === null) return value;
+        value = parseIsoDate(value);
+
+        // 0 is a valid timestamp equivalent to 1970-01-01T00:00:00Z(unix epoch) or before.
+        return !isNaN(value) ? new Date(value) : DateSchema.INVALID_DATE;
+      });
+    });
+  }
+  prepareParam(ref, name) {
+    let param;
+    if (!Reference.isRef(ref)) {
+      let cast = this.cast(ref);
+      if (!this._typeCheck(cast)) throw new TypeError(`\`${name}\` must be a Date or a value that can be \`cast()\` to a Date`);
+      param = cast;
+    } else {
+      param = ref;
+    }
+    return param;
+  }
+  min(min, message = date.min) {
+    let limit = this.prepareParam(min, 'min');
+    return this.test({
+      message,
+      name: 'min',
+      exclusive: true,
+      params: {
+        min
+      },
+      skipAbsent: true,
+      test(value) {
+        return value >= this.resolve(limit);
+      }
+    });
+  }
+  max(max, message = date.max) {
+    let limit = this.prepareParam(max, 'max');
+    return this.test({
+      message,
+      name: 'max',
+      exclusive: true,
+      params: {
+        max
+      },
+      skipAbsent: true,
+      test(value) {
+        return value <= this.resolve(limit);
+      }
+    });
+  }
+}
+DateSchema.INVALID_DATE = invalidDate;
+
+// @ts-expect-error
+function sortFields(fields, excludedEdges = []) {
+  let edges = [];
+  let nodes = new Set();
+  let excludes = new Set(excludedEdges.map(([a, b]) => `${a}-${b}`));
+  function addNode(depPath, key) {
+    let node = propertyExpr.split(depPath)[0];
+    nodes.add(node);
+    if (!excludes.has(`${key}-${node}`)) edges.push([key, node]);
+  }
+  for (const key of Object.keys(fields)) {
+    let value = fields[key];
+    nodes.add(key);
+    if (Reference.isRef(value) && value.isSibling) addNode(value.path, key);else if (isSchema(value) && 'deps' in value) value.deps.forEach(path => addNode(path, key));
+  }
+  return toposort$1.array(Array.from(nodes), edges).reverse();
+}
+
+function findIndex(arr, err) {
+  let idx = Infinity;
+  arr.some((key, ii) => {
+    var _err$path;
+    if ((_err$path = err.path) != null && _err$path.includes(key)) {
+      idx = ii;
+      return true;
+    }
+  });
+  return idx;
+}
+function sortByKeyOrder(keys) {
+  return (a, b) => {
+    return findIndex(keys, a) - findIndex(keys, b);
+  };
+}
+
+const parseJson = (value, _, ctx) => {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  let parsed = value;
+  try {
+    parsed = JSON.parse(value);
+  } catch (err) {
+    /* */
+  }
+  return ctx.isType(parsed) ? parsed : value;
+};
+
+// @ts-ignore
+function deepPartial(schema) {
+  if ('fields' in schema) {
+    const partial = {};
+    for (const [key, fieldSchema] of Object.entries(schema.fields)) {
+      partial[key] = deepPartial(fieldSchema);
+    }
+    return schema.setFields(partial);
+  }
+  if (schema.type === 'array') {
+    const nextArray = schema.optional();
+    if (nextArray.innerType) nextArray.innerType = deepPartial(nextArray.innerType);
+    return nextArray;
+  }
+  if (schema.type === 'tuple') {
+    return schema.optional().clone({
+      types: schema.spec.types.map(deepPartial)
+    });
+  }
+  if ('optional' in schema) {
+    return schema.optional();
+  }
+  return schema;
+}
+const deepHas = (obj, p) => {
+  const path = [...propertyExpr.normalizePath(p)];
+  if (path.length === 1) return path[0] in obj;
+  let last = path.pop();
+  let parent = propertyExpr.getter(propertyExpr.join(path), true)(obj);
+  return !!(parent && last in parent);
+};
+let isObject = obj => Object.prototype.toString.call(obj) === '[object Object]';
+function unknown(ctx, value) {
+  let known = Object.keys(ctx.fields);
+  return Object.keys(value).filter(key => known.indexOf(key) === -1);
+}
+const defaultSort = sortByKeyOrder([]);
+function create$3(spec) {
+  return new ObjectSchema(spec);
+}
+class ObjectSchema extends Schema {
+  constructor(spec) {
+    super({
+      type: 'object',
+      check(value) {
+        return isObject(value) || typeof value === 'function';
+      }
+    });
+    this.fields = Object.create(null);
+    this._sortErrors = defaultSort;
+    this._nodes = [];
+    this._excludedEdges = [];
+    this.withMutation(() => {
+      if (spec) {
+        this.shape(spec);
+      }
+    });
+  }
+  _cast(_value, options = {}) {
+    var _options$stripUnknown;
+    let value = super._cast(_value, options);
+
+    //should ignore nulls here
+    if (value === undefined) return this.getDefault(options);
+    if (!this._typeCheck(value)) return value;
+    let fields = this.fields;
+    let strip = (_options$stripUnknown = options.stripUnknown) != null ? _options$stripUnknown : this.spec.noUnknown;
+    let props = [].concat(this._nodes, Object.keys(value).filter(v => !this._nodes.includes(v)));
+    let intermediateValue = {}; // is filled during the transform below
+    let innerOptions = Object.assign({}, options, {
+      parent: intermediateValue,
+      __validating: options.__validating || false
+    });
+    let isChanged = false;
+    for (const prop of props) {
+      let field = fields[prop];
+      let exists = (prop in value);
+      if (field) {
+        let fieldValue;
+        let inputValue = value[prop];
+
+        // safe to mutate since this is fired in sequence
+        innerOptions.path = (options.path ? `${options.path}.` : '') + prop;
+        field = field.resolve({
+          value: inputValue,
+          context: options.context,
+          parent: intermediateValue
+        });
+        let fieldSpec = field instanceof Schema ? field.spec : undefined;
+        let strict = fieldSpec == null ? void 0 : fieldSpec.strict;
+        if (fieldSpec != null && fieldSpec.strip) {
+          isChanged = isChanged || prop in value;
+          continue;
+        }
+        fieldValue = !options.__validating || !strict ?
+        // TODO: use _cast, this is double resolving
+        field.cast(value[prop], innerOptions) : value[prop];
+        if (fieldValue !== undefined) {
+          intermediateValue[prop] = fieldValue;
+        }
+      } else if (exists && !strip) {
+        intermediateValue[prop] = value[prop];
+      }
+      if (exists !== prop in intermediateValue || intermediateValue[prop] !== value[prop]) {
+        isChanged = true;
+      }
+    }
+    return isChanged ? intermediateValue : value;
+  }
+  _validate(_value, options = {}, panic, next) {
+    let {
+      from = [],
+      originalValue = _value,
+      recursive = this.spec.recursive
+    } = options;
+    options.from = [{
+      schema: this,
+      value: originalValue
+    }, ...from];
+    // this flag is needed for handling `strict` correctly in the context of
+    // validation vs just casting. e.g strict() on a field is only used when validating
+    options.__validating = true;
+    options.originalValue = originalValue;
+    super._validate(_value, options, panic, (objectErrors, value) => {
+      if (!recursive || !isObject(value)) {
+        next(objectErrors, value);
+        return;
+      }
+      originalValue = originalValue || value;
+      let tests = [];
+      for (let key of this._nodes) {
+        let field = this.fields[key];
+        if (!field || Reference.isRef(field)) {
+          continue;
+        }
+        tests.push(field.asNestedTest({
+          options,
+          key,
+          parent: value,
+          parentPath: options.path,
+          originalParent: originalValue
+        }));
+      }
+      this.runTests({
+        tests,
+        value,
+        originalValue,
+        options
+      }, panic, fieldErrors => {
+        next(fieldErrors.sort(this._sortErrors).concat(objectErrors), value);
+      });
+    });
+  }
+  clone(spec) {
+    const next = super.clone(spec);
+    next.fields = Object.assign({}, this.fields);
+    next._nodes = this._nodes;
+    next._excludedEdges = this._excludedEdges;
+    next._sortErrors = this._sortErrors;
+    return next;
+  }
+  concat(schema) {
+    let next = super.concat(schema);
+    let nextFields = next.fields;
+    for (let [field, schemaOrRef] of Object.entries(this.fields)) {
+      const target = nextFields[field];
+      nextFields[field] = target === undefined ? schemaOrRef : target;
+    }
+    return next.withMutation(s =>
+    // XXX: excludes here is wrong
+    s.setFields(nextFields, [...this._excludedEdges, ...schema._excludedEdges]));
+  }
+  _getDefault(options) {
+    if ('default' in this.spec) {
+      return super._getDefault(options);
+    }
+
+    // if there is no default set invent one
+    if (!this._nodes.length) {
+      return undefined;
+    }
+    let dft = {};
+    this._nodes.forEach(key => {
+      var _innerOptions;
+      const field = this.fields[key];
+      let innerOptions = options;
+      if ((_innerOptions = innerOptions) != null && _innerOptions.value) {
+        innerOptions = Object.assign({}, innerOptions, {
+          parent: innerOptions.value,
+          value: innerOptions.value[key]
+        });
+      }
+      dft[key] = field && 'getDefault' in field ? field.getDefault(innerOptions) : undefined;
+    });
+    return dft;
+  }
+  setFields(shape, excludedEdges) {
+    let next = this.clone();
+    next.fields = shape;
+    next._nodes = sortFields(shape, excludedEdges);
+    next._sortErrors = sortByKeyOrder(Object.keys(shape));
+    // XXX: this carries over edges which may not be what you want
+    if (excludedEdges) next._excludedEdges = excludedEdges;
+    return next;
+  }
+  shape(additions, excludes = []) {
+    return this.clone().withMutation(next => {
+      let edges = next._excludedEdges;
+      if (excludes.length) {
+        if (!Array.isArray(excludes[0])) excludes = [excludes];
+        edges = [...next._excludedEdges, ...excludes];
+      }
+
+      // XXX: excludes here is wrong
+      return next.setFields(Object.assign(next.fields, additions), edges);
+    });
+  }
+  partial() {
+    const partial = {};
+    for (const [key, schema] of Object.entries(this.fields)) {
+      partial[key] = 'optional' in schema && schema.optional instanceof Function ? schema.optional() : schema;
+    }
+    return this.setFields(partial);
+  }
+  deepPartial() {
+    const next = deepPartial(this);
+    return next;
+  }
+  pick(keys) {
+    const picked = {};
+    for (const key of keys) {
+      if (this.fields[key]) picked[key] = this.fields[key];
+    }
+    return this.setFields(picked, this._excludedEdges.filter(([a, b]) => keys.includes(a) && keys.includes(b)));
+  }
+  omit(keys) {
+    const remaining = [];
+    for (const key of Object.keys(this.fields)) {
+      if (keys.includes(key)) continue;
+      remaining.push(key);
+    }
+    return this.pick(remaining);
+  }
+  from(from, to, alias) {
+    let fromGetter = propertyExpr.getter(from, true);
+    return this.transform(obj => {
+      if (!obj) return obj;
+      let newObj = obj;
+      if (deepHas(obj, from)) {
+        newObj = Object.assign({}, obj);
+        if (!alias) delete newObj[from];
+        newObj[to] = fromGetter(obj);
+      }
+      return newObj;
+    });
+  }
+
+  /** Parse an input JSON string to an object */
+  json() {
+    return this.transform(parseJson);
+  }
+
+  /**
+   * Similar to `noUnknown` but only validates that an object is the right shape without stripping the unknown keys
+   */
+  exact(message) {
+    return this.test({
+      name: 'exact',
+      exclusive: true,
+      message: message || object.exact,
+      test(value) {
+        if (value == null) return true;
+        const unknownKeys = unknown(this.schema, value);
+        return unknownKeys.length === 0 || this.createError({
+          params: {
+            properties: unknownKeys.join(', ')
+          }
+        });
+      }
+    });
+  }
+  stripUnknown() {
+    return this.clone({
+      noUnknown: true
+    });
+  }
+  noUnknown(noAllow = true, message = object.noUnknown) {
+    if (typeof noAllow !== 'boolean') {
+      message = noAllow;
+      noAllow = true;
+    }
+    let next = this.test({
+      name: 'noUnknown',
+      exclusive: true,
+      message: message,
+      test(value) {
+        if (value == null) return true;
+        const unknownKeys = unknown(this.schema, value);
+        return !noAllow || unknownKeys.length === 0 || this.createError({
+          params: {
+            unknown: unknownKeys.join(', ')
+          }
+        });
+      }
+    });
+    next.spec.noUnknown = noAllow;
+    return next;
+  }
+  unknown(allow = true, message = object.noUnknown) {
+    return this.noUnknown(!allow, message);
+  }
+  transformKeys(fn) {
+    return this.transform(obj => {
+      if (!obj) return obj;
+      const result = {};
+      for (const key of Object.keys(obj)) result[fn(key)] = obj[key];
+      return result;
+    });
+  }
+  camelCase() {
+    return this.transformKeys(tinyCase.camelCase);
+  }
+  snakeCase() {
+    return this.transformKeys(tinyCase.snakeCase);
+  }
+  constantCase() {
+    return this.transformKeys(key => tinyCase.snakeCase(key).toUpperCase());
+  }
+  describe(options) {
+    const next = (options ? this.resolve(options) : this).clone();
+    const base = super.describe(options);
+    base.fields = {};
+    for (const [key, value] of Object.entries(next.fields)) {
+      var _innerOptions2;
+      let innerOptions = options;
+      if ((_innerOptions2 = innerOptions) != null && _innerOptions2.value) {
+        innerOptions = Object.assign({}, innerOptions, {
+          parent: innerOptions.value,
+          value: innerOptions.value[key]
+        });
+      }
+      base.fields[key] = value.describe(innerOptions);
+    }
+    return base;
+  }
+}
+create$3.prototype = ObjectSchema.prototype;
+
+var createValidationSchema = function (fields) {
+    var schema = {};
+    fields.forEach(function (field) {
+        // Excluir campos que no tienen name o son de tipos especiales
+        if (!field.name ||
+            ['declaration', 'subtitle', 'alert', 'status'].includes(field.type)) {
+            return;
+        }
+        if (field.validations && field.validations.length > 0) {
+            var fieldSchema_1 = create$6();
+            field.validations.forEach(function (validation) {
+                switch (validation.type) {
+                    case 'required':
+                        fieldSchema_1 = fieldSchema_1.required(validation.params[0] || 'Este campo es requerido');
+                        break;
+                    case 'min':
+                        var minLength = parseInt(validation.params[0]);
+                        var minMessage = validation.params[1] || "M\u00EDnimo ".concat(minLength, " caracteres");
+                        fieldSchema_1 = fieldSchema_1.min(minLength, minMessage);
+                        break;
+                    case 'max':
+                        var maxLength = parseInt(validation.params[0]);
+                        var maxMessage = validation.params[1] || "M\u00E1ximo ".concat(maxLength, " caracteres");
+                        fieldSchema_1 = fieldSchema_1.max(maxLength, maxMessage);
+                        break;
+                    case 'email':
+                        var emailMessage = validation.params[0] || 'Email inválido';
+                        fieldSchema_1 = fieldSchema_1.email(emailMessage);
+                        break;
+                    case 'pattern':
+                        var pattern = new RegExp(validation.params[0]);
+                        var patternMessage = validation.params[1] || 'Formato inválido';
+                        fieldSchema_1 = fieldSchema_1.matches(pattern, patternMessage);
+                        break;
+                    case 'custom':
+                        // Para validaciones personalizadas
+                        var customValidator = validation.params[0];
+                        if (customValidator === 'rut') {
+                            fieldSchema_1 = fieldSchema_1.test('rut', validation.params[1] || 'RUT inválido', function (value) {
+                                if (!value)
+                                    return true; // Si está vacío, la validación required se encargará
+                                return validate(clean(value));
+                            });
+                        }
+                        else {
+                            fieldSchema_1 = fieldSchema_1.test('custom', validation.params[1] || 'Validación fallida', function (value) {
+                                // Aquí puedes implementar lógica personalizada
+                                return value; // Por defecto pasa la validación
+                            });
+                        }
+                        break;
+                }
+            });
+            schema[field.name] = fieldSchema_1;
+        }
+        else if (field.required) {
+            // Validación básica de requerido si no hay validaciones específicas
+            schema[field.name] = create$6().required("El campo ".concat(field.label, " es requerido"));
+        }
+    });
+    return create$3().shape(schema);
+};
+// Validaciones predefinidas
+var commonValidations = {
+    required: function (message) { return ({
+        type: 'required',
+        params: [message || 'Este campo es requerido'],
+    }); },
+    min: function (length, message) { return ({
+        type: 'min',
+        params: [length.toString(), message || "M\u00EDnimo ".concat(length, " caracteres")],
+    }); },
+    max: function (length, message) { return ({
+        type: 'max',
+        params: [length.toString(), message || "M\u00E1ximo ".concat(length, " caracteres")],
+    }); },
+    email: function (message) { return ({
+        type: 'email',
+        params: [message || 'Email inválido'],
+    }); },
+    pattern: function (regex, message) { return ({
+        type: 'pattern',
+        params: [regex, message || 'Formato inválido'],
+    }); },
+};
+
+var GenericForm = function (_a) {
+    var _b, _c, _d, _e, _f, _g, _h;
+    var config = _a.config, _j = _a.stepperData, stepperData = _j === void 0 ? {} : _j, onStepComplete = _a.onStepComplete, _k = _a.loading, loading = _k === void 0 ? false : _k, _l = _a.className, className = _l === void 0 ? '' : _l;
+    // Función para obtener datos del stepper o valores por defecto
+    var getFieldValue = function (field) {
+        var _a;
+        // Prioridad 1: Valor por defecto del campo (máxima prioridad)
+        if ((field === null || field === void 0 ? void 0 : field.value) !== undefined) {
+            return field.value;
+        }
+        // Prioridad 2: Datos del stepper si existe
+        if ((stepperData === null || stepperData === void 0 ? void 0 : stepperData[field === null || field === void 0 ? void 0 : field.name]) !== undefined) {
+            return stepperData[field === null || field === void 0 ? void 0 : field.name];
+        }
+        // Prioridad 3: Datos iniciales de la configuración
+        if (((_a = config.initialData) === null || _a === void 0 ? void 0 : _a[field.name]) !== undefined) {
+            return config.initialData[field.name];
+        }
+        // Prioridad 4: Valor vacío
+        return '';
+    };
+    // Inicializar formData con datos existentes o valores por defecto
+    var getInitialFormData = function () {
+        var initialData = {};
+        if (Array.isArray(config.fields)) {
+            config.fields.forEach(function (field) {
+                initialData[field.name] = getFieldValue(field);
+            });
+        }
+        return initialData;
+    };
+    var _m = React.useState(getInitialFormData), formData = _m[0], setFormData = _m[1];
+    var _o = React.useState({}), errors = _o[0], setErrors = _o[1];
+    // Sincronizar formData cuando cambie stepperData
+    React.useEffect(function () {
+        if (stepperData && Array.isArray(config.fields)) {
+            var updatedFormData_1 = {};
+            config.fields.forEach(function (field) {
+                updatedFormData_1[field.name] =
+                    (stepperData === null || stepperData === void 0 ? void 0 : stepperData[field.name]) ||
+                        formData[field.name] ||
+                        (field === null || field === void 0 ? void 0 : field.value);
+            });
+            setFormData(function (prev) { return (__assign$1(__assign$1({}, prev), updatedFormData_1)); });
+        }
+    }, [stepperData, config.fields]);
+    var handleInputChange = function (e) {
+        var _a = e.target, name = _a.name, value = _a.value, type = _a.type;
+        var checked = type === 'checkbox' ? e.target.checked : undefined;
+        var newValue = type === 'checkbox' ? checked : value;
+        // Actualizar estado local
+        setFormData(function (prevData) {
+            var _a;
+            return (__assign$1(__assign$1({}, prevData), (_a = {}, _a[name] = newValue, _a)));
+        });
+        // Limpiar error del campo
+        if (errors[name]) {
+            setErrors(function (prev) {
+                var _a;
+                return (__assign$1(__assign$1({}, prev), (_a = {}, _a[name] = '', _a)));
+            });
+        }
+    };
+    var validateForm = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var validationSchema, validationError_1, newErrors_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    validationSchema = createValidationSchema(config.fields);
+                    // Validar los datos del formulario
+                    return [4 /*yield*/, validationSchema.validate(__assign$1(__assign$1({}, formData), stepperData), { abortEarly: false })];
+                case 1:
+                    // Validar los datos del formulario
+                    _a.sent();
+                    // Si llega aquí, la validación fue exitosa
+                    setErrors({});
+                    return [2 /*return*/, true];
+                case 2:
+                    validationError_1 = _a.sent();
+                    newErrors_1 = {};
+                    if (validationError_1.inner) {
+                        validationError_1.inner.forEach(function (error) {
+                            newErrors_1[error.path] = error.message;
+                        });
+                    }
+                    setErrors(newErrors_1);
+                    return [2 /*return*/, false];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); };
+    var handleNext = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var isValid;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, validateForm()];
+                case 1:
+                    isValid = _a.sent();
+                    if (isValid) {
+                        if (onStepComplete) {
+                            onStepComplete(2); // Asumiendo que es el paso 2, se puede hacer configurable
+                        }
+                        if (config.onNext) {
+                            config.onNext(__assign$1(__assign$1({}, stepperData), formData));
+                        }
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var handleOut = function () {
+        if (config.onOut) {
+            config.onOut();
+        }
+    };
+    var handleBack = function () {
+        if (config.onBack) {
+            config.onBack();
+        }
+    };
+    var renderField = function (field) {
+        var _a, _b, _c;
+        // Prioridad: field.value > formData > getFieldValue
+        var fieldValue = (_b = (_a = formData[field.name]) !== null && _a !== void 0 ? _a : field.value) !== null && _b !== void 0 ? _b : getFieldValue(field);
+        // Preparar el campo con las funciones de búsqueda si están disponibles
+        var fieldWithHandlers = __assign$1(__assign$1({}, field), { onSearch: function (value) {
+                var _a;
+                if (field.onSearch) {
+                    (_a = config.onSearch) === null || _a === void 0 ? void 0 : _a.call(config, field, value, __assign$1(__assign$1({}, stepperData), formData));
+                }
+            } });
+        return (jsxRuntime.jsx("div", { className: (_c = field.className) !== null && _c !== void 0 ? _c : 'col-span-12 md:col-span-6', children: jsxRuntime.jsx(DynamicInput, { field: fieldWithHandlers, value: fieldValue, onChange: handleInputChange, error: errors[field.name] }) }, field.id));
+    };
+    var buttonHandlers = {
+        handleBack: handleBack,
+        handleNext: handleNext,
+        handleOut: handleOut,
+        // agrega más handlers si es necesario
+    };
+    var isButtonDisabled = function (btn) {
+        if (config.fields.length === 0)
+            return false;
+        if (btn.direction === 'back' || btn.direction === 'out-light')
+            return false;
+        // Tu lógica de disabled para los demás botones:
+        return (btn.disabled ||
+            loading ||
+            !Object.values(formData).some(function (value) { return value !== '' && value !== false; }));
+    };
+    if (loading) {
+        return (jsxRuntime.jsxs("div", { className: "min-h-[550px] flex flex-col justify-between gap-10 ".concat(className), children: [jsxRuntime.jsxs("div", { className: "flex flex-col gap-10", children: [jsxRuntime.jsxs("div", { id: "title", children: [jsxRuntime.jsx("div", { className: "h-8 bg-gray-200 rounded animate-pulse w-3/4 mb-2" }), jsxRuntime.jsx("div", { className: "w-full h-[3px] bg-gray-200 rounded-full animate-pulse" })] }), jsxRuntime.jsxs("div", { className: "text-gray-500 text-lg font-normal flex flex-col gap-2", children: [jsxRuntime.jsx("div", { className: "h-6 bg-gray-200 rounded animate-pulse w-1/2 ml-5" }), jsxRuntime.jsx("div", { className: "w-full h-[1px] bg-gray-200 animate-pulse" })] }), jsxRuntime.jsx("div", { children: jsxRuntime.jsx("div", { className: "flex max-w-1xl mx-auto flex-col gap-4", children: jsxRuntime.jsx("div", { className: "grid grid-cols-12 gap-4", children: (_b = config === null || config === void 0 ? void 0 : config.fields) === null || _b === void 0 ? void 0 : _b.map(function (field) { return (jsxRuntime.jsxs("div", { className: "col-span-12 md:col-span-6", children: [jsxRuntime.jsx("div", { className: "h-4 bg-gray-200 rounded animate-pulse w-1/3 mb-2" }), jsxRuntime.jsx("div", { className: "h-10 bg-gray-200 rounded animate-pulse w-full" })] }, field.id)); }) }) }) })] }), jsxRuntime.jsxs("div", { className: "flex justify-between", children: [jsxRuntime.jsxs("div", { className: "flex gap-2", children: [jsxRuntime.jsx("div", { className: "h-10 bg-gray-200 rounded animate-pulse w-20" }), jsxRuntime.jsx("div", { className: "h-10 bg-gray-200 rounded animate-pulse w-20" })] }), jsxRuntime.jsx("div", { className: "h-10 bg-gray-200 rounded animate-pulse w-24" })] })] }));
+    }
+    return (jsxRuntime.jsxs("div", { className: "min-h-[550px] flex flex-col justify-between gap-10 ".concat(className), children: [jsxRuntime.jsxs("div", { className: "flex flex-col gap-10", children: [jsxRuntime.jsxs("div", { id: "title", children: [jsxRuntime.jsx("h1", { className: "text-gray-800 text-3xl font-bold font-roboto", children: config.title }), jsxRuntime.jsx("div", { className: "w-full h-[3px] bg-orange-500 rounded-full mt-2" })] }), (config === null || config === void 0 ? void 0 : config.subtitle) && (jsxRuntime.jsx(jsxRuntime.Fragment, { children: jsxRuntime.jsxs("div", { className: "text-gray-500 text-lg font-normal flex flex-col gap-2", children: [jsxRuntime.jsx("h3", { className: "pl-5 text-[24px] text-gray-800 text-xl font-bold font-roboto", children: config.subtitle }), jsxRuntime.jsx("hr", { className: "w-full border-gray-400" })] }) })), config.showInfoAlert && config.infoMessage && (jsxRuntime.jsx(Alert, { type: (_c = config.infoMessage.type) !== null && _c !== void 0 ? _c : 'info', text: config.infoMessage.message })), jsxRuntime.jsx("div", { children: jsxRuntime.jsx("form", { className: "flex max-w-1xl mx-auto flex-col gap-4", children: jsxRuntime.jsx("div", { className: "grid grid-cols-12 gap-4", children: config.fields.map(renderField) }) }) })] }), ((_d = config === null || config === void 0 ? void 0 : config.navigation) === null || _d === void 0 ? void 0 : _d.buttons) && (jsxRuntime.jsx("div", { className: (_f = (_e = config.navigation) === null || _e === void 0 ? void 0 : _e.containerClass) !== null && _f !== void 0 ? _f : 'flex justify-between', children: (_h = (_g = config === null || config === void 0 ? void 0 : config.navigation) === null || _g === void 0 ? void 0 : _g.buttons) === null || _h === void 0 ? void 0 : _h.map(function (btn) {
+                    var _a;
+                    return btn.show ? (jsxRuntime.jsx("div", { className: (_a = btn.className) !== null && _a !== void 0 ? _a : '', children: jsxRuntime.jsx(NavigationButton, { direction: btn.direction, onClick: buttonHandlers[btn.onClick], disabled: isButtonDisabled(btn), label: btn.label }) }, btn.key)) : null;
+                }) }))] }));
+};
+
+exports.Alert = Alert;
+exports.CheckboxInput = CheckboxInput;
+exports.DynamicInput = DynamicInput;
+exports.GenericForm = GenericForm;
+exports.InputWrapper = InputWrapper;
+exports.NavigationButton = NavigationButton;
+exports.RutInput = RutInput;
+exports.SelectInput = SelectInput;
+exports.TextInput = TextInput;
+exports.TextareaInput = TextareaInput;
+exports.cleanRut = clean;
+exports.commonValidations = commonValidations;
+exports.createValidationSchema = createValidationSchema;
+exports.formatRut = formatRut;
+exports.maskRut = maskRut;
+exports.validateOnlyNumbersAndLetters = validateOnlyNumbersAndLetters;
+exports.validateRut = validate;
+//# sourceMappingURL=index.js.map