@remoteoss/json-schema-form 0.6.4-beta.0 → 0.6.5-beta.0

package/dist/standalone.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.6.4-beta.0
- Generated: Fri, 15 Sep 2023 12:36:13 GMT
+ NPM Package: @remoteoss/json-schema-form@0.6.5-beta.0
+ Generated: Mon, 18 Sep 2023 10:09:01 GMT
 
  MIT License
 
@@ -5648,6 +5648,384 @@ var require_isEmpty = __commonJS({
   }
 });
 
+// node_modules/json-logic-js/logic.js
+var require_logic = __commonJS({
+  "node_modules/json-logic-js/logic.js"(exports2, module2) {
+    (function(root2, factory) {
+      if (typeof define === "function" && define.amd) {
+        define(factory);
+      } else if (typeof exports2 === "object") {
+        module2.exports = factory();
+      } else {
+        root2.jsonLogic = factory();
+      }
+    })(exports2, function() {
+      "use strict";
+      if (!Array.isArray) {
+        Array.isArray = function(arg) {
+          return Object.prototype.toString.call(arg) === "[object Array]";
+        };
+      }
+      function arrayUnique(array2) {
+        var a = [];
+        for (var i = 0, l = array2.length; i < l; i++) {
+          if (a.indexOf(array2[i]) === -1) {
+            a.push(array2[i]);
+          }
+        }
+        return a;
+      }
+      var jsonLogic2 = {};
+      var operations = {
+        "==": function(a, b) {
+          return a == b;
+        },
+        "===": function(a, b) {
+          return a === b;
+        },
+        "!=": function(a, b) {
+          return a != b;
+        },
+        "!==": function(a, b) {
+          return a !== b;
+        },
+        ">": function(a, b) {
+          return a > b;
+        },
+        ">=": function(a, b) {
+          return a >= b;
+        },
+        "<": function(a, b, c) {
+          return c === void 0 ? a < b : a < b && b < c;
+        },
+        "<=": function(a, b, c) {
+          return c === void 0 ? a <= b : a <= b && b <= c;
+        },
+        "!!": function(a) {
+          return jsonLogic2.truthy(a);
+        },
+        "!": function(a) {
+          return !jsonLogic2.truthy(a);
+        },
+        "%": function(a, b) {
+          return a % b;
+        },
+        "log": function(a) {
+          console.log(a);
+          return a;
+        },
+        "in": function(a, b) {
+          if (!b || typeof b.indexOf === "undefined")
+            return false;
+          return b.indexOf(a) !== -1;
+        },
+        "cat": function() {
+          return Array.prototype.join.call(arguments, "");
+        },
+        "substr": function(source, start, end) {
+          if (end < 0) {
+            var temp = String(source).substr(start);
+            return temp.substr(0, temp.length + end);
+          }
+          return String(source).substr(start, end);
+        },
+        "+": function() {
+          return Array.prototype.reduce.call(arguments, function(a, b) {
+            return parseFloat(a, 10) + parseFloat(b, 10);
+          }, 0);
+        },
+        "*": function() {
+          return Array.prototype.reduce.call(arguments, function(a, b) {
+            return parseFloat(a, 10) * parseFloat(b, 10);
+          });
+        },
+        "-": function(a, b) {
+          if (b === void 0) {
+            return -a;
+          } else {
+            return a - b;
+          }
+        },
+        "/": function(a, b) {
+          return a / b;
+        },
+        "min": function() {
+          return Math.min.apply(this, arguments);
+        },
+        "max": function() {
+          return Math.max.apply(this, arguments);
+        },
+        "merge": function() {
+          return Array.prototype.reduce.call(arguments, function(a, b) {
+            return a.concat(b);
+          }, []);
+        },
+        "var": function(a, b) {
+          var not_found = b === void 0 ? null : b;
+          var data = this;
+          if (typeof a === "undefined" || a === "" || a === null) {
+            return data;
+          }
+          var sub_props = String(a).split(".");
+          for (var i = 0; i < sub_props.length; i++) {
+            if (data === null || data === void 0) {
+              return not_found;
+            }
+            data = data[sub_props[i]];
+            if (data === void 0) {
+              return not_found;
+            }
+          }
+          return data;
+        },
+        "missing": function() {
+          var missing = [];
+          var keys2 = Array.isArray(arguments[0]) ? arguments[0] : arguments;
+          for (var i = 0; i < keys2.length; i++) {
+            var key = keys2[i];
+            var value = jsonLogic2.apply({ "var": key }, this);
+            if (value === null || value === "") {
+              missing.push(key);
+            }
+          }
+          return missing;
+        },
+        "missing_some": function(need_count, options) {
+          var are_missing = jsonLogic2.apply({ "missing": options }, this);
+          if (options.length - are_missing.length >= need_count) {
+            return [];
+          } else {
+            return are_missing;
+          }
+        }
+      };
+      jsonLogic2.is_logic = function(logic) {
+        return typeof logic === "object" && // An object
+        logic !== null && // but not null
+        !Array.isArray(logic) && // and not an array
+        Object.keys(logic).length === 1;
+      };
+      jsonLogic2.truthy = function(value) {
+        if (Array.isArray(value) && value.length === 0) {
+          return false;
+        }
+        return !!value;
+      };
+      jsonLogic2.get_operator = function(logic) {
+        return Object.keys(logic)[0];
+      };
+      jsonLogic2.get_values = function(logic) {
+        return logic[jsonLogic2.get_operator(logic)];
+      };
+      jsonLogic2.apply = function(logic, data) {
+        if (Array.isArray(logic)) {
+          return logic.map(function(l) {
+            return jsonLogic2.apply(l, data);
+          });
+        }
+        if (!jsonLogic2.is_logic(logic)) {
+          return logic;
+        }
+        var op = jsonLogic2.get_operator(logic);
+        var values2 = logic[op];
+        var i;
+        var current;
+        var scopedLogic;
+        var scopedData;
+        var initial;
+        if (!Array.isArray(values2)) {
+          values2 = [values2];
+        }
+        if (op === "if" || op == "?:") {
+          for (i = 0; i < values2.length - 1; i += 2) {
+            if (jsonLogic2.truthy(jsonLogic2.apply(values2[i], data))) {
+              return jsonLogic2.apply(values2[i + 1], data);
+            }
+          }
+          if (values2.length === i + 1) {
+            return jsonLogic2.apply(values2[i], data);
+          }
+          return null;
+        } else if (op === "and") {
+          for (i = 0; i < values2.length; i += 1) {
+            current = jsonLogic2.apply(values2[i], data);
+            if (!jsonLogic2.truthy(current)) {
+              return current;
+            }
+          }
+          return current;
+        } else if (op === "or") {
+          for (i = 0; i < values2.length; i += 1) {
+            current = jsonLogic2.apply(values2[i], data);
+            if (jsonLogic2.truthy(current)) {
+              return current;
+            }
+          }
+          return current;
+        } else if (op === "filter") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData)) {
+            return [];
+          }
+          return scopedData.filter(function(datum) {
+            return jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, datum));
+          });
+        } else if (op === "map") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData)) {
+            return [];
+          }
+          return scopedData.map(function(datum) {
+            return jsonLogic2.apply(scopedLogic, datum);
+          });
+        } else if (op === "reduce") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          initial = typeof values2[2] !== "undefined" ? values2[2] : null;
+          if (!Array.isArray(scopedData)) {
+            return initial;
+          }
+          return scopedData.reduce(
+            function(accumulator, current2) {
+              return jsonLogic2.apply(
+                scopedLogic,
+                { current: current2, accumulator }
+              );
+            },
+            initial
+          );
+        } else if (op === "all") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData) || !scopedData.length) {
+            return false;
+          }
+          for (i = 0; i < scopedData.length; i += 1) {
+            if (!jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, scopedData[i]))) {
+              return false;
+            }
+          }
+          return true;
+        } else if (op === "none") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData) || !scopedData.length) {
+            return true;
+          }
+          for (i = 0; i < scopedData.length; i += 1) {
+            if (jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, scopedData[i]))) {
+              return false;
+            }
+          }
+          return true;
+        } else if (op === "some") {
+          scopedData = jsonLogic2.apply(values2[0], data);
+          scopedLogic = values2[1];
+          if (!Array.isArray(scopedData) || !scopedData.length) {
+            return false;
+          }
+          for (i = 0; i < scopedData.length; i += 1) {
+            if (jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, scopedData[i]))) {
+              return true;
+            }
+          }
+          return false;
+        }
+        values2 = values2.map(function(val) {
+          return jsonLogic2.apply(val, data);
+        });
+        if (operations.hasOwnProperty(op) && typeof operations[op] === "function") {
+          return operations[op].apply(data, values2);
+        } else if (op.indexOf(".") > 0) {
+          var sub_ops = String(op).split(".");
+          var operation = operations;
+          for (i = 0; i < sub_ops.length; i++) {
+            if (!operation.hasOwnProperty(sub_ops[i])) {
+              throw new Error("Unrecognized operation " + op + " (failed at " + sub_ops.slice(0, i + 1).join(".") + ")");
+            }
+            operation = operation[sub_ops[i]];
+          }
+          return operation.apply(data, values2);
+        }
+        throw new Error("Unrecognized operation " + op);
+      };
+      jsonLogic2.uses_data = function(logic) {
+        var collection = [];
+        if (jsonLogic2.is_logic(logic)) {
+          var op = jsonLogic2.get_operator(logic);
+          var values2 = logic[op];
+          if (!Array.isArray(values2)) {
+            values2 = [values2];
+          }
+          if (op === "var") {
+            collection.push(values2[0]);
+          } else {
+            values2.forEach(function(val) {
+              collection.push.apply(collection, jsonLogic2.uses_data(val));
+            });
+          }
+        }
+        return arrayUnique(collection);
+      };
+      jsonLogic2.add_operation = function(name, code) {
+        operations[name] = code;
+      };
+      jsonLogic2.rm_operation = function(name) {
+        delete operations[name];
+      };
+      jsonLogic2.rule_like = function(rule, pattern) {
+        if (pattern === rule) {
+          return true;
+        }
+        if (pattern === "@") {
+          return true;
+        }
+        if (pattern === "number") {
+          return typeof rule === "number";
+        }
+        if (pattern === "string") {
+          return typeof rule === "string";
+        }
+        if (pattern === "array") {
+          return Array.isArray(rule) && !jsonLogic2.is_logic(rule);
+        }
+        if (jsonLogic2.is_logic(pattern)) {
+          if (jsonLogic2.is_logic(rule)) {
+            var pattern_op = jsonLogic2.get_operator(pattern);
+            var rule_op = jsonLogic2.get_operator(rule);
+            if (pattern_op === "@" || pattern_op === rule_op) {
+              return jsonLogic2.rule_like(
+                jsonLogic2.get_values(rule, false),
+                jsonLogic2.get_values(pattern, false)
+              );
+            }
+          }
+          return false;
+        }
+        if (Array.isArray(pattern)) {
+          if (Array.isArray(rule)) {
+            if (pattern.length !== rule.length) {
+              return false;
+            }
+            for (var i = 0; i < pattern.length; i += 1) {
+              if (!jsonLogic2.rule_like(rule[i], pattern[i])) {
+                return false;
+              }
+            }
+            return true;
+          } else {
+            return false;
+          }
+        }
+        return false;
+      };
+      return jsonLogic2;
+    });
+  }
+});
+
 // node_modules/lodash/_createFlow.js
 var require_createFlow = __commonJS({
   "node_modules/lodash/_createFlow.js"(exports2, module2) {
@@ -6229,573 +6607,195 @@ var require_randexp = __commonJS({
         } else {
           throw new Error("Expected a regexp or string");
         }
-        this.tokens = ret(regexp);
-      }
-      /**
-       * Checks if some custom properties have been set for this regexp.
-       *
-       * @param {RandExp} randexp
-       * @param {RegExp} regexp
-       */
-      _setDefaults(regexp) {
-        this.max = regexp.max != null ? regexp.max : RandExp.prototype.max != null ? RandExp.prototype.max : 100;
-        this.defaultRange = regexp.defaultRange ? regexp.defaultRange : this.defaultRange.clone();
-        if (regexp.randInt) {
-          this.randInt = regexp.randInt;
-        }
-      }
-      /**
-       * Generates the random string.
-       *
-       * @return {String}
-       */
-      gen() {
-        return this._gen(this.tokens, []);
-      }
-      /**
-       * Generate random string modeled after given tokens.
-       *
-       * @param {Object} token
-       * @param {Array.<String>} groups
-       * @return {String}
-       */
-      _gen(token, groups) {
-        var stack, str, n, i, l;
-        switch (token.type) {
-          case types.ROOT:
-          case types.GROUP:
-            if (token.followedBy || token.notFollowedBy) {
-              return "";
-            }
-            if (token.remember && token.groupNumber === void 0) {
-              token.groupNumber = groups.push(null) - 1;
-            }
-            stack = token.options ? this._randSelect(token.options) : token.stack;
-            str = "";
-            for (i = 0, l = stack.length; i < l; i++) {
-              str += this._gen(stack[i], groups);
-            }
-            if (token.remember) {
-              groups[token.groupNumber] = str;
-            }
-            return str;
-          case types.POSITION:
-            return "";
-          case types.SET:
-            var expandedSet = this._expand(token);
-            if (!expandedSet.length) {
-              return "";
-            }
-            return String.fromCharCode(this._randSelect(expandedSet));
-          case types.REPETITION:
-            n = this.randInt(
-              token.min,
-              token.max === Infinity ? token.min + this.max : token.max
-            );
-            str = "";
-            for (i = 0; i < n; i++) {
-              str += this._gen(token.value, groups);
-            }
-            return str;
-          case types.REFERENCE:
-            return groups[token.value - 1] || "";
-          case types.CHAR:
-            var code = this.ignoreCase && this._randBool() ? this._toOtherCase(token.value) : token.value;
-            return String.fromCharCode(code);
-        }
-      }
-      /**
-       * If code is alphabetic, converts to other case.
-       * If not alphabetic, returns back code.
-       *
-       * @param {Number} code
-       * @return {Number}
-       */
-      _toOtherCase(code) {
-        return code + (97 <= code && code <= 122 ? -32 : 65 <= code && code <= 90 ? 32 : 0);
-      }
-      /**
-       * Randomly returns a true or false value.
-       *
-       * @return {Boolean}
-       */
-      _randBool() {
-        return !this.randInt(0, 1);
-      }
-      /**
-       * Randomly selects and returns a value from the array.
-       *
-       * @param {Array.<Object>} arr
-       * @return {Object}
-       */
-      _randSelect(arr) {
-        if (arr instanceof DRange) {
-          return arr.index(this.randInt(0, arr.length - 1));
-        }
-        return arr[this.randInt(0, arr.length - 1)];
-      }
-      /**
-       * expands a token to a DiscontinuousRange of characters which has a
-       * length and an index function (for random selecting)
-       *
-       * @param {Object} token
-       * @return {DiscontinuousRange}
-       */
-      _expand(token) {
-        if (token.type === ret.types.CHAR) {
-          return new DRange(token.value);
-        } else if (token.type === ret.types.RANGE) {
-          return new DRange(token.from, token.to);
-        } else {
-          let drange = new DRange();
-          for (let i = 0; i < token.set.length; i++) {
-            let subrange = this._expand(token.set[i]);
-            drange.add(subrange);
-            if (this.ignoreCase) {
-              for (let j = 0; j < subrange.length; j++) {
-                let code = subrange.index(j);
-                let otherCaseCode = this._toOtherCase(code);
-                if (code !== otherCaseCode) {
-                  drange.add(otherCaseCode);
-                }
-              }
-            }
-          }
-          if (token.not) {
-            return this.defaultRange.clone().subtract(drange);
-          } else {
-            return this.defaultRange.clone().intersect(drange);
-          }
-        }
-      }
-      /**
-       * Randomly generates and returns a number between a and b (inclusive).
-       *
-       * @param {Number} a
-       * @param {Number} b
-       * @return {Number}
-       */
-      randInt(a, b) {
-        return a + Math.floor(Math.random() * (1 + b - a));
+        this.tokens = ret(regexp);
       }
       /**
-       * Default range of characters to generate from.
+       * Checks if some custom properties have been set for this regexp.
+       *
+       * @param {RandExp} randexp
+       * @param {RegExp} regexp
        */
-      get defaultRange() {
-        return this._range = this._range || new DRange(32, 126);
-      }
-      set defaultRange(range) {
-        this._range = range;
+      _setDefaults(regexp) {
+        this.max = regexp.max != null ? regexp.max : RandExp.prototype.max != null ? RandExp.prototype.max : 100;
+        this.defaultRange = regexp.defaultRange ? regexp.defaultRange : this.defaultRange.clone();
+        if (regexp.randInt) {
+          this.randInt = regexp.randInt;
+        }
       }
       /**
+       * Generates the random string.
        *
-       * Enables use of randexp with a shorter call.
-       *
-       * @param {RegExp|String| regexp}
-       * @param {String} m
        * @return {String}
        */
-      static randexp(regexp, m) {
-        var randexp2;
-        if (typeof regexp === "string") {
-          regexp = new RegExp(regexp, m);
-        }
-        if (regexp._randexp === void 0) {
-          randexp2 = new RandExp(regexp, m);
-          regexp._randexp = randexp2;
-        } else {
-          randexp2 = regexp._randexp;
-          randexp2._setDefaults(regexp);
-        }
-        return randexp2.gen();
+      gen() {
+        return this._gen(this.tokens, []);
       }
       /**
-       * Enables sugary /regexp/.gen syntax.
-       */
-      static sugar() {
-        RegExp.prototype.gen = function() {
-          return RandExp.randexp(this);
-        };
-      }
-    };
-  }
-});
-
-// node_modules/json-logic-js/logic.js
-var require_logic = __commonJS({
-  "node_modules/json-logic-js/logic.js"(exports2, module2) {
-    (function(root2, factory) {
-      if (typeof define === "function" && define.amd) {
-        define(factory);
-      } else if (typeof exports2 === "object") {
-        module2.exports = factory();
-      } else {
-        root2.jsonLogic = factory();
-      }
-    })(exports2, function() {
-      "use strict";
-      if (!Array.isArray) {
-        Array.isArray = function(arg) {
-          return Object.prototype.toString.call(arg) === "[object Array]";
-        };
-      }
-      function arrayUnique(array2) {
-        var a = [];
-        for (var i = 0, l = array2.length; i < l; i++) {
-          if (a.indexOf(array2[i]) === -1) {
-            a.push(array2[i]);
-          }
-        }
-        return a;
-      }
-      var jsonLogic2 = {};
-      var operations = {
-        "==": function(a, b) {
-          return a == b;
-        },
-        "===": function(a, b) {
-          return a === b;
-        },
-        "!=": function(a, b) {
-          return a != b;
-        },
-        "!==": function(a, b) {
-          return a !== b;
-        },
-        ">": function(a, b) {
-          return a > b;
-        },
-        ">=": function(a, b) {
-          return a >= b;
-        },
-        "<": function(a, b, c) {
-          return c === void 0 ? a < b : a < b && b < c;
-        },
-        "<=": function(a, b, c) {
-          return c === void 0 ? a <= b : a <= b && b <= c;
-        },
-        "!!": function(a) {
-          return jsonLogic2.truthy(a);
-        },
-        "!": function(a) {
-          return !jsonLogic2.truthy(a);
-        },
-        "%": function(a, b) {
-          return a % b;
-        },
-        "log": function(a) {
-          console.log(a);
-          return a;
-        },
-        "in": function(a, b) {
-          if (!b || typeof b.indexOf === "undefined")
-            return false;
-          return b.indexOf(a) !== -1;
-        },
-        "cat": function() {
-          return Array.prototype.join.call(arguments, "");
-        },
-        "substr": function(source, start, end) {
-          if (end < 0) {
-            var temp = String(source).substr(start);
-            return temp.substr(0, temp.length + end);
-          }
-          return String(source).substr(start, end);
-        },
-        "+": function() {
-          return Array.prototype.reduce.call(arguments, function(a, b) {
-            return parseFloat(a, 10) + parseFloat(b, 10);
-          }, 0);
-        },
-        "*": function() {
-          return Array.prototype.reduce.call(arguments, function(a, b) {
-            return parseFloat(a, 10) * parseFloat(b, 10);
-          });
-        },
-        "-": function(a, b) {
-          if (b === void 0) {
-            return -a;
-          } else {
-            return a - b;
-          }
-        },
-        "/": function(a, b) {
-          return a / b;
-        },
-        "min": function() {
-          return Math.min.apply(this, arguments);
-        },
-        "max": function() {
-          return Math.max.apply(this, arguments);
-        },
-        "merge": function() {
-          return Array.prototype.reduce.call(arguments, function(a, b) {
-            return a.concat(b);
-          }, []);
-        },
-        "var": function(a, b) {
-          var not_found = b === void 0 ? null : b;
-          var data = this;
-          if (typeof a === "undefined" || a === "" || a === null) {
-            return data;
-          }
-          var sub_props = String(a).split(".");
-          for (var i = 0; i < sub_props.length; i++) {
-            if (data === null || data === void 0) {
-              return not_found;
-            }
-            data = data[sub_props[i]];
-            if (data === void 0) {
-              return not_found;
-            }
-          }
-          return data;
-        },
-        "missing": function() {
-          var missing = [];
-          var keys2 = Array.isArray(arguments[0]) ? arguments[0] : arguments;
-          for (var i = 0; i < keys2.length; i++) {
-            var key = keys2[i];
-            var value = jsonLogic2.apply({ "var": key }, this);
-            if (value === null || value === "") {
-              missing.push(key);
-            }
-          }
-          return missing;
-        },
-        "missing_some": function(need_count, options) {
-          var are_missing = jsonLogic2.apply({ "missing": options }, this);
-          if (options.length - are_missing.length >= need_count) {
-            return [];
-          } else {
-            return are_missing;
-          }
-        }
-      };
-      jsonLogic2.is_logic = function(logic) {
-        return typeof logic === "object" && // An object
-        logic !== null && // but not null
-        !Array.isArray(logic) && // and not an array
-        Object.keys(logic).length === 1;
-      };
-      jsonLogic2.truthy = function(value) {
-        if (Array.isArray(value) && value.length === 0) {
-          return false;
-        }
-        return !!value;
-      };
-      jsonLogic2.get_operator = function(logic) {
-        return Object.keys(logic)[0];
-      };
-      jsonLogic2.get_values = function(logic) {
-        return logic[jsonLogic2.get_operator(logic)];
-      };
-      jsonLogic2.apply = function(logic, data) {
-        if (Array.isArray(logic)) {
-          return logic.map(function(l) {
-            return jsonLogic2.apply(l, data);
-          });
-        }
-        if (!jsonLogic2.is_logic(logic)) {
-          return logic;
-        }
-        var op = jsonLogic2.get_operator(logic);
-        var values2 = logic[op];
-        var i;
-        var current;
-        var scopedLogic;
-        var scopedData;
-        var initial;
-        if (!Array.isArray(values2)) {
-          values2 = [values2];
-        }
-        if (op === "if" || op == "?:") {
-          for (i = 0; i < values2.length - 1; i += 2) {
-            if (jsonLogic2.truthy(jsonLogic2.apply(values2[i], data))) {
-              return jsonLogic2.apply(values2[i + 1], data);
-            }
-          }
-          if (values2.length === i + 1) {
-            return jsonLogic2.apply(values2[i], data);
-          }
-          return null;
-        } else if (op === "and") {
-          for (i = 0; i < values2.length; i += 1) {
-            current = jsonLogic2.apply(values2[i], data);
-            if (!jsonLogic2.truthy(current)) {
-              return current;
+       * Generate random string modeled after given tokens.
+       *
+       * @param {Object} token
+       * @param {Array.<String>} groups
+       * @return {String}
+       */
+      _gen(token, groups) {
+        var stack, str, n, i, l;
+        switch (token.type) {
+          case types.ROOT:
+          case types.GROUP:
+            if (token.followedBy || token.notFollowedBy) {
+              return "";
             }
-          }
-          return current;
-        } else if (op === "or") {
-          for (i = 0; i < values2.length; i += 1) {
-            current = jsonLogic2.apply(values2[i], data);
-            if (jsonLogic2.truthy(current)) {
-              return current;
+            if (token.remember && token.groupNumber === void 0) {
+              token.groupNumber = groups.push(null) - 1;
             }
-          }
-          return current;
-        } else if (op === "filter") {
-          scopedData = jsonLogic2.apply(values2[0], data);
-          scopedLogic = values2[1];
-          if (!Array.isArray(scopedData)) {
-            return [];
-          }
-          return scopedData.filter(function(datum) {
-            return jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, datum));
-          });
-        } else if (op === "map") {
-          scopedData = jsonLogic2.apply(values2[0], data);
-          scopedLogic = values2[1];
-          if (!Array.isArray(scopedData)) {
-            return [];
-          }
-          return scopedData.map(function(datum) {
-            return jsonLogic2.apply(scopedLogic, datum);
-          });
-        } else if (op === "reduce") {
-          scopedData = jsonLogic2.apply(values2[0], data);
-          scopedLogic = values2[1];
-          initial = typeof values2[2] !== "undefined" ? values2[2] : null;
-          if (!Array.isArray(scopedData)) {
-            return initial;
-          }
-          return scopedData.reduce(
-            function(accumulator, current2) {
-              return jsonLogic2.apply(
-                scopedLogic,
-                { current: current2, accumulator }
-              );
-            },
-            initial
-          );
-        } else if (op === "all") {
-          scopedData = jsonLogic2.apply(values2[0], data);
-          scopedLogic = values2[1];
-          if (!Array.isArray(scopedData) || !scopedData.length) {
-            return false;
-          }
-          for (i = 0; i < scopedData.length; i += 1) {
-            if (!jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, scopedData[i]))) {
-              return false;
+            stack = token.options ? this._randSelect(token.options) : token.stack;
+            str = "";
+            for (i = 0, l = stack.length; i < l; i++) {
+              str += this._gen(stack[i], groups);
             }
-          }
-          return true;
-        } else if (op === "none") {
-          scopedData = jsonLogic2.apply(values2[0], data);
-          scopedLogic = values2[1];
-          if (!Array.isArray(scopedData) || !scopedData.length) {
-            return true;
-          }
-          for (i = 0; i < scopedData.length; i += 1) {
-            if (jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, scopedData[i]))) {
-              return false;
+            if (token.remember) {
+              groups[token.groupNumber] = str;
             }
-          }
-          return true;
-        } else if (op === "some") {
-          scopedData = jsonLogic2.apply(values2[0], data);
-          scopedLogic = values2[1];
-          if (!Array.isArray(scopedData) || !scopedData.length) {
-            return false;
-          }
-          for (i = 0; i < scopedData.length; i += 1) {
-            if (jsonLogic2.truthy(jsonLogic2.apply(scopedLogic, scopedData[i]))) {
-              return true;
+            return str;
+          case types.POSITION:
+            return "";
+          case types.SET:
+            var expandedSet = this._expand(token);
+            if (!expandedSet.length) {
+              return "";
             }
-          }
-          return false;
-        }
-        values2 = values2.map(function(val) {
-          return jsonLogic2.apply(val, data);
-        });
-        if (operations.hasOwnProperty(op) && typeof operations[op] === "function") {
-          return operations[op].apply(data, values2);
-        } else if (op.indexOf(".") > 0) {
-          var sub_ops = String(op).split(".");
-          var operation = operations;
-          for (i = 0; i < sub_ops.length; i++) {
-            if (!operation.hasOwnProperty(sub_ops[i])) {
-              throw new Error("Unrecognized operation " + op + " (failed at " + sub_ops.slice(0, i + 1).join(".") + ")");
+            return String.fromCharCode(this._randSelect(expandedSet));
+          case types.REPETITION:
+            n = this.randInt(
+              token.min,
+              token.max === Infinity ? token.min + this.max : token.max
+            );
+            str = "";
+            for (i = 0; i < n; i++) {
+              str += this._gen(token.value, groups);
             }
-            operation = operation[sub_ops[i]];
-          }
-          return operation.apply(data, values2);
+            return str;
+          case types.REFERENCE:
+            return groups[token.value - 1] || "";
+          case types.CHAR:
+            var code = this.ignoreCase && this._randBool() ? this._toOtherCase(token.value) : token.value;
+            return String.fromCharCode(code);
         }
-        throw new Error("Unrecognized operation " + op);
-      };
-      jsonLogic2.uses_data = function(logic) {
-        var collection = [];
-        if (jsonLogic2.is_logic(logic)) {
-          var op = jsonLogic2.get_operator(logic);
-          var values2 = logic[op];
-          if (!Array.isArray(values2)) {
-            values2 = [values2];
+      }
+      /**
+       * If code is alphabetic, converts to other case.
+       * If not alphabetic, returns back code.
+       *
+       * @param {Number} code
+       * @return {Number}
+       */
+      _toOtherCase(code) {
+        return code + (97 <= code && code <= 122 ? -32 : 65 <= code && code <= 90 ? 32 : 0);
+      }
+      /**
+       * Randomly returns a true or false value.
+       *
+       * @return {Boolean}
+       */
+      _randBool() {
+        return !this.randInt(0, 1);
+      }
+      /**
+       * Randomly selects and returns a value from the array.
+       *
+       * @param {Array.<Object>} arr
+       * @return {Object}
+       */
+      _randSelect(arr) {
+        if (arr instanceof DRange) {
+          return arr.index(this.randInt(0, arr.length - 1));
+        }
+        return arr[this.randInt(0, arr.length - 1)];
+      }
+      /**
+       * expands a token to a DiscontinuousRange of characters which has a
+       * length and an index function (for random selecting)
+       *
+       * @param {Object} token
+       * @return {DiscontinuousRange}
+       */
+      _expand(token) {
+        if (token.type === ret.types.CHAR) {
+          return new DRange(token.value);
+        } else if (token.type === ret.types.RANGE) {
+          return new DRange(token.from, token.to);
+        } else {
+          let drange = new DRange();
+          for (let i = 0; i < token.set.length; i++) {
+            let subrange = this._expand(token.set[i]);
+            drange.add(subrange);
+            if (this.ignoreCase) {
+              for (let j = 0; j < subrange.length; j++) {
+                let code = subrange.index(j);
+                let otherCaseCode = this._toOtherCase(code);
+                if (code !== otherCaseCode) {
+                  drange.add(otherCaseCode);
+                }
+              }
+            }
           }
-          if (op === "var") {
-            collection.push(values2[0]);
+          if (token.not) {
+            return this.defaultRange.clone().subtract(drange);
           } else {
-            values2.forEach(function(val) {
-              collection.push.apply(collection, jsonLogic2.uses_data(val));
-            });
+            return this.defaultRange.clone().intersect(drange);
           }
         }
-        return arrayUnique(collection);
-      };
-      jsonLogic2.add_operation = function(name, code) {
-        operations[name] = code;
-      };
-      jsonLogic2.rm_operation = function(name) {
-        delete operations[name];
-      };
-      jsonLogic2.rule_like = function(rule, pattern) {
-        if (pattern === rule) {
-          return true;
-        }
-        if (pattern === "@") {
-          return true;
-        }
-        if (pattern === "number") {
-          return typeof rule === "number";
-        }
-        if (pattern === "string") {
-          return typeof rule === "string";
-        }
-        if (pattern === "array") {
-          return Array.isArray(rule) && !jsonLogic2.is_logic(rule);
-        }
-        if (jsonLogic2.is_logic(pattern)) {
-          if (jsonLogic2.is_logic(rule)) {
-            var pattern_op = jsonLogic2.get_operator(pattern);
-            var rule_op = jsonLogic2.get_operator(rule);
-            if (pattern_op === "@" || pattern_op === rule_op) {
-              return jsonLogic2.rule_like(
-                jsonLogic2.get_values(rule, false),
-                jsonLogic2.get_values(pattern, false)
-              );
-            }
-          }
-          return false;
+      }
+      /**
+       * Randomly generates and returns a number between a and b (inclusive).
+       *
+       * @param {Number} a
+       * @param {Number} b
+       * @return {Number}
+       */
+      randInt(a, b) {
+        return a + Math.floor(Math.random() * (1 + b - a));
+      }
+      /**
+       * Default range of characters to generate from.
+       */
+      get defaultRange() {
+        return this._range = this._range || new DRange(32, 126);
+      }
+      set defaultRange(range) {
+        this._range = range;
+      }
+      /**
+       *
+       * Enables use of randexp with a shorter call.
+       *
+       * @param {RegExp|String| regexp}
+       * @param {String} m
+       * @return {String}
+       */
+      static randexp(regexp, m) {
+        var randexp2;
+        if (typeof regexp === "string") {
+          regexp = new RegExp(regexp, m);
         }
-        if (Array.isArray(pattern)) {
-          if (Array.isArray(rule)) {
-            if (pattern.length !== rule.length) {
-              return false;
-            }
-            for (var i = 0; i < pattern.length; i += 1) {
-              if (!jsonLogic2.rule_like(rule[i], pattern[i])) {
-                return false;
-              }
-            }
-            return true;
-          } else {
-            return false;
-          }
+        if (regexp._randexp === void 0) {
+          randexp2 = new RandExp(regexp, m);
+          regexp._randexp = randexp2;
+        } else {
+          randexp2 = regexp._randexp;
+          randexp2._setDefaults(regexp);
         }
-        return false;
-      };
-      return jsonLogic2;
-    });
+        return randexp2.gen();
+      }
+      /**
+       * Enables sugary /regexp/.gen syntax.
+       */
+      static sugar() {
+        RegExp.prototype.gen = function() {
+          return RandExp.randexp(this);
+        };
+      }
+    };
   }
 });
 
@@ -11315,670 +11315,441 @@ inherits(ArraySchema, SchemaType, {
       exclusive: true,
       params: {
         min: _min
-      },
-      test: function test2(value) {
-        return isAbsent_default(value) || value.length >= this.resolve(_min);
-      }
-    });
-  },
-  max: function max4(_max, message) {
-    message = message || array.max;
-    return this.test({
-      message,
-      name: "max",
-      exclusive: true,
-      params: {
-        max: _max
-      },
-      test: function test2(value) {
-        return isAbsent_default(value) || value.length <= this.resolve(_max);
-      }
-    });
-  },
-  ensure: function ensure2() {
-    var _this4 = this;
-    return this.default(function() {
-      return [];
-    }).transform(function(val, original) {
-      if (_this4._typeCheck(val))
-        return val;
-      return original == null ? [] : [].concat(original);
-    });
-  },
-  compact: function compact(rejector) {
-    var reject = !rejector ? function(v) {
-      return !!v;
-    } : function(v, i, a) {
-      return !rejector(v, i, a);
-    };
-    return this.transform(function(values2) {
-      return values2 != null ? values2.filter(reject) : values2;
-    });
-  },
-  describe: function describe3() {
-    var base = SchemaType.prototype.describe.call(this);
-    if (this.innerType)
-      base.innerType = this.innerType.describe();
-    return base;
-  }
-});
-
-// node_modules/yup/es/Lazy.js
-var Lazy = /* @__PURE__ */ function() {
-  function Lazy2(mapFn) {
-    this._resolve = function(value, options) {
-      var schema = mapFn(value, options);
-      if (!isSchema_default(schema))
-        throw new TypeError("lazy() functions must return a valid schema");
-      return schema.resolve(options);
-    };
-  }
-  var _proto = Lazy2.prototype;
-  _proto.resolve = function resolve2(options) {
-    return this._resolve(options.value, options);
-  };
-  _proto.cast = function cast2(value, options) {
-    return this._resolve(value, options).cast(value, options);
-  };
-  _proto.validate = function validate2(value, options, maybeCb) {
-    return this._resolve(value, options).validate(value, options, maybeCb);
-  };
-  _proto.validateSync = function validateSync2(value, options) {
-    return this._resolve(value, options).validateSync(value, options);
-  };
-  _proto.validateAt = function validateAt(path, value, options) {
-    return this._resolve(value, options).validateAt(path, value, options);
-  };
-  _proto.validateSyncAt = function validateSyncAt(path, value, options) {
-    return this._resolve(value, options).validateSyncAt(path, value, options);
-  };
-  return Lazy2;
-}();
-Lazy.prototype.__isYupSchema__ = true;
-var Lazy_default = Lazy;
-
-// node_modules/yup/es/index.js
-var boolean2 = boolean_default;
-var lazy = function lazy2(fn) {
-  return new Lazy_default(fn);
-};
-
-// src/utils.js
-function convertDiskSizeFromTo(from2, to) {
-  const units = ["bytes", "kb", "mb"];
-  return function convert(value) {
-    return value * Math.pow(1024, units.indexOf(from2.toLowerCase())) / Math.pow(1024, units.indexOf(to.toLowerCase()));
-  };
-}
-function containsHTML(str = "") {
-  return /<[a-z][\s\S]*>/i.test(str);
-}
-function wrapWithSpan(html, properties = {}) {
-  const attributes = Object.entries(properties).reduce((acc, [key, value]) => `${acc}${key}="${value}" `, "").trim();
-  return `<span ${attributes}>${html}</span>`;
-}
-function hasProperty(object2, propertyName) {
-  return Object.prototype.hasOwnProperty.call(object2, propertyName);
-}
-
-// src/checkIfConditionMatches.js
-function checkIfConditionMatches(node, formValues, formFields) {
-  return Object.keys(node.if.properties).every((name) => {
-    const currentProperty = node.if.properties[name];
-    const value = formValues[name];
-    const hasEmptyValue = typeof value === "undefined" || // NOTE: This is a "Remote API" dependency, as empty fields are sent as "null".
-    value === null;
-    const hasIfExplicit = node.if.required?.includes(name);
-    if (hasEmptyValue && !hasIfExplicit) {
-      return true;
-    }
-    if (hasProperty(currentProperty, "const")) {
-      return compareFormValueWithSchemaValue(value, currentProperty.const);
-    }
-    if (currentProperty.contains?.pattern) {
-      const formValue = value || [];
-      if (Array.isArray(formValue)) {
-        const pattern = new RegExp(currentProperty.contains.pattern);
-        return (value || []).some((item) => pattern.test(item));
-      }
-    }
-    if (currentProperty.enum) {
-      return currentProperty.enum.includes(value);
-    }
-    if (currentProperty.properties) {
-      return checkIfConditionMatches(
-        { if: currentProperty },
-        formValues[name],
-        getField(name, formFields).fields
-      );
-    }
-    const field = getField(name, formFields);
-    return validateFieldSchema(
-      {
-        options: field.options,
-        // @TODO/CODE SMELL. We are passing the property (raw field), but buildYupSchema() expected the output field.
-        ...currentProperty,
-        inputType: field.inputType,
-        required: true
-      },
-      value
-    );
-  });
-}
-
-// src/internals/helpers.js
-var import_merge = __toESM(require_merge2());
-var import_get2 = __toESM(require_get());
-var import_isEmpty = __toESM(require_isEmpty());
-var import_isFunction3 = __toESM(require_isFunction());
-function pickXKey(node, key) {
-  const deprecatedKeys = ["presentation", "errorMessage"];
-  return (0, import_get2.default)(node, `x-jsf-${key}`, deprecatedKeys.includes(key) ? node?.[key] : void 0);
-}
-function getFieldDescription(node, customProperties = {}) {
-  const nodeDescription = node?.description ? {
-    description: node.description
-  } : {};
-  const customDescription = customProperties?.description ? {
-    description: (0, import_isFunction3.default)(customProperties.description) ? customProperties.description(node?.description, {
-      ...node,
-      ...customProperties
-    }) : customProperties.description
-  } : {};
-  const nodePresentation = pickXKey(node, "presentation");
-  const presentation = !(0, import_isEmpty.default)(nodePresentation) && {
-    presentation: { ...nodePresentation, ...customDescription }
-  };
-  return (0, import_merge.default)(nodeDescription, { ...customDescription, ...presentation });
-}
-
-// src/internals/fields.js
-var jsonTypes = {
-  STRING: "string",
-  NUMBER: "number",
-  INTEGER: "integer",
-  OBJECT: "object",
-  ARRAY: "array",
-  BOOLEAN: "boolean",
-  NULL: "null"
-};
-var supportedTypes = {
-  TEXT: "text",
-  NUMBER: "number",
-  SELECT: "select",
-  FILE: "file",
-  RADIO: "radio",
-  GROUP_ARRAY: "group-array",
-  EMAIL: "email",
-  DATE: "date",
-  CHECKBOX: "checkbox",
-  FIELDSET: "fieldset"
-};
-var jsonTypeToInputType = {
-  [jsonTypes.STRING]: ({ oneOf: oneOf2, format }) => {
-    if (format === "email")
-      return supportedTypes.EMAIL;
-    if (format === "date")
-      return supportedTypes.DATE;
-    if (format === "data-url")
-      return supportedTypes.FILE;
-    if (oneOf2)
-      return supportedTypes.RADIO;
-    return supportedTypes.TEXT;
+      },
+      test: function test2(value) {
+        return isAbsent_default(value) || value.length >= this.resolve(_min);
+      }
+    });
   },
-  [jsonTypes.NUMBER]: () => supportedTypes.NUMBER,
-  [jsonTypes.INTEGER]: () => supportedTypes.NUMBER,
-  [jsonTypes.OBJECT]: () => supportedTypes.FIELDSET,
-  [jsonTypes.ARRAY]: ({ items }) => {
-    if (items.properties)
-      return supportedTypes.GROUP_ARRAY;
-    return supportedTypes.SELECT;
+  max: function max4(_max, message) {
+    message = message || array.max;
+    return this.test({
+      message,
+      name: "max",
+      exclusive: true,
+      params: {
+        max: _max
+      },
+      test: function test2(value) {
+        return isAbsent_default(value) || value.length <= this.resolve(_max);
+      }
+    });
   },
-  [jsonTypes.BOOLEAN]: () => supportedTypes.CHECKBOX
-};
-function getInputType(fieldProperties, strictInputType, name) {
-  const presentation = pickXKey(fieldProperties, "presentation") ?? {};
-  const presentationInputType = presentation?.inputType;
-  if (presentationInputType) {
-    return presentationInputType;
-  }
-  if (strictInputType) {
-    throw Error(`Strict error: Missing inputType to field "${name || fieldProperties.title}".
-You can fix the json schema or skip this error by calling createHeadlessForm(schema, { strictInputType: false })`);
-  }
-  if (!fieldProperties.type) {
-    if (fieldProperties.items?.properties) {
-      return supportedTypes.GROUP_ARRAY;
-    }
-    if (fieldProperties.properties) {
-      return supportedTypes.SELECT;
-    }
-    return jsonTypeToInputType[jsonTypes.STRING](fieldProperties);
+  ensure: function ensure2() {
+    var _this4 = this;
+    return this.default(function() {
+      return [];
+    }).transform(function(val, original) {
+      if (_this4._typeCheck(val))
+        return val;
+      return original == null ? [] : [].concat(original);
+    });
+  },
+  compact: function compact(rejector) {
+    var reject = !rejector ? function(v) {
+      return !!v;
+    } : function(v, i, a) {
+      return !rejector(v, i, a);
+    };
+    return this.transform(function(values2) {
+      return values2 != null ? values2.filter(reject) : values2;
+    });
+  },
+  describe: function describe3() {
+    var base = SchemaType.prototype.describe.call(this);
+    if (this.innerType)
+      base.innerType = this.innerType.describe();
+    return base;
   }
-  return jsonTypeToInputType[fieldProperties.type]?.(fieldProperties);
-}
-function _composeFieldFile({ name, label: label2, description, accept, required: required2 = true, ...attrs }) {
-  return {
-    type: supportedTypes.FILE,
-    name,
-    label: label2,
-    description,
-    required: required2,
-    accept,
-    ...attrs
-  };
-}
-function _composeFieldText({ name, label: label2, description, required: required2 = true, ...attrs }) {
-  return {
-    type: supportedTypes.TEXT,
-    name,
-    label: label2,
-    description,
-    required: required2,
-    ...attrs
-  };
-}
-function _composeFieldEmail({ name, label: label2, required: required2 = true, ...attrs }) {
-  return {
-    type: supportedTypes.EMAIL,
-    name,
-    label: label2,
-    required: required2,
-    ...attrs
-  };
-}
-function _composeFieldNumber({
-  name,
-  label: label2,
-  percentage = false,
-  required: required2 = true,
-  minimum,
-  maximum,
-  ...attrs
-}) {
-  let minValue = minimum;
-  let maxValue = maximum;
-  if (percentage) {
-    minValue = minValue ?? 0;
-    maxValue = maxValue ?? 100;
+});
+
+// node_modules/yup/es/Lazy.js
+var Lazy = /* @__PURE__ */ function() {
+  function Lazy2(mapFn) {
+    this._resolve = function(value, options) {
+      var schema = mapFn(value, options);
+      if (!isSchema_default(schema))
+        throw new TypeError("lazy() functions must return a valid schema");
+      return schema.resolve(options);
+    };
   }
-  return {
-    type: supportedTypes.NUMBER,
-    name,
-    label: label2,
-    percentage,
-    required: required2,
-    minimum: minValue,
-    maximum: maxValue,
-    ...attrs
-  };
-}
-function _composeFieldDate({ name, label: label2, required: required2 = true, ...attrs }) {
-  return {
-    type: supportedTypes.DATE,
-    name,
-    label: label2,
-    required: required2,
-    ...attrs
+  var _proto = Lazy2.prototype;
+  _proto.resolve = function resolve2(options) {
+    return this._resolve(options.value, options);
   };
-}
-function _composeFieldRadio({ name, label: label2, options, required: required2 = true, ...attrs }) {
-  return {
-    type: supportedTypes.RADIO,
-    name,
-    label: label2,
-    options,
-    required: required2,
-    ...attrs
+  _proto.cast = function cast2(value, options) {
+    return this._resolve(value, options).cast(value, options);
   };
-}
-function _composeFieldSelect({ name, label: label2, options, required: required2 = true, ...attrs }) {
-  return {
-    type: supportedTypes.SELECT,
-    name,
-    label: label2,
-    options,
-    required: required2,
-    ...attrs
+  _proto.validate = function validate2(value, options, maybeCb) {
+    return this._resolve(value, options).validate(value, options, maybeCb);
   };
-}
-function _composeNthFieldGroup({ name, label: label2, required: required2, nthFieldGroup, ...attrs }) {
-  return [
-    {
-      ...nthFieldGroup,
-      type: supportedTypes.GROUP_ARRAY,
-      name,
-      label: label2,
-      required: required2,
-      ...attrs
-    }
-  ];
-}
-function _composeFieldCheckbox({
-  required: required2 = true,
-  name,
-  label: label2,
-  description,
-  default: defaultValue,
-  checkboxValue,
-  ...attrs
-}) {
-  return {
-    type: supportedTypes.CHECKBOX,
-    required: required2,
-    name,
-    label: label2,
-    description,
-    checkboxValue,
-    ...defaultValue && { default: defaultValue },
-    ...attrs
+  _proto.validateSync = function validateSync2(value, options) {
+    return this._resolve(value, options).validateSync(value, options);
   };
-}
-function _composeFieldset({ name, label: label2, fields, variant, ...attrs }) {
-  return {
-    type: supportedTypes.FIELDSET,
-    name,
-    label: label2,
-    fields,
-    variant,
-    ...attrs
+  _proto.validateAt = function validateAt(path, value, options) {
+    return this._resolve(value, options).validateAt(path, value, options);
   };
-}
-var _composeFieldArbitraryClosure = (inputType) => (attrs) => ({
-  type: inputType,
-  ...attrs
-});
-var inputTypeMap = {
-  text: _composeFieldText,
-  select: _composeFieldSelect,
-  radio: _composeFieldRadio,
-  date: _composeFieldDate,
-  number: _composeFieldNumber,
-  "group-array": _composeNthFieldGroup,
-  fieldset: _composeFieldset,
-  file: _composeFieldFile,
-  email: _composeFieldEmail,
-  checkbox: _composeFieldCheckbox
-};
-function _composeFieldCustomClosure(defaultComposeFn) {
-  return ({ fieldCustomization, ...attrs }) => {
-    const { description, ...restFieldCustomization } = fieldCustomization;
-    const fieldDescription = getFieldDescription(attrs, fieldCustomization);
-    const { nthFieldGroup, ...restAttrs } = attrs;
-    const commonAttrs = {
-      ...restAttrs,
-      ...restFieldCustomization,
-      ...fieldDescription
-    };
-    if (attrs.inputType === supportedTypes.GROUP_ARRAY) {
-      return [
-        {
-          ...nthFieldGroup,
-          ...commonAttrs
-        }
-      ];
-    }
-    return {
-      ...defaultComposeFn(attrs),
-      ...commonAttrs
-    };
+  _proto.validateSyncAt = function validateSyncAt(path, value, options) {
+    return this._resolve(value, options).validateSyncAt(path, value, options);
   };
-}
+  return Lazy2;
+}();
+Lazy.prototype.__isYupSchema__ = true;
+var Lazy_default = Lazy;
 
-// src/yupSchema.js
-var import_flow = __toESM(require_flow());
-var import_noop = __toESM(require_noop());
-var import_randexp = __toESM(require_randexp());
+// node_modules/yup/es/index.js
+var boolean2 = boolean_default;
+var lazy = function lazy2(fn) {
+  return new Lazy_default(fn);
+};
 
-// src/jsonLogic.js
-var import_json_logic_js = __toESM(require_logic());
-function createValidationChecker(schema) {
-  const scopes = /* @__PURE__ */ new Map();
-  function createScopes(jsonSchema, key = "root") {
-    const sampleEmptyObject = buildSampleEmptyObject(schema);
-    scopes.set(key, createValidationsScope(jsonSchema));
-    Object.entries(jsonSchema?.properties ?? {}).filter(([, property2]) => property2.type === "object" || property2.type === "array").forEach(([key2, property2]) => {
-      if (property2.type === "array") {
-        createScopes(property2.items, `${key2}[]`);
-      } else {
-        createScopes(property2, key2);
-      }
-    });
-    validateInlineRules(jsonSchema, sampleEmptyObject);
-  }
-  createScopes(schema);
-  return {
-    scopes,
-    getScope(name = "root") {
-      return scopes.get(name);
-    }
+// src/utils.js
+function convertDiskSizeFromTo(from2, to) {
+  const units = ["bytes", "kb", "mb"];
+  return function convert(value) {
+    return value * Math.pow(1024, units.indexOf(from2.toLowerCase())) / Math.pow(1024, units.indexOf(to.toLowerCase()));
   };
 }
-function createValidationsScope(schema) {
-  const validationMap = /* @__PURE__ */ new Map();
-  const computedValuesMap = /* @__PURE__ */ new Map();
-  const logic = schema?.["x-jsf-logic"] ?? {
-    validations: {},
-    computedValues: {}
-  };
-  const validations = Object.entries(logic.validations ?? {});
-  const computedValues = Object.entries(logic.computedValues ?? {});
-  const sampleEmptyObject = buildSampleEmptyObject(schema);
-  validations.forEach(([id, validation]) => {
-    if (!validation.rule) {
-      throw Error(`[json-schema-form] json-logic error: Validation "${id}" has missing rule.`);
+function containsHTML(str = "") {
+  return /<[a-z][\s\S]*>/i.test(str);
+}
+function wrapWithSpan(html, properties = {}) {
+  const attributes = Object.entries(properties).reduce((acc, [key, value]) => `${acc}${key}="${value}" `, "").trim();
+  return `<span ${attributes}>${html}</span>`;
+}
+function hasProperty(object2, propertyName) {
+  return Object.prototype.hasOwnProperty.call(object2, propertyName);
+}
+
+// src/checkIfConditionMatches.js
+function checkIfConditionMatchesProperties(node, formValues, formFields, logic) {
+  return Object.keys(node.if.properties ?? {}).every((name) => {
+    const currentProperty = node.if.properties[name];
+    const value = formValues[name];
+    const hasEmptyValue = typeof value === "undefined" || // NOTE: This is a "Remote API" dependency, as empty fields are sent as "null".
+    value === null;
+    const hasIfExplicit = node.if.required?.includes(name);
+    if (hasEmptyValue && !hasIfExplicit) {
+      return true;
     }
-    checkRuleIntegrity(validation.rule, id, sampleEmptyObject);
-    validationMap.set(id, validation);
-  });
-  computedValues.forEach(([id, computedValue]) => {
-    if (!computedValue.rule) {
-      throw Error(`[json-schema-form] json-logic error: Computed value "${id}" has missing rule.`);
+    if (hasProperty(currentProperty, "const")) {
+      return compareFormValueWithSchemaValue(value, currentProperty.const);
     }
-    checkRuleIntegrity(computedValue.rule, id, sampleEmptyObject);
-    computedValuesMap.set(id, computedValue);
-  });
-  function validate2(rule, values2) {
-    return import_json_logic_js.default.apply(rule, replaceUndefinedValuesWithNulls(values2));
-  }
-  return {
-    validationMap,
-    computedValuesMap,
-    validate: validate2,
-    applyValidationRuleInCondition(id, values2) {
-      const validation = validationMap.get(id);
-      return validate2(validation.rule, values2);
-    },
-    applyComputedValueInField(id, values2, fieldName) {
-      const validation = computedValuesMap.get(id);
-      if (validation === void 0) {
-        throw Error(
-          `[json-schema-form] json-logic error: Computed value "${id}" doesn't exist in field "${fieldName}".`
-        );
+    if (currentProperty.contains?.pattern) {
+      const formValue = value || [];
+      if (Array.isArray(formValue)) {
+        const pattern = new RegExp(currentProperty.contains.pattern);
+        return (value || []).some((item) => pattern.test(item));
       }
-      return validate2(validation.rule, values2);
-    },
-    applyComputedValueRuleInCondition(id, values2) {
-      const validation = computedValuesMap.get(id);
-      return validate2(validation.rule, values2);
     }
-  };
-}
-function replaceUndefinedValuesWithNulls(values2 = {}) {
-  return Object.entries(values2).reduce((prev, [key, value]) => {
-    return { ...prev, [key]: value === void 0 ? null : value };
-  }, {});
-}
-function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
-  const { parentID = "root" } = config;
-  const validation = logic.getScope(parentID).validationMap.get(id);
-  if (validation === void 0) {
-    throw Error(
-      `[json-schema-form] json-logic error: "${field.name}" required validation "${id}" doesn't exist.`
+    if (currentProperty.enum) {
+      return currentProperty.enum.includes(value);
+    }
+    if (currentProperty.properties) {
+      return checkIfConditionMatchesProperties(
+        { if: currentProperty },
+        formValues[name],
+        getField(name, formFields).fields,
+        logic
+      );
+    }
+    const field = getField(name, formFields);
+    return validateFieldSchema(
+      {
+        options: field.options,
+        // @TODO/CODE SMELL. We are passing the property (raw field), but buildYupSchema() expected the output field.
+        ...currentProperty,
+        inputType: field.inputType,
+        required: true
+      },
+      value
     );
-  }
-  return (yupSchema) => yupSchema.test(
-    `${field.name}-validation-${id}`,
-    validation?.errorMessage ?? "This field is invalid.",
-    (value, { parent }) => {
-      if (value === void 0 && !field.required)
+  });
+}
+function checkIfMatchesValidationsAndComputedValues(node, formValues, logic, parentID) {
+  const validationsMatch = Object.entries(node.if.validations ?? {}).every(([name, property2]) => {
+    const currentValue = logic.getScope(parentID).applyValidationRuleInCondition(name, formValues);
+    if (Object.hasOwn(property2, "const") && currentValue === property2.const)
+      return true;
+    return false;
+  });
+  const computedValuesMatch = Object.entries(node.if.computedValues ?? {}).every(
+    ([name, property2]) => {
+      const currentValue = logic.getScope(parentID).applyComputedValueRuleInCondition(name, formValues);
+      if (Object.hasOwn(property2, "const") && currentValue === property2.const)
         return true;
-      return import_json_logic_js.default.apply(validation.rule, parent);
+      return false;
     }
   );
+  return computedValuesMatch && validationsMatch;
 }
-var HANDLEBARS_REGEX = /\{\{([^{}]+)\}\}/g;
-function replaceHandlebarsTemplates({
-  value: toReplace,
-  logic,
-  formValues,
-  parentID,
-  name: fieldName
-}) {
-  if (typeof toReplace === "string") {
-    return toReplace.replace(HANDLEBARS_REGEX, (match, key) => {
-      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
-    });
-  } else if (typeof toReplace === "object") {
-    const { value, ...rules } = toReplace;
-    if (Object.keys(rules).length > 1 && !value) {
-      throw Error("Cannot define multiple rules without a template string with key `value`.");
+
+// src/internals/helpers.js
+var import_merge = __toESM(require_merge2());
+var import_get2 = __toESM(require_get());
+var import_isEmpty = __toESM(require_isEmpty());
+var import_isFunction3 = __toESM(require_isFunction());
+function pickXKey(node, key) {
+  const deprecatedKeys = ["presentation", "errorMessage"];
+  return (0, import_get2.default)(node, `x-jsf-${key}`, deprecatedKeys.includes(key) ? node?.[key] : void 0);
+}
+function getFieldDescription(node, customProperties = {}) {
+  const nodeDescription = node?.description ? {
+    description: node.description
+  } : {};
+  const customDescription = customProperties?.description ? {
+    description: (0, import_isFunction3.default)(customProperties.description) ? customProperties.description(node?.description, {
+      ...node,
+      ...customProperties
+    }) : customProperties.description
+  } : {};
+  const nodePresentation = pickXKey(node, "presentation");
+  const presentation = !(0, import_isEmpty.default)(nodePresentation) && {
+    presentation: { ...nodePresentation, ...customDescription }
+  };
+  return (0, import_merge.default)(nodeDescription, { ...customDescription, ...presentation });
+}
+
+// src/internals/fields.js
+var jsonTypes = {
+  STRING: "string",
+  NUMBER: "number",
+  INTEGER: "integer",
+  OBJECT: "object",
+  ARRAY: "array",
+  BOOLEAN: "boolean",
+  NULL: "null"
+};
+var supportedTypes = {
+  TEXT: "text",
+  NUMBER: "number",
+  SELECT: "select",
+  FILE: "file",
+  RADIO: "radio",
+  GROUP_ARRAY: "group-array",
+  EMAIL: "email",
+  DATE: "date",
+  CHECKBOX: "checkbox",
+  FIELDSET: "fieldset"
+};
+var jsonTypeToInputType = {
+  [jsonTypes.STRING]: ({ oneOf: oneOf2, format }) => {
+    if (format === "email")
+      return supportedTypes.EMAIL;
+    if (format === "date")
+      return supportedTypes.DATE;
+    if (format === "data-url")
+      return supportedTypes.FILE;
+    if (oneOf2)
+      return supportedTypes.RADIO;
+    return supportedTypes.TEXT;
+  },
+  [jsonTypes.NUMBER]: () => supportedTypes.NUMBER,
+  [jsonTypes.INTEGER]: () => supportedTypes.NUMBER,
+  [jsonTypes.OBJECT]: () => supportedTypes.FIELDSET,
+  [jsonTypes.ARRAY]: ({ items }) => {
+    if (items.properties)
+      return supportedTypes.GROUP_ARRAY;
+    return supportedTypes.SELECT;
+  },
+  [jsonTypes.BOOLEAN]: () => supportedTypes.CHECKBOX
+};
+function getInputType(fieldProperties, strictInputType, name) {
+  const presentation = pickXKey(fieldProperties, "presentation") ?? {};
+  const presentationInputType = presentation?.inputType;
+  if (presentationInputType) {
+    return presentationInputType;
+  }
+  if (strictInputType) {
+    throw Error(`Strict error: Missing inputType to field "${name || fieldProperties.title}".
+You can fix the json schema or skip this error by calling createHeadlessForm(schema, { strictInputType: false })`);
+  }
+  if (!fieldProperties.type) {
+    if (fieldProperties.items?.properties) {
+      return supportedTypes.GROUP_ARRAY;
+    }
+    if (fieldProperties.properties) {
+      return supportedTypes.SELECT;
     }
-    const computedTemplateValue = Object.entries(rules).reduce((prev, [key, rule]) => {
-      const computedValue = logic.getScope(parentID).validate(rule, formValues);
-      return prev.replaceAll(`{{${key}}}`, computedValue);
-    }, value);
-    return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
-      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
-    });
+    return jsonTypeToInputType[jsonTypes.STRING](fieldProperties);
   }
-  return toReplace;
+  return jsonTypeToInputType[fieldProperties.type]?.(fieldProperties);
 }
-function calculateComputedAttributes(fieldParams, { parentID = "root" } = {}) {
-  return ({ logic, isRequired, config, formValues }) => {
-    const { name, computedAttributes } = fieldParams;
-    const attributes = Object.fromEntries(
-      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID, name)).filter(([, value]) => value !== null)
-    );
-    return {
-      ...attributes,
-      schema: buildYupSchema(
-        { ...fieldParams, ...attributes, required: isRequired },
-        config,
-        logic
-      )
-    };
+function _composeFieldFile({ name, label: label2, description, accept, required: required2 = true, ...attrs }) {
+  return {
+    type: supportedTypes.FILE,
+    name,
+    label: label2,
+    description,
+    required: required2,
+    accept,
+    ...attrs
   };
 }
-function handleComputedAttribute(logic, formValues, parentID, name) {
-  return ([key, value]) => {
-    switch (key) {
-      case "description":
-        return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
-      case "title":
-        return ["label", replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
-      case "x-jsf-errorMessage":
-        return [
-          "errorMessage",
-          handleNestedObjectForComputedValues(value, formValues, parentID, logic, name)
-        ];
-      case "x-jsf-presentation": {
-        if (value.statement) {
-          return [
-            "statement",
-            handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
-          ];
-        }
-        return [
-          key,
-          handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
-        ];
-      }
-      case "const":
-      default: {
-        if (typeof value === "object" && value.rule) {
-          return [key, logic.getScope(parentID).validate(value.rule, formValues)];
-        }
-        return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
-      }
-    }
+function _composeFieldText({ name, label: label2, description, required: required2 = true, ...attrs }) {
+  return {
+    type: supportedTypes.TEXT,
+    name,
+    label: label2,
+    description,
+    required: required2,
+    ...attrs
   };
 }
-function handleNestedObjectForComputedValues(values2, formValues, parentID, logic, name) {
-  return Object.fromEntries(
-    Object.entries(values2).map(([key, value]) => {
-      return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
-    })
-  );
+function _composeFieldEmail({ name, label: label2, required: required2 = true, ...attrs }) {
+  return {
+    type: supportedTypes.EMAIL,
+    name,
+    label: label2,
+    required: required2,
+    ...attrs
+  };
 }
-function buildSampleEmptyObject(schema = {}) {
-  const sample = {};
-  if (typeof schema !== "object" || !schema.properties) {
-    return schema;
+function _composeFieldNumber({
+  name,
+  label: label2,
+  percentage = false,
+  required: required2 = true,
+  minimum,
+  maximum,
+  ...attrs
+}) {
+  let minValue = minimum;
+  let maxValue = maximum;
+  if (percentage) {
+    minValue = minValue ?? 0;
+    maxValue = maxValue ?? 100;
   }
-  for (const key in schema.properties) {
-    if (schema.properties[key].type === "object") {
-      sample[key] = buildSampleEmptyObject(schema.properties[key]);
-    } else if (schema.properties[key].type === "array") {
-      const itemSchema = schema.properties[key].items;
-      sample[key] = buildSampleEmptyObject(itemSchema);
-    } else {
-      sample[key] = true;
+  return {
+    type: supportedTypes.NUMBER,
+    name,
+    label: label2,
+    percentage,
+    required: required2,
+    minimum: minValue,
+    maximum: maxValue,
+    ...attrs
+  };
+}
+function _composeFieldDate({ name, label: label2, required: required2 = true, ...attrs }) {
+  return {
+    type: supportedTypes.DATE,
+    name,
+    label: label2,
+    required: required2,
+    ...attrs
+  };
+}
+function _composeFieldRadio({ name, label: label2, options, required: required2 = true, ...attrs }) {
+  return {
+    type: supportedTypes.RADIO,
+    name,
+    label: label2,
+    options,
+    required: required2,
+    ...attrs
+  };
+}
+function _composeFieldSelect({ name, label: label2, options, required: required2 = true, ...attrs }) {
+  return {
+    type: supportedTypes.SELECT,
+    name,
+    label: label2,
+    options,
+    required: required2,
+    ...attrs
+  };
+}
+function _composeNthFieldGroup({ name, label: label2, required: required2, nthFieldGroup, ...attrs }) {
+  return [
+    {
+      ...nthFieldGroup,
+      type: supportedTypes.GROUP_ARRAY,
+      name,
+      label: label2,
+      required: required2,
+      ...attrs
     }
-  }
-  return sample;
+  ];
 }
-function validateInlineRules(jsonSchema, sampleEmptyObject) {
-  const properties = (jsonSchema?.properties || jsonSchema?.items?.properties) ?? {};
-  Object.entries(properties).filter(([, property2]) => property2["x-jsf-logic-computedAttrs"] !== void 0).forEach(([fieldName, property2]) => {
-    Object.entries(property2["x-jsf-logic-computedAttrs"]).filter(([, value]) => typeof value === "object").forEach(([key, item]) => {
-      Object.values(item).forEach((rule) => {
-        checkRuleIntegrity(
-          rule,
-          fieldName,
-          sampleEmptyObject,
-          (item2) => `[json-schema-form] json-logic error: fieldName "${item2.var}" doesn't exist in field "${fieldName}.x-jsf-logic-computedAttrs.${key}".`
-        );
-      });
-    });
-  });
+function _composeFieldCheckbox({
+  required: required2 = true,
+  name,
+  label: label2,
+  description,
+  default: defaultValue,
+  checkboxValue,
+  ...attrs
+}) {
+  return {
+    type: supportedTypes.CHECKBOX,
+    required: required2,
+    name,
+    label: label2,
+    description,
+    checkboxValue,
+    ...defaultValue && { default: defaultValue },
+    ...attrs
+  };
 }
-function checkRuleIntegrity(rule, id, data, errorMessage = (item) => `[json-schema-form] json-logic error: rule "${id}" has no variable "${item.var}".`) {
-  Object.entries(rule ?? {}).map(([operator, subRule]) => {
-    if (!Array.isArray(subRule) && subRule !== null && subRule !== void 0)
-      return;
-    throwIfUnknownOperator(operator, subRule, id);
-    subRule.map((item) => {
-      const isVar = item !== null && typeof item === "object" && Object.hasOwn(item, "var");
-      if (isVar) {
-        const exists = import_json_logic_js.default.apply({ var: removeIndicesFromPath(item.var) }, data);
-        if (exists === null) {
-          throw Error(errorMessage(item));
-        }
-      } else {
-        checkRuleIntegrity(item, id, data);
-      }
-    });
-  });
+function _composeFieldset({ name, label: label2, fields, variant, ...attrs }) {
+  return {
+    type: supportedTypes.FIELDSET,
+    name,
+    label: label2,
+    fields,
+    variant,
+    ...attrs
+  };
 }
-function throwIfUnknownOperator(operator, subRule, id) {
-  try {
-    import_json_logic_js.default.apply({ [operator]: subRule });
-  } catch (e) {
-    if (e.message === `Unrecognized operation ${operator}`) {
-      throw Error(
-        `[json-schema-form] json-logic error: in "${id}" rule there is an unknown operator "${operator}".`
-      );
+var _composeFieldArbitraryClosure = (inputType) => (attrs) => ({
+  type: inputType,
+  ...attrs
+});
+var inputTypeMap = {
+  text: _composeFieldText,
+  select: _composeFieldSelect,
+  radio: _composeFieldRadio,
+  date: _composeFieldDate,
+  number: _composeFieldNumber,
+  "group-array": _composeNthFieldGroup,
+  fieldset: _composeFieldset,
+  file: _composeFieldFile,
+  email: _composeFieldEmail,
+  checkbox: _composeFieldCheckbox
+};
+function _composeFieldCustomClosure(defaultComposeFn) {
+  return ({ fieldCustomization, ...attrs }) => {
+    const { description, ...restFieldCustomization } = fieldCustomization;
+    const fieldDescription = getFieldDescription(attrs, fieldCustomization);
+    const { nthFieldGroup, ...restAttrs } = attrs;
+    const commonAttrs = {
+      ...restAttrs,
+      ...restFieldCustomization,
+      ...fieldDescription
+    };
+    if (attrs.inputType === supportedTypes.GROUP_ARRAY) {
+      return [
+        {
+          ...nthFieldGroup,
+          ...commonAttrs
+        }
+      ];
     }
-  }
-}
-var regexToGetIndices = /\.\d+\./g;
-function removeIndicesFromPath(path) {
-  const intermediatePath = path.replace(regexToGetIndices, ".");
-  return intermediatePath.replace(/\.\d+$/, "");
+    return {
+      ...defaultComposeFn(attrs),
+      ...commonAttrs
+    };
+  };
 }
 
+// src/jsonLogic.js
+var import_json_logic_js = __toESM(require_logic());
+
 // src/yupSchema.js
+var import_flow = __toESM(require_flow());
+var import_noop = __toESM(require_noop());
+var import_randexp = __toESM(require_randexp());
 var DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
 var baseString = StringSchema().trim();
 var todayDateHint = (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
@@ -12174,118 +11945,414 @@ function buildYupSchema(field, config, logic) {
       }) : true
     );
   }
-  function withConst(yupSchema) {
-    return yupSchema.test(
-      "isConst",
-      errorMessage.const ?? errorMessageFromConfig.const ?? `The only accepted value is ${propertyFields.const}.`,
-      (value) => propertyFields.required === false && value === void 0 || value === null || value === propertyFields.const
+  function withConst(yupSchema) {
+    return yupSchema.test(
+      "isConst",
+      errorMessage.const ?? errorMessageFromConfig.const ?? `The only accepted value is ${propertyFields.const}.`,
+      (value) => propertyFields.required === false && value === void 0 || value === null || value === propertyFields.const
+    );
+  }
+  function withBaseSchema() {
+    const customErrorMsg = errorMessage.type || errorMessageFromConfig.type;
+    if (customErrorMsg) {
+      return baseSchema.typeError(customErrorMsg);
+    }
+    return baseSchema;
+  }
+  function buildFieldSetSchema(innerFields) {
+    const fieldSetShape = {};
+    innerFields.forEach((fieldSetfield) => {
+      if (fieldSetfield.fields) {
+        fieldSetShape[fieldSetfield.name] = ObjectSchema().shape(
+          buildFieldSetSchema(fieldSetfield.fields)
+        );
+      } else {
+        fieldSetShape[fieldSetfield.name] = buildYupSchema(
+          {
+            ...fieldSetfield,
+            inputType: fieldSetfield.type
+          },
+          config
+        )();
+      }
+    });
+    return fieldSetShape;
+  }
+  function buildGroupArraySchema() {
+    return ObjectSchema().shape(
+      propertyFields.nthFieldGroup.fields().reduce(
+        (schema, groupArrayField) => ({
+          ...schema,
+          [groupArrayField.name]: buildYupSchema(groupArrayField, config)()
+        }),
+        {}
+      )
+    );
+  }
+  const validators = [withBaseSchema];
+  if (inputType === supportedTypes.GROUP_ARRAY) {
+    validators[0] = () => withBaseSchema().of(buildGroupArraySchema());
+  } else if (inputType === supportedTypes.FIELDSET) {
+    validators[0] = () => withBaseSchema().shape(buildFieldSetSchema(propertyFields.fields));
+  }
+  if (propertyFields.required) {
+    validators.push(withRequired);
+  }
+  if (typeof propertyFields.minimum !== "undefined") {
+    validators.push(withMin);
+  }
+  if (typeof propertyFields.minLength !== "undefined") {
+    validators.push(withMinLength);
+  }
+  if (propertyFields.maximum !== void 0) {
+    validators.push(withMax);
+  }
+  if (propertyFields.maxLength) {
+    validators.push(withMaxLength);
+  }
+  if (propertyFields.pattern) {
+    validators.push(withMatches);
+  }
+  if (propertyFields.maxFileSize) {
+    validators.push(withMaxFileSize);
+  }
+  if (propertyFields.accept) {
+    validators.push(withFileFormat);
+  }
+  if (propertyFields.const) {
+    validators.push(withConst);
+  }
+  if (propertyFields.jsonLogicValidations) {
+    propertyFields.jsonLogicValidations.forEach(
+      (id) => validators.push(yupSchemaWithCustomJSONLogic({ field, id, logic, config }))
+    );
+  }
+  return (0, import_flow.default)(validators);
+}
+function getNoSortEdges(fields = []) {
+  return fields.reduce((list, field) => {
+    if (field.noSortEdges) {
+      list.push(field.name);
+    }
+    return list;
+  }, []);
+}
+function getSchema(fields = [], config) {
+  const newSchema = {};
+  fields.forEach((field) => {
+    if (field.schema) {
+      if (field.name) {
+        if (field.inputType === supportedTypes.FIELDSET) {
+          const fieldsetSchema = buildYupSchema(field, config)();
+          newSchema[field.name] = fieldsetSchema;
+        } else {
+          newSchema[field.name] = field.schema;
+        }
+      } else {
+        Object.assign(newSchema, getSchema(field.fields, config));
+      }
+    }
+  });
+  return newSchema;
+}
+function buildCompleteYupSchema(fields, config) {
+  return ObjectSchema().shape(getSchema(fields, config), getNoSortEdges(fields));
+}
+
+// src/jsonLogic.js
+function createValidationChecker(schema) {
+  const scopes = /* @__PURE__ */ new Map();
+  function createScopes(jsonSchema, key = "root") {
+    const sampleEmptyObject = buildSampleEmptyObject(schema);
+    scopes.set(key, createValidationsScope(jsonSchema));
+    Object.entries(jsonSchema?.properties ?? {}).filter(([, property2]) => property2.type === "object" || property2.type === "array").forEach(([key2, property2]) => {
+      if (property2.type === "array") {
+        createScopes(property2.items, `${key2}[]`);
+      } else {
+        createScopes(property2, key2);
+      }
+    });
+    validateInlineRules(jsonSchema, sampleEmptyObject);
+  }
+  createScopes(schema);
+  return {
+    scopes,
+    getScope(name = "root") {
+      return scopes.get(name);
+    }
+  };
+}
+function createValidationsScope(schema) {
+  const validationMap = /* @__PURE__ */ new Map();
+  const computedValuesMap = /* @__PURE__ */ new Map();
+  const logic = schema?.["x-jsf-logic"] ?? {
+    validations: {},
+    computedValues: {}
+  };
+  const validations = Object.entries(logic.validations ?? {});
+  const computedValues = Object.entries(logic.computedValues ?? {});
+  const sampleEmptyObject = buildSampleEmptyObject(schema);
+  validations.forEach(([id, validation]) => {
+    if (!validation.rule) {
+      throw Error(`[json-schema-form] json-logic error: Validation "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(validation.rule, id, sampleEmptyObject);
+    validationMap.set(id, validation);
+  });
+  computedValues.forEach(([id, computedValue]) => {
+    if (!computedValue.rule) {
+      throw Error(`[json-schema-form] json-logic error: Computed value "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(computedValue.rule, id, sampleEmptyObject);
+    computedValuesMap.set(id, computedValue);
+  });
+  function validate2(rule, values2) {
+    return import_json_logic_js.default.apply(
+      rule,
+      replaceUndefinedValuesWithNulls({ ...sampleEmptyObject, ...values2 })
+    );
+  }
+  return {
+    validationMap,
+    computedValuesMap,
+    validate: validate2,
+    applyValidationRuleInCondition(id, values2) {
+      const validation = validationMap.get(id);
+      return validate2(validation.rule, values2);
+    },
+    applyComputedValueInField(id, values2, fieldName) {
+      const validation = computedValuesMap.get(id);
+      if (validation === void 0) {
+        throw Error(
+          `[json-schema-form] json-logic error: Computed value "${id}" doesn't exist in field "${fieldName}".`
+        );
+      }
+      return validate2(validation.rule, values2);
+    },
+    applyComputedValueRuleInCondition(id, values2) {
+      const validation = computedValuesMap.get(id);
+      return validate2(validation.rule, values2);
+    }
+  };
+}
+function replaceUndefinedValuesWithNulls(values2 = {}) {
+  return Object.entries(values2).reduce((prev, [key, value]) => {
+    return { ...prev, [key]: value === void 0 || value === null ? NaN : value };
+  }, {});
+}
+function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
+  const { parentID = "root" } = config;
+  const validation = logic.getScope(parentID).validationMap.get(id);
+  if (validation === void 0) {
+    throw Error(
+      `[json-schema-form] json-logic error: "${field.name}" required validation "${id}" doesn't exist.`
+    );
+  }
+  return (yupSchema) => yupSchema.test(
+    `${field.name}-validation-${id}`,
+    validation?.errorMessage ?? "This field is invalid.",
+    (value, { parent }) => {
+      if (value === void 0 && !field.required)
+        return true;
+      return import_json_logic_js.default.apply(validation.rule, parent);
+    }
+  );
+}
+var HANDLEBARS_REGEX = /\{\{([^{}]+)\}\}/g;
+function replaceHandlebarsTemplates({
+  value: toReplace,
+  logic,
+  formValues,
+  parentID,
+  name: fieldName
+}) {
+  if (typeof toReplace === "string") {
+    return toReplace.replace(HANDLEBARS_REGEX, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
+    });
+  } else if (typeof toReplace === "object") {
+    const { value, ...rules } = toReplace;
+    if (Object.keys(rules).length > 1 && !value) {
+      throw Error("Cannot define multiple rules without a template string with key `value`.");
+    }
+    const computedTemplateValue = Object.entries(rules).reduce((prev, [key, rule]) => {
+      const computedValue = logic.getScope(parentID).validate(rule, formValues);
+      return prev.replaceAll(`{{${key}}}`, computedValue);
+    }, value);
+    return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
+    });
+  }
+  return toReplace;
+}
+function calculateComputedAttributes(fieldParams, { parentID = "root" } = {}) {
+  return ({ logic, isRequired, config, formValues }) => {
+    const { name, computedAttributes } = fieldParams;
+    const attributes = Object.fromEntries(
+      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID, name)).filter(([, value]) => value !== null)
     );
+    return {
+      ...attributes,
+      schema: buildYupSchema(
+        { ...fieldParams, ...attributes, required: isRequired },
+        config,
+        logic
+      )
+    };
+  };
+}
+function handleComputedAttribute(logic, formValues, parentID, name) {
+  return ([key, value]) => {
+    switch (key) {
+      case "description":
+        return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "title":
+        return ["label", replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "x-jsf-errorMessage":
+        return [
+          "errorMessage",
+          handleNestedObjectForComputedValues(value, formValues, parentID, logic, name)
+        ];
+      case "x-jsf-presentation": {
+        if (value.statement) {
+          return [
+            "statement",
+            handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+          ];
+        }
+        return [
+          key,
+          handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+        ];
+      }
+      case "const":
+      default: {
+        if (typeof value === "object" && value.rule) {
+          return [key, logic.getScope(parentID).validate(value.rule, formValues)];
+        }
+        return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
+      }
+    }
+  };
+}
+function handleNestedObjectForComputedValues(values2, formValues, parentID, logic, name) {
+  return Object.fromEntries(
+    Object.entries(values2).map(([key, value]) => {
+      return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+    })
+  );
+}
+function buildSampleEmptyObject(schema = {}) {
+  const sample = {};
+  if (typeof schema !== "object" || !schema.properties) {
+    return schema;
   }
-  function withBaseSchema() {
-    const customErrorMsg = errorMessage.type || errorMessageFromConfig.type;
-    if (customErrorMsg) {
-      return baseSchema.typeError(customErrorMsg);
+  for (const key in schema.properties) {
+    if (schema.properties[key].type === "object") {
+      sample[key] = buildSampleEmptyObject(schema.properties[key]);
+    } else if (schema.properties[key].type === "array") {
+      const itemSchema = schema.properties[key].items;
+      sample[key] = buildSampleEmptyObject(itemSchema);
+    } else {
+      sample[key] = true;
     }
-    return baseSchema;
   }
-  function buildFieldSetSchema(innerFields) {
-    const fieldSetShape = {};
-    innerFields.forEach((fieldSetfield) => {
-      if (fieldSetfield.fields) {
-        fieldSetShape[fieldSetfield.name] = ObjectSchema().shape(
-          buildFieldSetSchema(fieldSetfield.fields)
+  return sample;
+}
+function validateInlineRules(jsonSchema, sampleEmptyObject) {
+  const properties = (jsonSchema?.properties || jsonSchema?.items?.properties) ?? {};
+  Object.entries(properties).filter(([, property2]) => property2["x-jsf-logic-computedAttrs"] !== void 0).forEach(([fieldName, property2]) => {
+    Object.entries(property2["x-jsf-logic-computedAttrs"]).filter(([, value]) => typeof value === "object").forEach(([key, item]) => {
+      Object.values(item).forEach((rule) => {
+        checkRuleIntegrity(
+          rule,
+          fieldName,
+          sampleEmptyObject,
+          (item2) => `[json-schema-form] json-logic error: fieldName "${item2.var}" doesn't exist in field "${fieldName}.x-jsf-logic-computedAttrs.${key}".`
         );
+      });
+    });
+  });
+}
+function checkRuleIntegrity(rule, id, data, errorMessage = (item) => `[json-schema-form] json-logic error: rule "${id}" has no variable "${item.var}".`) {
+  Object.entries(rule ?? {}).map(([operator, subRule]) => {
+    if (!Array.isArray(subRule) && subRule !== null && subRule !== void 0)
+      return;
+    throwIfUnknownOperator(operator, subRule, id);
+    subRule.map((item) => {
+      const isVar = item !== null && typeof item === "object" && Object.hasOwn(item, "var");
+      if (isVar) {
+        const exists = import_json_logic_js.default.apply({ var: removeIndicesFromPath(item.var) }, data);
+        if (exists === null) {
+          throw Error(errorMessage(item));
+        }
       } else {
-        fieldSetShape[fieldSetfield.name] = buildYupSchema(
-          {
-            ...fieldSetfield,
-            inputType: fieldSetfield.type
-          },
-          config
-        )();
+        checkRuleIntegrity(item, id, data);
       }
     });
-    return fieldSetShape;
-  }
-  function buildGroupArraySchema() {
-    return ObjectSchema().shape(
-      propertyFields.nthFieldGroup.fields().reduce(
-        (schema, groupArrayField) => ({
-          ...schema,
-          [groupArrayField.name]: buildYupSchema(groupArrayField, config)()
-        }),
-        {}
-      )
-    );
-  }
-  const validators = [withBaseSchema];
-  if (inputType === supportedTypes.GROUP_ARRAY) {
-    validators[0] = () => withBaseSchema().of(buildGroupArraySchema());
-  } else if (inputType === supportedTypes.FIELDSET) {
-    validators[0] = () => withBaseSchema().shape(buildFieldSetSchema(propertyFields.fields));
-  }
-  if (propertyFields.required) {
-    validators.push(withRequired);
-  }
-  if (typeof propertyFields.minimum !== "undefined") {
-    validators.push(withMin);
-  }
-  if (typeof propertyFields.minLength !== "undefined") {
-    validators.push(withMinLength);
-  }
-  if (propertyFields.maximum !== void 0) {
-    validators.push(withMax);
-  }
-  if (propertyFields.maxLength) {
-    validators.push(withMaxLength);
-  }
-  if (propertyFields.pattern) {
-    validators.push(withMatches);
-  }
-  if (propertyFields.maxFileSize) {
-    validators.push(withMaxFileSize);
-  }
-  if (propertyFields.accept) {
-    validators.push(withFileFormat);
+  });
+}
+function throwIfUnknownOperator(operator, subRule, id) {
+  try {
+    import_json_logic_js.default.apply({ [operator]: subRule });
+  } catch (e) {
+    if (e.message === `Unrecognized operation ${operator}`) {
+      throw Error(
+        `[json-schema-form] json-logic error: in "${id}" rule there is an unknown operator "${operator}".`
+      );
+    }
   }
-  if (propertyFields.const) {
-    validators.push(withConst);
+}
+var regexToGetIndices = /\.\d+\./g;
+function removeIndicesFromPath(path) {
+  const intermediatePath = path.replace(regexToGetIndices, ".");
+  return intermediatePath.replace(/\.\d+$/, "");
+}
+function processJSONLogicNode({
+  node,
+  formFields,
+  formValues,
+  accRequired,
+  parentID,
+  logic
+}) {
+  const requiredFields = new Set(accRequired);
+  if (node.allOf) {
+    node.allOf.map(
+      (allOfNode) => processJSONLogicNode({ node: allOfNode, formValues, formFields, logic, parentID })
+    ).forEach(({ required: allOfItemRequired }) => {
+      allOfItemRequired.forEach(requiredFields.add, requiredFields);
+    });
   }
-  if (propertyFields.requiredValidations) {
-    propertyFields.requiredValidations.forEach(
-      (id) => validators.push(yupSchemaWithCustomJSONLogic({ field, id, logic, config }))
+  if (node.if) {
+    const matchesPropertyCondition = checkIfConditionMatchesProperties(
+      node,
+      formValues,
+      formFields,
+      logic
     );
-  }
-  return (0, import_flow.default)(validators);
-}
-function getNoSortEdges(fields = []) {
-  return fields.reduce((list, field) => {
-    if (field.noSortEdges) {
-      list.push(field.name);
+    const matchesValidationsAndComputedValues = matchesPropertyCondition && checkIfMatchesValidationsAndComputedValues(node, formValues, logic, parentID);
+    const isConditionMatch = matchesPropertyCondition && matchesValidationsAndComputedValues;
+    let nextNode;
+    if (isConditionMatch && node.then) {
+      nextNode = node.then;
     }
-    return list;
-  }, []);
-}
-function getSchema(fields = [], config) {
-  const newSchema = {};
-  fields.forEach((field) => {
-    if (field.schema) {
-      if (field.name) {
-        if (field.inputType === supportedTypes.FIELDSET) {
-          const fieldsetSchema = buildYupSchema(field, config)();
-          newSchema[field.name] = fieldsetSchema;
-        } else {
-          newSchema[field.name] = field.schema;
-        }
-      } else {
-        Object.assign(newSchema, getSchema(field.fields, config));
-      }
+    if (!isConditionMatch && node.else) {
+      nextNode = node.else;
     }
-  });
-  return newSchema;
-}
-function buildCompleteYupSchema(fields, config) {
-  return ObjectSchema().shape(getSchema(fields, config), getNoSortEdges(fields));
+    if (nextNode) {
+      const { required: branchRequired } = processNode({
+        node: nextNode,
+        formValues,
+        formFields,
+        accRequired,
+        logic,
+        parentID
+      });
+      branchRequired.forEach((field) => requiredFields.add(field));
+    }
+  }
+  return { required: requiredFields };
 }
 
 // src/helpers.js
@@ -12404,7 +12471,11 @@ function updateField(field, requiredFields, node, formValues, logic, config) {
     updateValues(computedFieldValues);
   }
   if (field.calculateConditionalProperties) {
-    const newFieldValues = field.calculateConditionalProperties(fieldIsRequired, node);
+    const newFieldValues = field.calculateConditionalProperties({
+      isRequired: fieldIsRequired,
+      conditionBranch: node,
+      formValues
+    });
     updateValues(newFieldValues);
   }
   if (field.calculateCustomValidationProperties) {
@@ -12436,7 +12507,7 @@ function processNode({
     });
   });
   if (node.if) {
-    const matchesCondition = checkIfConditionMatches(node, formValues, formFields, logic);
+    const matchesCondition = checkIfConditionMatchesProperties(node, formValues, formFields, logic);
     if (matchesCondition && node.then) {
       const { required: branchRequired } = processNode({
         node: node.then,
@@ -12499,6 +12570,17 @@ function processNode({
       }
     });
   }
+  if (node["x-jsf-logic"]) {
+    const { required: requiredFromLogic } = processJSONLogicNode({
+      node: node["x-jsf-logic"],
+      formValues,
+      formFields,
+      accRequired: requiredFields,
+      parentID,
+      logic
+    });
+    requiredFromLogic.forEach((field) => requiredFields.add(field));
+  }
   return {
     required: requiredFields
   };
@@ -12560,7 +12642,7 @@ function extractParametersFromNode(schemaNode) {
   }
   const presentation = pickXKey(schemaNode, "presentation") ?? {};
   const errorMessage = pickXKey(schemaNode, "errorMessage") ?? {};
-  const requiredValidations = schemaNode["x-jsf-logic-validations"];
+  const jsonLogicValidations = schemaNode["x-jsf-logic-validations"];
   const computedAttributes = schemaNode["x-jsf-logic-computedAttrs"];
   const decoratedComputedAttributes = getDecoratedComputedAttributes(computedAttributes);
   const node = (0, import_omit.default)(schemaNode, ["x-jsf-presentation", "presentation"]);
@@ -12604,7 +12686,7 @@ function extractParametersFromNode(schemaNode) {
       },
       // Handle [name].presentation
       ...presentation,
-      requiredValidations,
+      jsonLogicValidations,
       computedAttributes: decoratedComputedAttributes,
       description: containsHTML(description) ? wrapWithSpan(description, {
         class: "jsf-description"
@@ -12704,8 +12786,8 @@ function rebuildFieldset(fields, property2) {
     required: isFieldRequired(property2, field)
   }));
 }
-function calculateConditionalProperties(fieldParams, customProperties) {
-  return (isRequired, conditionBranch) => {
+function calculateConditionalProperties({ fieldParams, customProperties, logic, config }) {
+  return ({ isRequired, conditionBranch, formValues }) => {
     const conditionalProperty = conditionBranch?.properties?.[fieldParams.name];
     if (conditionalProperty) {
       const presentation = pickXKey(conditionalProperty, "presentation") ?? {};
@@ -12719,17 +12801,31 @@ function calculateConditionalProperties(fieldParams, customProperties) {
         fieldSetFields = rebuildFieldset(fieldParams.fields, conditionalProperty);
         newFieldParams.fields = fieldSetFields;
       }
+      const { computedAttributes, ...restNewFieldParams } = newFieldParams;
+      const calculatedComputedAttributes = computedAttributes ? calculateComputedAttributes(newFieldParams, config)({ logic, formValues }) : {};
+      const jsonLogicValidations = [
+        ...fieldParams.jsonLogicValidations ?? [],
+        ...restNewFieldParams.jsonLogicValidations ?? []
+      ];
       const base = {
         isVisible: true,
         required: isRequired,
         ...presentation?.inputType && { type: presentation.inputType },
-        schema: buildYupSchema({
-          ...fieldParams,
-          ...newFieldParams,
-          // If there are inner fields (case of fieldset) they need to be updated based on the condition
-          fields: fieldSetFields,
-          required: isRequired
-        })
+        ...calculatedComputedAttributes,
+        ...calculatedComputedAttributes.value ? { value: calculatedComputedAttributes.value } : { value: void 0 },
+        schema: buildYupSchema(
+          {
+            ...fieldParams,
+            ...restNewFieldParams,
+            ...calculatedComputedAttributes,
+            jsonLogicValidations,
+            // If there are inner fields (case of fieldset) they need to be updated based on the condition
+            fields: fieldSetFields,
+            required: isRequired
+          },
+          config,
+          logic
+        )
       };
       return (0, import_omit2.default)((0, import_merge2.default)(base, presentation, newFieldParams), ["inputType"]);
     }
@@ -12823,14 +12919,19 @@ function sortByOrderOrPosition(a, b, order) {
 function removeInvalidAttributes(fields) {
   return (0, import_omit3.default)(fields, ["items", "maxFileSize", "isDynamic"]);
 }
-function buildFieldParameters(name, fieldProperties, required2 = [], config = {}) {
+function buildFieldParameters(name, fieldProperties, required2 = [], config = {}, logic) {
   const { position } = pickXKey(fieldProperties, "presentation") ?? {};
   let fields;
   const inputType = getInputType(fieldProperties, config.strictInputType, name);
   if (inputType === supportedTypes.FIELDSET) {
-    fields = getFieldsFromJSONSchema(fieldProperties, {
-      customProperties: (0, import_get4.default)(config, `customProperties.${name}`, {})
-    });
+    fields = getFieldsFromJSONSchema(
+      fieldProperties,
+      {
+        customProperties: (0, import_get4.default)(config, `customProperties.${name}`, {}),
+        parentID: name
+      },
+      logic
+    );
   }
   const result = {
     name,
@@ -12887,7 +12988,7 @@ function buildField(fieldParams, config, scopedJsonSchema, logic) {
   const customProperties = getCustomPropertiesForField(fieldParams, config);
   const composeFn = getComposeFunctionForField(fieldParams, !!customProperties);
   const yupSchema = buildYupSchema(fieldParams, config, logic);
-  const calculateConditionalFieldsClosure = fieldParams.isDynamic && calculateConditionalProperties(fieldParams, customProperties);
+  const calculateConditionalFieldsClosure = fieldParams.isDynamic && calculateConditionalProperties({ fieldParams, customProperties, logic, config });
   const calculateCustomValidationPropertiesClosure = calculateCustomValidationProperties(
     fieldParams,
     customProperties