@rjsf/utils 5.11.1 → 5.12.0

package/dist/utils.esm.js

@@ -1,184 +1,107 @@
-import isPlainObject from 'lodash-es/isPlainObject';
-import isEqualWith from 'lodash-es/isEqualWith';
-import get from 'lodash-es/get';
-import isEmpty from 'lodash-es/isEmpty';
-import jsonpointer from 'jsonpointer';
-import omit from 'lodash-es/omit';
-import has from 'lodash-es/has';
-import isObject$1 from 'lodash-es/isObject';
-import isString from 'lodash-es/isString';
-import reduce from 'lodash-es/reduce';
-import times from 'lodash-es/times';
-import set from 'lodash-es/set';
-import forEach from 'lodash-es/forEach';
-import mergeAllOf from 'json-schema-merge-allof';
-import union from 'lodash-es/union';
-import isEqual from 'lodash-es/isEqual';
-import { isNil } from 'lodash-es';
-import cloneDeep from 'lodash-es/cloneDeep';
-import { jsx } from 'react/jsx-runtime';
-import { createElement } from 'react';
-import ReactIs from 'react-is';
-import toPath from 'lodash-es/toPath';
-
-/** Determines whether a `thing` is an object for the purposes of RSJF. In this case, `thing` is an object if it has
- * the type `object` but is NOT null, an array or a File.
- *
- * @param thing - The thing to check to see whether it is an object
- * @returns - True if it is a non-null, non-array, non-File object
- */
+// src/isObject.ts
 function isObject(thing) {
-  if (typeof File !== 'undefined' && thing instanceof File) {
+  if (typeof File !== "undefined" && thing instanceof File) {
     return false;
   }
-  if (typeof Date !== 'undefined' && thing instanceof Date) {
+  if (typeof Date !== "undefined" && thing instanceof Date) {
     return false;
   }
-  return typeof thing === 'object' && thing !== null && !Array.isArray(thing);
+  return typeof thing === "object" && thing !== null && !Array.isArray(thing);
 }
 
-/** Checks the schema to see if it is allowing additional items, by verifying that `schema.additionalItems` is an
- * object. The user is warned in the console if `schema.additionalItems` has the value `true`.
- *
- * @param schema - The schema object to check
- * @returns - True if additional items is allowed, otherwise false
- */
+// src/allowAdditionalItems.ts
 function allowAdditionalItems(schema) {
   if (schema.additionalItems === true) {
-    console.warn('additionalItems=true is currently not supported');
+    console.warn("additionalItems=true is currently not supported");
   }
   return isObject(schema.additionalItems);
 }
 
-/** Attempts to convert the string into a number. If an empty string is provided, then `undefined` is returned. If a
- * `null` is provided, it is returned. If the string ends in a `.` then the string is returned because the user may be
- * in the middle of typing a float number. If a number ends in a pattern like `.0`, `.20`, `.030`, string is returned
- * because the user may be typing number that will end in a non-zero digit. Otherwise, the string is wrapped by
- * `Number()` and if that result is not `NaN`, that number will be returned, otherwise the string `value` will be.
- *
- * @param value - The string or null value to convert to a number
- * @returns - The `value` converted to a number when appropriate, otherwise the `value`
- */
+// src/asNumber.ts
 function asNumber(value) {
-  if (value === '') {
-    return undefined;
+  if (value === "") {
+    return void 0;
   }
   if (value === null) {
     return null;
   }
   if (/\.$/.test(value)) {
-    // '3.' can't really be considered a number even if it parses in js. The
-    // user is most likely entering a float.
     return value;
   }
   if (/\.0$/.test(value)) {
-    // we need to return this as a string here, to allow for input like 3.07
     return value;
   }
   if (/\.\d*0$/.test(value)) {
-    // It's a number, that's cool - but we need it as a string so it doesn't screw
-    // with the user when entering dollar amounts or other values (such as those with
-    // specific precision or number of significant digits)
     return value;
   }
   const n = Number(value);
-  const valid = typeof n === 'number' && !Number.isNaN(n);
+  const valid = typeof n === "number" && !Number.isNaN(n);
   return valid ? n : value;
 }
 
-/** Below are the list of all the keys into various elements of a RJSFSchema or UiSchema that are used by the various
- * utility functions. In addition to those keys, there are the special `ADDITIONAL_PROPERTY_FLAG` and
- * `RJSF_ADDITONAL_PROPERTIES_FLAG` flags that is added to a schema under certain conditions by the `retrieveSchema()`
- * utility.
- */
-const ADDITIONAL_PROPERTY_FLAG = '__additional_property';
-const ADDITIONAL_PROPERTIES_KEY = 'additionalProperties';
-const ALL_OF_KEY = 'allOf';
-const ANY_OF_KEY = 'anyOf';
-const CONST_KEY = 'const';
-const DEFAULT_KEY = 'default';
-const DEFINITIONS_KEY = 'definitions';
-const DEPENDENCIES_KEY = 'dependencies';
-const ENUM_KEY = 'enum';
-const ERRORS_KEY = '__errors';
-const ID_KEY = '$id';
-const IF_KEY = 'if';
-const ITEMS_KEY = 'items';
-const JUNK_OPTION_ID = '_$junk_option_schema_id$_';
-const NAME_KEY = '$name';
-const ONE_OF_KEY = 'oneOf';
-const PROPERTIES_KEY = 'properties';
-const REQUIRED_KEY = 'required';
-const SUBMIT_BTN_OPTIONS_KEY = 'submitButtonOptions';
-const REF_KEY = '$ref';
-const RJSF_ADDITONAL_PROPERTIES_FLAG = '__rjsf_additionalProperties';
-const ROOT_SCHEMA_PREFIX = '__rjsf_rootSchema';
-const UI_FIELD_KEY = 'ui:field';
-const UI_WIDGET_KEY = 'ui:widget';
-const UI_OPTIONS_KEY = 'ui:options';
-const UI_GLOBAL_OPTIONS_KEY = 'ui:globalOptions';
-
-/** Get all passed options from ui:options, and ui:<optionName>, returning them in an object with the `ui:`
- * stripped off. Any `globalOptions` will always be returned, unless they are overridden by options in the `uiSchema`.
- *
- * @param [uiSchema={}] - The UI Schema from which to get any `ui:xxx` options
- * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
- * @returns - An object containing all the `ui:xxx` options with the `ui:` stripped off along with all `globalOptions`
- */
+// src/constants.ts
+var ADDITIONAL_PROPERTY_FLAG = "__additional_property";
+var ADDITIONAL_PROPERTIES_KEY = "additionalProperties";
+var ALL_OF_KEY = "allOf";
+var ANY_OF_KEY = "anyOf";
+var CONST_KEY = "const";
+var DEFAULT_KEY = "default";
+var DEFINITIONS_KEY = "definitions";
+var DEPENDENCIES_KEY = "dependencies";
+var ENUM_KEY = "enum";
+var ERRORS_KEY = "__errors";
+var ID_KEY = "$id";
+var IF_KEY = "if";
+var ITEMS_KEY = "items";
+var JUNK_OPTION_ID = "_$junk_option_schema_id$_";
+var NAME_KEY = "$name";
+var ONE_OF_KEY = "oneOf";
+var PROPERTIES_KEY = "properties";
+var REQUIRED_KEY = "required";
+var SUBMIT_BTN_OPTIONS_KEY = "submitButtonOptions";
+var REF_KEY = "$ref";
+var RJSF_ADDITONAL_PROPERTIES_FLAG = "__rjsf_additionalProperties";
+var ROOT_SCHEMA_PREFIX = "__rjsf_rootSchema";
+var UI_FIELD_KEY = "ui:field";
+var UI_WIDGET_KEY = "ui:widget";
+var UI_OPTIONS_KEY = "ui:options";
+var UI_GLOBAL_OPTIONS_KEY = "ui:globalOptions";
+
+// src/getUiOptions.ts
 function getUiOptions(uiSchema = {}, globalOptions = {}) {
-  return Object.keys(uiSchema).filter(key => key.indexOf('ui:') === 0).reduce((options, key) => {
-    const value = uiSchema[key];
-    if (key === UI_WIDGET_KEY && isObject(value)) {
-      console.error('Setting options via ui:widget object is no longer supported, use ui:options instead');
-      return options;
-    }
-    if (key === UI_OPTIONS_KEY && isObject(value)) {
-      return {
-        ...options,
-        ...value
-      };
-    }
-    return {
-      ...options,
-      [key.substring(3)]: value
-    };
-  }, {
-    ...globalOptions
-  });
+  return Object.keys(uiSchema).filter((key) => key.indexOf("ui:") === 0).reduce(
+    (options, key) => {
+      const value = uiSchema[key];
+      if (key === UI_WIDGET_KEY && isObject(value)) {
+        console.error("Setting options via ui:widget object is no longer supported, use ui:options instead");
+        return options;
+      }
+      if (key === UI_OPTIONS_KEY && isObject(value)) {
+        return { ...options, ...value };
+      }
+      return { ...options, [key.substring(3)]: value };
+    },
+    { ...globalOptions }
+  );
 }
 
-/** Checks whether the field described by `schema`, having the `uiSchema` and `formData` supports expanding. The UI for
- * the field can expand if it has additional properties, is not forced as non-expandable by the `uiSchema` and the
- * `formData` object doesn't already have `schema.maxProperties` elements.
- *
- * @param schema - The schema for the field that is being checked
- * @param [uiSchema={}] - The uiSchema for the field
- * @param [formData] - The formData for the field
- * @returns - True if the schema element has additionalProperties, is expandable, and not at the maxProperties limit
- */
+// src/canExpand.ts
 function canExpand(schema, uiSchema = {}, formData) {
   if (!schema.additionalProperties) {
     return false;
   }
-  const {
-    expandable = true
-  } = getUiOptions(uiSchema);
+  const { expandable = true } = getUiOptions(uiSchema);
   if (expandable === false) {
     return expandable;
   }
-  // if ui:options.expandable was not explicitly set to false, we can add
-  // another property if we have not exceeded maxProperties yet
-  if (schema.maxProperties !== undefined && formData) {
+  if (schema.maxProperties !== void 0 && formData) {
     return Object.keys(formData).length < schema.maxProperties;
   }
   return true;
 }
 
-/** Given a `formData` object, recursively creates a `FormValidation` error handling structure around it
- *
- * @param formData - The form data around which the error handler is created
- * @returns - A `FormValidation` object based on the `formData` structure
- */
+// src/createErrorHandler.ts
+import isPlainObject from "lodash/isPlainObject";
 function createErrorHandler(formData) {
   const handler = {
     // We store the list of errors for this node in a property named __errors
@@ -191,111 +114,80 @@ function createErrorHandler(formData) {
   };
   if (Array.isArray(formData)) {
     return formData.reduce((acc, value, key) => {
-      return {
-        ...acc,
-        [key]: createErrorHandler(value)
-      };
+      return { ...acc, [key]: createErrorHandler(value) };
     }, handler);
   }
   if (isPlainObject(formData)) {
     const formObject = formData;
     return Object.keys(formObject).reduce((acc, key) => {
-      return {
-        ...acc,
-        [key]: createErrorHandler(formObject[key])
-      };
+      return { ...acc, [key]: createErrorHandler(formObject[key]) };
     }, handler);
   }
   return handler;
 }
 
-/** Implements a deep equals using the `lodash.isEqualWith` function, that provides a customized comparator that
- * assumes all functions are equivalent.
- *
- * @param a - The first element to compare
- * @param b - The second element to compare
- * @returns - True if the `a` and `b` are deeply equal, false otherwise
- */
+// src/deepEquals.ts
+import isEqualWith from "lodash/isEqualWith";
 function deepEquals(a, b) {
   return isEqualWith(a, b, (obj, other) => {
-    if (typeof obj === 'function' && typeof other === 'function') {
-      // Assume all functions are equivalent
-      // see https://github.com/rjsf-team/react-jsonschema-form/issues/255
+    if (typeof obj === "function" && typeof other === "function") {
       return true;
     }
-    return undefined; // fallback to default isEquals behavior
+    return void 0;
   });
 }
 
-/** Splits out the value at the `key` in `object` from the `object`, returning an array that contains in the first
- * location, the `object` minus the `key: value` and in the second location the `value`.
- *
- * @param key - The key from the object to extract
- * @param object - The object from which to extract the element
- * @returns - An array with the first value being the object minus the `key` element and the second element being the
- *      value from `object[key]`
- */
+// src/schema/getDefaultFormState.ts
+import get6 from "lodash/get";
+import isEmpty from "lodash/isEmpty";
+
+// src/findSchemaDefinition.ts
+import jsonpointer from "jsonpointer";
+import omit from "lodash/omit";
 function splitKeyElementFromObject(key, object) {
   const value = object[key];
   const remaining = omit(object, [key]);
   return [remaining, value];
 }
-/** Given the name of a `$ref` from within a schema, using the `rootSchema`, look up and return the sub-schema using the
- * path provided by that reference. If `#` is not the first character of the reference, or the path does not exist in
- * the schema, then throw an Error. Otherwise return the sub-schema. Also deals with nested `$ref`s in the sub-schema.
- *
- * @param $ref - The ref string for which the schema definition is desired
- * @param [rootSchema={}] - The root schema in which to search for the definition
- * @returns - The sub-schema within the `rootSchema` which matches the `$ref` if it exists
- * @throws - Error indicating that no schema for that reference exists
- */
 function findSchemaDefinition($ref, rootSchema = {}) {
-  let ref = $ref || '';
-  if (ref.startsWith('#')) {
-    // Decode URI fragment representation.
+  let ref = $ref || "";
+  if (ref.startsWith("#")) {
     ref = decodeURIComponent(ref.substring(1));
   } else {
     throw new Error(`Could not find a definition for ${$ref}.`);
   }
   const current = jsonpointer.get(rootSchema, ref);
-  if (current === undefined) {
+  if (current === void 0) {
     throw new Error(`Could not find a definition for ${$ref}.`);
   }
   if (current[REF_KEY]) {
     const [remaining, theRef] = splitKeyElementFromObject(REF_KEY, current);
     const subSchema = findSchemaDefinition(theRef, rootSchema);
     if (Object.keys(remaining).length > 0) {
-      return {
-        ...remaining,
-        ...subSchema
-      };
+      return { ...remaining, ...subSchema };
     }
     return subSchema;
   }
   return current;
 }
 
-/** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
- * Deprecated, use `getFirstMatchingOption()` instead.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param formData - The current formData, if any, used to figure out a match
- * @param options - The list of options to find a matching options from
- * @param rootSchema - The root schema, used to primarily to look up `$ref`s
- * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
- *          determine which option is selected
- * @returns - The index of the matched option or 0 if none is available
- * @deprecated
- */
+// src/schema/getClosestMatchingOption.ts
+import get4 from "lodash/get";
+import has2 from "lodash/has";
+import isObject2 from "lodash/isObject";
+import isString2 from "lodash/isString";
+import reduce from "lodash/reduce";
+import times2 from "lodash/times";
+
+// src/schema/getMatchingOption.ts
+import get from "lodash/get";
+import has from "lodash/has";
 function getMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
-  // For performance, skip validating subschemas if formData is undefined. We just
-  // want to get the first option in that case.
-  if (formData === undefined) {
+  if (formData === void 0) {
     return 0;
   }
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
-    // If we have a discriminator field, then we will use this to make the determination
     if (discriminatorField && has(option, [PROPERTIES_KEY, discriminatorField])) {
       const value = get(formData, discriminatorField);
       const discriminator = get(option, [PROPERTIES_KEY, discriminatorField], {});
@@ -303,32 +195,17 @@ function getMatchingOption(validator, formData, options, rootSchema, discriminat
         return i;
       }
     } else if (option[PROPERTIES_KEY]) {
-      // If the schema describes an object then we need to add slightly more
-      // strict matching to the schema, because unless the schema uses the
-      // "requires" keyword, an object will match the schema as long as it
-      // doesn't have matching keys with a conflicting type. To do this we use an
-      // "anyOf" with an array of requires. This augmentation expresses that the
-      // schema should match if any of the keys in the schema are present on the
-      // object and pass validation.
-      //
-      // Create an "anyOf" schema that requires at least one of the keys in the
-      // "properties" object
       const requiresAnyOf = {
-        anyOf: Object.keys(option[PROPERTIES_KEY]).map(key => ({
+        anyOf: Object.keys(option[PROPERTIES_KEY]).map((key) => ({
           required: [key]
         }))
       };
       let augmentedSchema;
-      // If the "anyOf" keyword already exists, wrap the augmentation in an "allOf"
       if (option.anyOf) {
-        // Create a shallow clone of the option
-        const {
-          ...shallowClone
-        } = option;
+        const { ...shallowClone } = option;
         if (!shallowClone.allOf) {
           shallowClone.allOf = [];
         } else {
-          // If "allOf" already exists, shallow clone the array
           shallowClone.allOf = shallowClone.allOf.slice();
         }
         shallowClone.allOf.push(requiresAnyOf);
@@ -336,8 +213,6 @@ function getMatchingOption(validator, formData, options, rootSchema, discriminat
       } else {
         augmentedSchema = Object.assign({}, option, requiresAnyOf);
       }
-      // Remove the "required" field as it's likely that not all fields have
-      // been filled in yet, which will mean that the schema is not valid
       delete augmentedSchema.required;
       if (validator.isValid(augmentedSchema, formData, rootSchema)) {
         return i;
@@ -349,373 +224,241 @@ function getMatchingOption(validator, formData, options, rootSchema, discriminat
   return 0;
 }
 
-/** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
- * Always returns the first option if there is nothing that matches.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param formData - The current formData, if any, used to figure out a match
- * @param options - The list of options to find a matching options from
- * @param rootSchema - The root schema, used to primarily to look up `$ref`s
- * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
- *          determine which option is selected
- * @returns - The index of the first matched option or 0 if none is available
- */
+// src/schema/getFirstMatchingOption.ts
 function getFirstMatchingOption(validator, formData, options, rootSchema, discriminatorField) {
   return getMatchingOption(validator, formData, options, rootSchema, discriminatorField);
 }
 
-/** Returns the `discriminator.propertyName` when defined in the `schema` if it is a string. A warning is generated when
- * it is not a string. Returns `undefined` when a valid discriminator is not present.
- *
- * @param schema - The schema from which the discriminator is potentially obtained
- * @returns - The `discriminator.propertyName` if it exists in the schema, otherwise `undefined`
- */
+// src/schema/retrieveSchema.ts
+import get3 from "lodash/get";
+import set from "lodash/set";
+import times from "lodash/times";
+import transform from "lodash/transform";
+import mergeAllOf from "json-schema-merge-allof";
+
+// src/getDiscriminatorFieldFromSchema.ts
+import get2 from "lodash/get";
+import isString from "lodash/isString";
 function getDiscriminatorFieldFromSchema(schema) {
   let discriminator;
-  const maybeString = get(schema, 'discriminator.propertyName', undefined);
+  const maybeString = get2(schema, "discriminator.propertyName", void 0);
   if (isString(maybeString)) {
     discriminator = maybeString;
-  } else if (maybeString !== undefined) {
+  } else if (maybeString !== void 0) {
     console.warn(`Expecting discriminator to be a string, got "${typeof maybeString}" instead`);
   }
   return discriminator;
 }
 
-/** Given a specific `value` attempts to guess the type of a schema element. In the case where we have to implicitly
- *  create a schema, it is useful to know what type to use based on the data we are defining.
- *
- * @param value - The value from which to guess the type
- * @returns - The best guess for the object type
- */
+// src/guessType.ts
 function guessType(value) {
   if (Array.isArray(value)) {
-    return 'array';
+    return "array";
   }
-  if (typeof value === 'string') {
-    return 'string';
+  if (typeof value === "string") {
+    return "string";
   }
   if (value == null) {
-    return 'null';
+    return "null";
   }
-  if (typeof value === 'boolean') {
-    return 'boolean';
+  if (typeof value === "boolean") {
+    return "boolean";
   }
   if (!isNaN(value)) {
-    return 'number';
-  }
-  if (typeof value === 'object') {
-    return 'object';
-  }
-  // Default to string if we can't figure it out
-  return 'string';
-}
-
-/** Gets the type of a given `schema`. If the type is not explicitly defined, then an attempt is made to infer it from
- * other elements of the schema as follows:
- * - schema.const: Returns the `guessType()` of that value
- * - schema.enum: Returns `string`
- * - schema.properties: Returns `object`
- * - schema.additionalProperties: Returns `object`
- * - type is an array with a length of 2 and one type is 'null': Returns the other type
- *
- * @param schema - The schema for which to get the type
- * @returns - The type of the schema
- */
+    return "number";
+  }
+  if (typeof value === "object") {
+    return "object";
+  }
+  return "string";
+}
+
+// src/mergeSchemas.ts
+import union from "lodash/union";
+
+// src/getSchemaType.ts
 function getSchemaType(schema) {
-  let {
-    type
-  } = schema;
+  let { type } = schema;
   if (!type && schema.const) {
     return guessType(schema.const);
   }
   if (!type && schema.enum) {
-    return 'string';
+    return "string";
   }
   if (!type && (schema.properties || schema.additionalProperties)) {
-    return 'object';
+    return "object";
   }
-  if (Array.isArray(type) && type.length === 2 && type.includes('null')) {
-    type = type.find(type => type !== 'null');
+  if (Array.isArray(type) && type.length === 2 && type.includes("null")) {
+    type = type.find((type2) => type2 !== "null");
   }
   return type;
 }
 
-/** Recursively merge deeply nested schemas. The difference between `mergeSchemas` and `mergeObjects` is that
- * `mergeSchemas` only concats arrays for values under the 'required' keyword, and when it does, it doesn't include
- * duplicate values.
- *
- * @param obj1 - The first schema object to merge
- * @param obj2 - The second schema object to merge
- * @returns - The merged schema object
- */
+// src/mergeSchemas.ts
 function mergeSchemas(obj1, obj2) {
-  const acc = Object.assign({}, obj1); // Prevent mutation of source object.
-  return Object.keys(obj2).reduce((acc, key) => {
-    const left = obj1 ? obj1[key] : {},
-      right = obj2[key];
+  const acc = Object.assign({}, obj1);
+  return Object.keys(obj2).reduce((acc2, key) => {
+    const left = obj1 ? obj1[key] : {}, right = obj2[key];
     if (obj1 && key in obj1 && isObject(right)) {
-      acc[key] = mergeSchemas(left, right);
-    } else if (obj1 && obj2 && (getSchemaType(obj1) === 'object' || getSchemaType(obj2) === 'object') && key === REQUIRED_KEY && Array.isArray(left) && Array.isArray(right)) {
-      // Don't include duplicate values when merging 'required' fields.
-      acc[key] = union(left, right);
+      acc2[key] = mergeSchemas(left, right);
+    } else if (obj1 && obj2 && (getSchemaType(obj1) === "object" || getSchemaType(obj2) === "object") && key === REQUIRED_KEY && Array.isArray(left) && Array.isArray(right)) {
+      acc2[key] = union(left, right);
     } else {
-      acc[key] = right;
+      acc2[key] = right;
     }
-    return acc;
+    return acc2;
   }, acc);
 }
 
-/** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
- * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
- * potentially recursive resolution.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which retrieving a schema is desired
- * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
- * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
- * @returns - The schema having its conditions, additional properties, references and dependencies resolved
- */
+// src/schema/retrieveSchema.ts
 function retrieveSchema(validator, schema, rootSchema = {}, rawFormData) {
   return retrieveSchemaInternal(validator, schema, rootSchema, rawFormData)[0];
 }
-/** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
- * with the rest of the schema. If `expandAllBranches` is true, then the `retrieveSchemaInteral()` results for both
- * conditions will be returned.
- *
- * @param validator - An implementation of the `ValidatorType` interface that is used to detect valid schema conditions
- * @param schema - The schema for which resolving a condition is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and
- *          dependencies as a list of schemas
- * @param [formData] - The current formData to assist retrieving a schema
- * @returns - A list of schemas with the appropriate conditions resolved, possibly with all branches expanded
- */
 function resolveCondition(validator, schema, rootSchema, expandAllBranches, formData) {
-  const {
-    if: expression,
-    then,
-    else: otherwise,
-    ...resolvedSchemaLessConditional
-  } = schema;
+  const { if: expression, then, else: otherwise, ...resolvedSchemaLessConditional } = schema;
   const conditionValue = validator.isValid(expression, formData || {}, rootSchema);
   let resolvedSchemas = [resolvedSchemaLessConditional];
   let schemas = [];
   if (expandAllBranches) {
-    if (then && typeof then !== 'boolean') {
-      schemas = schemas.concat(retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches));
+    if (then && typeof then !== "boolean") {
+      schemas = schemas.concat(
+        retrieveSchemaInternal(validator, then, rootSchema, formData, expandAllBranches)
+      );
     }
-    if (otherwise && typeof otherwise !== 'boolean') {
-      schemas = schemas.concat(retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches));
+    if (otherwise && typeof otherwise !== "boolean") {
+      schemas = schemas.concat(
+        retrieveSchemaInternal(validator, otherwise, rootSchema, formData, expandAllBranches)
+      );
     }
   } else {
     const conditionalSchema = conditionValue ? then : otherwise;
-    if (conditionalSchema && typeof conditionalSchema !== 'boolean') {
-      schemas = schemas.concat(retrieveSchemaInternal(validator, conditionalSchema, rootSchema, formData, expandAllBranches));
+    if (conditionalSchema && typeof conditionalSchema !== "boolean") {
+      schemas = schemas.concat(
+        retrieveSchemaInternal(validator, conditionalSchema, rootSchema, formData, expandAllBranches)
+      );
     }
   }
   if (schemas.length) {
-    resolvedSchemas = schemas.map(s => mergeSchemas(resolvedSchemaLessConditional, s));
-  }
-  return resolvedSchemas.flatMap(s => retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches));
-}
-/** Given a list of lists of allOf, anyOf or oneOf values, create a list of lists of all permutations of the values. The
- * `listOfLists` is expected to be all resolved values of the 1st...nth schemas within an `allOf`, `anyOf` or `oneOf`.
- * From those lists, build a matrix for each `xxxOf` where there is more than one schema for a row in the list of lists.
- *
- * For example:
- * - If there are three xxxOf rows (A, B, C) and they have been resolved such that there is only one A, two B and three
- *   C schemas then:
- *   - The permutation for the first row is `[[A]]`
- *   - The permutations for the second row are `[[A,B1], [A,B2]]`
- *   - The permutations for the third row are `[[A,B1,C1], [A,B1,C2], [A,B1,C3], [A,B2,C1], [A,B2,C2], [A,B2,C3]]`
- *
- * @param listOfLists - The list of lists of elements that represent the allOf, anyOf or oneOf resolved values in order
- * @returns - The list of all permutations of schemas for a set of `xxxOf`s
- */
+    resolvedSchemas = schemas.map((s) => mergeSchemas(resolvedSchemaLessConditional, s));
+  }
+  return resolvedSchemas.flatMap(
+    (s) => retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches)
+  );
+}
 function getAllPermutationsOfXxxOf(listOfLists) {
-  const allPermutations = listOfLists.reduce((permutations, list) => {
-    // When there are more than one set of schemas for a row, duplicate the set of permutations and add in the values
-    if (list.length > 1) {
-      return list.flatMap(element => times(permutations.length, i => [...permutations[i]].concat(element)));
-    }
-    // Otherwise just push in the single value into the current set of permutations
-    permutations.forEach(permutation => permutation.push(list[0]));
-    return permutations;
-  }, [[]] // Start with an empty list
+  const allPermutations = listOfLists.reduce(
+    (permutations, list) => {
+      if (list.length > 1) {
+        return list.flatMap((element) => times(permutations.length, (i) => [...permutations[i]].concat(element)));
+      }
+      permutations.forEach((permutation) => permutation.push(list[0]));
+      return permutations;
+    },
+    [[]]
+    // Start with an empty list
   );
-
   return allPermutations;
 }
-/** Resolves references and dependencies within a schema and its 'allOf' children. Passes the `expandAllBranches` flag
- * down to the `retrieveSchemaInternal()`, `resolveReference()` and `resolveDependencies()` helper calls. If
- * `expandAllBranches` is true, then all possible dependencies and/or allOf branches are returned.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which resolving a schema is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
- *          as a list of schemas
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The list of schemas having its references, dependencies and allOf schemas resolved
- */
 function resolveSchema(validator, schema, rootSchema, expandAllBranches, formData) {
   if (REF_KEY in schema) {
     return resolveReference(validator, schema, rootSchema, expandAllBranches, formData);
   }
   if (DEPENDENCIES_KEY in schema) {
     const resolvedSchemas = resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData);
-    return resolvedSchemas.flatMap(s => {
+    return resolvedSchemas.flatMap((s) => {
       return retrieveSchemaInternal(validator, s, rootSchema, formData, expandAllBranches);
     });
   }
   if (ALL_OF_KEY in schema && Array.isArray(schema.allOf)) {
-    const allOfSchemaElements = schema.allOf.map(allOfSubschema => retrieveSchemaInternal(validator, allOfSubschema, rootSchema, formData, expandAllBranches));
+    const allOfSchemaElements = schema.allOf.map(
+      (allOfSubschema) => retrieveSchemaInternal(validator, allOfSubschema, rootSchema, formData, expandAllBranches)
+    );
     const allPermutations = getAllPermutationsOfXxxOf(allOfSchemaElements);
-    return allPermutations.map(permutation => ({
-      ...schema,
-      allOf: permutation
-    }));
+    return allPermutations.map((permutation) => ({ ...schema, allOf: permutation }));
   }
-  // No $ref or dependencies or allOf attribute was found, returning the original schema.
   return [schema];
 }
-/** Resolves references within a schema and then returns the `retrieveSchemaInternal()` of the resolved schema. Passes
- * the `expandAllBranches` flag down to the `retrieveSchemaInternal()` helper call.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which resolving a reference is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
- *          as a list of schemas
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The list schemas retrieved after having all references resolved
- */
 function resolveReference(validator, schema, rootSchema, expandAllBranches, formData) {
-  // Drop the $ref property of the source schema.
-  const {
-    $ref,
-    ...localSchema
-  } = schema;
-  // Retrieve the referenced schema definition.
+  const { $ref, ...localSchema } = schema;
   const refSchema = findSchemaDefinition($ref, rootSchema);
-  // Update referenced schema definition with local schema properties.
-  return retrieveSchemaInternal(validator, {
-    ...refSchema,
-    ...localSchema
-  }, rootSchema, formData, expandAllBranches);
-}
-/** Resolves all references within a schema's properties and array items.
- *
- * @param schema - The schema for which resolving all references is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @returns - given schema will all references resolved
- */
+  return retrieveSchemaInternal(
+    validator,
+    { ...refSchema, ...localSchema },
+    rootSchema,
+    formData,
+    expandAllBranches
+  );
+}
 function resolveAllReferences(schema, rootSchema) {
   let resolvedSchema = schema;
-  // resolve top level ref
   if (REF_KEY in resolvedSchema) {
-    const {
-      $ref,
-      ...localSchema
-    } = resolvedSchema;
-    // Retrieve the referenced schema definition.
+    const { $ref, ...localSchema } = resolvedSchema;
     const refSchema = findSchemaDefinition($ref, rootSchema);
-    resolvedSchema = {
-      ...refSchema,
-      ...localSchema
-    };
+    resolvedSchema = { ...refSchema, ...localSchema };
   }
   if (PROPERTIES_KEY in resolvedSchema) {
-    forEach(resolvedSchema[PROPERTIES_KEY], (value, key) => {
-      resolvedSchema[PROPERTIES_KEY][key] = resolveAllReferences(value, rootSchema);
-    });
+    const updatedProps = transform(
+      resolvedSchema[PROPERTIES_KEY],
+      (result, value, key) => {
+        result[key] = resolveAllReferences(value, rootSchema);
+      },
+      {}
+    );
+    resolvedSchema = { ...resolvedSchema, [PROPERTIES_KEY]: updatedProps };
   }
-  if (ITEMS_KEY in resolvedSchema && !Array.isArray(resolvedSchema.items) && typeof resolvedSchema.items !== 'boolean') {
-    resolvedSchema.items = resolveAllReferences(resolvedSchema.items, rootSchema);
+  if (ITEMS_KEY in resolvedSchema && !Array.isArray(resolvedSchema.items) && typeof resolvedSchema.items !== "boolean") {
+    resolvedSchema = { ...resolvedSchema, items: resolveAllReferences(resolvedSchema.items, rootSchema) };
   }
   return resolvedSchema;
 }
-/** Creates new 'properties' items for each key in the `formData`
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param theSchema - The schema for which the existing additional properties is desired
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param validator
- * @param [aFormData] - The current formData, if any, to assist retrieving a schema
- * @returns - The updated schema with additional properties stubbed
- */
 function stubExistingAdditionalProperties(validator, theSchema, rootSchema, aFormData) {
-  // Clone the schema so that we don't ruin the consumer's original
   const schema = {
     ...theSchema,
-    properties: {
-      ...theSchema.properties
-    }
+    properties: { ...theSchema.properties }
   };
-  // make sure formData is an object
   const formData = aFormData && isObject(aFormData) ? aFormData : {};
-  Object.keys(formData).forEach(key => {
+  Object.keys(formData).forEach((key) => {
     if (key in schema.properties) {
-      // No need to stub, our schema already has the property
       return;
     }
     let additionalProperties = {};
-    if (typeof schema.additionalProperties !== 'boolean') {
+    if (typeof schema.additionalProperties !== "boolean") {
       if (REF_KEY in schema.additionalProperties) {
-        additionalProperties = retrieveSchema(validator, {
-          $ref: get(schema.additionalProperties, [REF_KEY])
-        }, rootSchema, formData);
-      } else if ('type' in schema.additionalProperties) {
-        additionalProperties = {
-          ...schema.additionalProperties
-        };
+        additionalProperties = retrieveSchema(
+          validator,
+          { $ref: get3(schema.additionalProperties, [REF_KEY]) },
+          rootSchema,
+          formData
+        );
+      } else if ("type" in schema.additionalProperties) {
+        additionalProperties = { ...schema.additionalProperties };
       } else if (ANY_OF_KEY in schema.additionalProperties || ONE_OF_KEY in schema.additionalProperties) {
         additionalProperties = {
-          type: 'object',
+          type: "object",
           ...schema.additionalProperties
         };
       } else {
-        additionalProperties = {
-          type: guessType(get(formData, [key]))
-        };
+        additionalProperties = { type: guessType(get3(formData, [key])) };
       }
     } else {
-      additionalProperties = {
-        type: guessType(get(formData, [key]))
-      };
+      additionalProperties = { type: guessType(get3(formData, [key])) };
     }
-    // The type of our new key should match the additionalProperties value;
     schema.properties[key] = additionalProperties;
-    // Set our additional property flag so we know it was dynamically added
     set(schema.properties, [key, ADDITIONAL_PROPERTY_FLAG], true);
   });
   return schema;
 }
-/** Internal handler that retrieves an expanded schema that has had all of its conditions, additional properties,
- * references and dependencies resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData`
- * that is used to do the potentially recursive resolution. If `expandAllBranches` is true, then all possible branches
- * of the schema and its references, conditions and dependencies are returned.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which retrieving a schema is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
- * @param [expandAllBranches=false] - Flag, if true, will return all possible branches of conditions, any/oneOf and
- *          dependencies as a list of schemas
- * @returns - The schema(s) resulting from having its conditions, additional properties, references and dependencies
- *          resolved. Multiple schemas may be returned if `expandAllBranches` is true.
- */
 function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expandAllBranches = false) {
   if (!isObject(schema)) {
     return [{}];
   }
   const resolvedSchemas = resolveSchema(validator, schema, rootSchema, expandAllBranches, rawFormData);
-  return resolvedSchemas.flatMap(s => {
+  return resolvedSchemas.flatMap((s) => {
     let resolvedSchema = s;
     if (IF_KEY in resolvedSchema) {
       return resolveCondition(validator, resolvedSchema, rootSchema, expandAllBranches, rawFormData);
     }
     if (ALL_OF_KEY in resolvedSchema) {
-      // resolve allOf schemas
       if (expandAllBranches) {
         return [...resolvedSchema.allOf];
       }
@@ -724,11 +467,8 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
           deep: false
         });
       } catch (e) {
-        console.warn('could not merge subschemas in allOf:\n', e);
-        const {
-          allOf,
-          ...resolvedSchemaWithoutAllOf
-        } = resolvedSchema;
+        console.warn("could not merge subschemas in allOf:\n", e);
+        const { allOf, ...resolvedSchemaWithoutAllOf } = resolvedSchema;
         return resolvedSchemaWithoutAllOf;
       }
     }
@@ -739,177 +479,123 @@ function retrieveSchemaInternal(validator, schema, rootSchema, rawFormData, expa
     return resolvedSchema;
   });
 }
-/** Resolves an `anyOf` or `oneOf` within a schema (if present) to the list of schemas returned from
- * `retrieveSchemaInternal()` for the best matching option. If `expandAllBranches` is true, then a list of schemas for ALL
- * options are retrieved and returned.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which retrieving a schema is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
- *          as a list of schemas
- * @param [rawFormData] - The current formData, if any, to assist retrieving a schema, defaults to an empty object
- * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true
- */
 function resolveAnyOrOneOfSchemas(validator, schema, rootSchema, expandAllBranches, rawFormData) {
   let anyOrOneOf;
-  const {
-    oneOf,
-    anyOf,
-    ...remaining
-  } = schema;
+  const { oneOf, anyOf, ...remaining } = schema;
   if (Array.isArray(oneOf)) {
     anyOrOneOf = oneOf;
   } else if (Array.isArray(anyOf)) {
     anyOrOneOf = anyOf;
   }
   if (anyOrOneOf) {
-    // Ensure that during expand all branches we pass an object rather than undefined so that all options are interrogated
-    const formData = rawFormData === undefined && expandAllBranches ? {} : rawFormData;
+    const formData = rawFormData === void 0 && expandAllBranches ? {} : rawFormData;
     const discriminator = getDiscriminatorFieldFromSchema(schema);
-    anyOrOneOf = anyOrOneOf.map(s => {
+    anyOrOneOf = anyOrOneOf.map((s) => {
       return resolveAllReferences(s, rootSchema);
     });
-    // Call this to trigger the set of isValid() calls that the schema parser will need
     const option = getFirstMatchingOption(validator, formData, anyOrOneOf, rootSchema, discriminator);
     if (expandAllBranches) {
-      return anyOrOneOf.map(item => mergeSchemas(remaining, item));
+      return anyOrOneOf.map((item) => mergeSchemas(remaining, item));
     }
     schema = mergeSchemas(remaining, anyOrOneOf[option]);
   }
   return [schema];
 }
-/** Resolves dependencies within a schema and its 'anyOf/oneOf' children. Passes the `expandAllBranches` flag down to
- * the `resolveAnyOrOneOfSchema()` and `processDependencies()` helper calls.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which resolving a dependency is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
- *          as a list of schemas
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The list of schemas with their dependencies resolved
- */
 function resolveDependencies(validator, schema, rootSchema, expandAllBranches, formData) {
-  // Drop the dependencies from the source schema.
-  const {
-    dependencies,
-    ...remainingSchema
-  } = schema;
-  const resolvedSchemas = resolveAnyOrOneOfSchemas(validator, remainingSchema, rootSchema, expandAllBranches, formData);
-  return resolvedSchemas.flatMap(resolvedSchema => processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData));
-}
-/** Processes all the `dependencies` recursively into the list of `resolvedSchema`s as needed. Passes the
- * `expandAllBranches` flag down to the `withDependentSchema()` and the recursive `processDependencies()` helper calls.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param dependencies - The set of dependencies that needs to be processed
- * @param resolvedSchema - The schema for which processing dependencies is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
- *          as a list of schemas
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The schema with the `dependencies` resolved into it
- */
+  const { dependencies, ...remainingSchema } = schema;
+  const resolvedSchemas = resolveAnyOrOneOfSchemas(
+    validator,
+    remainingSchema,
+    rootSchema,
+    expandAllBranches,
+    formData
+  );
+  return resolvedSchemas.flatMap(
+    (resolvedSchema) => processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData)
+  );
+}
 function processDependencies(validator, dependencies, resolvedSchema, rootSchema, expandAllBranches, formData) {
   let schemas = [resolvedSchema];
-  // Process dependencies updating the local schema properties as appropriate.
   for (const dependencyKey in dependencies) {
-    // Skip this dependency if its trigger property is not present.
-    if (!expandAllBranches && get(formData, [dependencyKey]) === undefined) {
+    if (!expandAllBranches && get3(formData, [dependencyKey]) === void 0) {
       continue;
     }
-    // Skip this dependency if it is not included in the schema (such as when dependencyKey is itself a hidden dependency.)
     if (resolvedSchema.properties && !(dependencyKey in resolvedSchema.properties)) {
       continue;
     }
-    const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(dependencyKey, dependencies);
+    const [remainingDependencies, dependencyValue] = splitKeyElementFromObject(
+      dependencyKey,
+      dependencies
+    );
     if (Array.isArray(dependencyValue)) {
       schemas[0] = withDependentProperties(resolvedSchema, dependencyValue);
     } else if (isObject(dependencyValue)) {
-      schemas = withDependentSchema(validator, resolvedSchema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, formData);
+      schemas = withDependentSchema(
+        validator,
+        resolvedSchema,
+        rootSchema,
+        dependencyKey,
+        dependencyValue,
+        expandAllBranches,
+        formData
+      );
     }
-    return schemas.flatMap(schema => processDependencies(validator, remainingDependencies, schema, rootSchema, expandAllBranches, formData));
+    return schemas.flatMap(
+      (schema) => processDependencies(validator, remainingDependencies, schema, rootSchema, expandAllBranches, formData)
+    );
   }
   return schemas;
 }
-/** Updates a schema with additionally required properties added
- *
- * @param schema - The schema for which resolving a dependent properties is desired
- * @param [additionallyRequired] - An optional array of additionally required names
- * @returns - The schema with the additional required values merged in
- */
 function withDependentProperties(schema, additionallyRequired) {
   if (!additionallyRequired) {
     return schema;
   }
-  const required = Array.isArray(schema.required) ? Array.from(new Set([...schema.required, ...additionallyRequired])) : additionallyRequired;
-  return {
-    ...schema,
-    required: required
-  };
+  const required = Array.isArray(schema.required) ? Array.from(/* @__PURE__ */ new Set([...schema.required, ...additionallyRequired])) : additionallyRequired;
+  return { ...schema, required };
 }
-/** Merges a dependent schema into the `schema` dealing with oneOfs and references. Passes the `expandAllBranches` flag
- * down to the `retrieveSchemaInternal()`, `resolveReference()` and `withExactlyOneSubschema()` helper calls.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which resolving a dependent schema is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param dependencyKey - The key name of the dependency
- * @param dependencyValue - The potentially dependent schema
- * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
- *          as a list of schemas
- * @param [formData]- The current formData to assist retrieving a schema
- * @returns - The list of schemas with the dependent schema resolved into them
- */
 function withDependentSchema(validator, schema, rootSchema, dependencyKey, dependencyValue, expandAllBranches, formData) {
-  const dependentSchemas = retrieveSchemaInternal(validator, dependencyValue, rootSchema, formData, expandAllBranches);
-  return dependentSchemas.flatMap(dependent => {
-    const {
-      oneOf,
-      ...dependentSchema
-    } = dependent;
+  const dependentSchemas = retrieveSchemaInternal(
+    validator,
+    dependencyValue,
+    rootSchema,
+    formData,
+    expandAllBranches
+  );
+  return dependentSchemas.flatMap((dependent) => {
+    const { oneOf, ...dependentSchema } = dependent;
     schema = mergeSchemas(schema, dependentSchema);
-    // Since it does not contain oneOf, we return the original schema.
-    if (oneOf === undefined) {
+    if (oneOf === void 0) {
       return schema;
     }
-    // Resolve $refs inside oneOf.
-    const resolvedOneOfs = oneOf.map(subschema => {
-      if (typeof subschema === 'boolean' || !(REF_KEY in subschema)) {
+    const resolvedOneOfs = oneOf.map((subschema) => {
+      if (typeof subschema === "boolean" || !(REF_KEY in subschema)) {
         return [subschema];
       }
       return resolveReference(validator, subschema, rootSchema, expandAllBranches, formData);
     });
     const allPermutations = getAllPermutationsOfXxxOf(resolvedOneOfs);
-    return allPermutations.flatMap(resolvedOneOf => withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, resolvedOneOf, expandAllBranches, formData));
+    return allPermutations.flatMap(
+      (resolvedOneOf) => withExactlyOneSubschema(
+        validator,
+        schema,
+        rootSchema,
+        dependencyKey,
+        resolvedOneOf,
+        expandAllBranches,
+        formData
+      )
+    );
   });
 }
-/** Returns a list of `schema`s with the best choice from the `oneOf` options merged into it. If `expandAllBranches` is
- * true, then a list of schemas for ALL options are retrieved and returned. Passes the `expandAllBranches` flag down to
- * the `retrieveSchemaInternal()` helper call.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used to validate oneOf options
- * @param schema - The schema for which resolving a oneOf subschema is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param dependencyKey - The key name of the oneOf dependency
- * @param oneOf - The list of schemas representing the oneOf options
- * @param expandAllBranches - Flag, if true, will return all possible branches of conditions, any/oneOf and dependencies
- *          as a list of schemas
- * @param [formData] - The current formData to assist retrieving a schema
- * @returns - Either an array containing the best matching option or all options if `expandAllBranches` is true
- */
 function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, oneOf, expandAllBranches, formData) {
-  const validSubschemas = oneOf.filter(subschema => {
-    if (typeof subschema === 'boolean' || !subschema || !subschema.properties) {
+  const validSubschemas = oneOf.filter((subschema) => {
+    if (typeof subschema === "boolean" || !subschema || !subschema.properties) {
       return false;
     }
-    const {
-      [dependencyKey]: conditionPropertySchema
-    } = subschema.properties;
+    const { [dependencyKey]: conditionPropertySchema } = subschema.properties;
     if (conditionPropertySchema) {
       const conditionSchema = {
-        type: 'object',
+        type: "object",
         properties: {
           [dependencyKey]: conditionPropertySchema
         }
@@ -922,194 +608,125 @@ function withExactlyOneSubschema(validator, schema, rootSchema, dependencyKey, o
     console.warn("ignoring oneOf in dependencies because there isn't exactly one subschema that is valid");
     return [schema];
   }
-  return validSubschemas.flatMap(s => {
+  return validSubschemas.flatMap((s) => {
     const subschema = s;
     const [dependentSubschema] = splitKeyElementFromObject(dependencyKey, subschema.properties);
-    const dependentSchema = {
-      ...subschema,
-      properties: dependentSubschema
-    };
-    const schemas = retrieveSchemaInternal(validator, dependentSchema, rootSchema, formData, expandAllBranches);
-    return schemas.map(s => mergeSchemas(schema, s));
+    const dependentSchema = { ...subschema, properties: dependentSubschema };
+    const schemas = retrieveSchemaInternal(
+      validator,
+      dependentSchema,
+      rootSchema,
+      formData,
+      expandAllBranches
+    );
+    return schemas.map((s2) => mergeSchemas(schema, s2));
   });
 }
 
-/** A junk option used to determine when the getFirstMatchingOption call really matches an option rather than returning
- * the first item
- */
-const JUNK_OPTION = {
-  type: 'object',
+// src/schema/getClosestMatchingOption.ts
+var JUNK_OPTION = {
+  type: "object",
   $id: JUNK_OPTION_ID,
   properties: {
     __not_really_there__: {
-      type: 'number'
+      type: "number"
     }
   }
 };
-/** Recursive function that calculates the score of a `formData` against the given `schema`. The computation is fairly
- * simple. Initially the total score is 0. When `schema.properties` object exists, then all the `key/value` pairs within
- * the object are processed as follows after obtaining the formValue from `formData` using the `key`:
- * - If the `value` contains a `$ref`, `calculateIndexScore()` is called recursively with the formValue and the new
- *   schema that is the result of the ref in the schema being resolved and that sub-schema's resulting score is added to
- *   the total.
- * - If the `value` contains a `oneOf` and there is a formValue, then score based on the index returned from calling
- *   `getClosestMatchingOption()` of that oneOf.
- * - If the type of the `value` is 'object', `calculateIndexScore()` is called recursively with the formValue and the
- *   `value` itself as the sub-schema, and the score is added to the total.
- * - If the type of the `value` matches the guessed-type of the `formValue`, the score is incremented by 1, UNLESS the
- *   value has a `default` or `const`. In those case, if the `default` or `const` and the `formValue` match, the score
- *   is incremented by another 1 otherwise it is decremented by 1.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param rootSchema - The root JSON schema of the entire form
- * @param schema - The schema for which the score is being calculated
- * @param formData - The form data associated with the schema, used to calculate the score
- * @returns - The score a schema against the formData
- */
 function calculateIndexScore(validator, rootSchema, schema, formData = {}) {
   let totalScore = 0;
   if (schema) {
-    if (isObject$1(schema.properties)) {
-      totalScore += reduce(schema.properties, (score, value, key) => {
-        const formValue = get(formData, key);
-        if (typeof value === 'boolean') {
-          return score;
-        }
-        if (has(value, REF_KEY)) {
-          const newSchema = retrieveSchema(validator, value, rootSchema, formValue);
-          return score + calculateIndexScore(validator, rootSchema, newSchema, formValue || {});
-        }
-        if ((has(value, ONE_OF_KEY) || has(value, ANY_OF_KEY)) && formValue) {
-          const key = has(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
-          const discriminator = getDiscriminatorFieldFromSchema(value);
-          return score + getClosestMatchingOption(validator, rootSchema, formValue, get(value, key), -1, discriminator);
-        }
-        if (value.type === 'object') {
-          return score + calculateIndexScore(validator, rootSchema, value, formValue || {});
-        }
-        if (value.type === guessType(formValue)) {
-          // If the types match, then we bump the score by one
-          let newScore = score + 1;
-          if (value.default) {
-            // If the schema contains a readonly default value score the value that matches the default higher and
-            // any non-matching value lower
-            newScore += formValue === value.default ? 1 : -1;
-          } else if (value.const) {
-            // If the schema contains a const value score the value that matches the default higher and
-            // any non-matching value lower
-            newScore += formValue === value.const ? 1 : -1;
+    if (isObject2(schema.properties)) {
+      totalScore += reduce(
+        schema.properties,
+        (score, value, key) => {
+          const formValue = get4(formData, key);
+          if (typeof value === "boolean") {
+            return score;
           }
-          // TODO eventually, deal with enums/arrays
-          return newScore;
-        }
-        return score;
-      }, 0);
-    } else if (isString(schema.type) && schema.type === guessType(formData)) {
+          if (has2(value, REF_KEY)) {
+            const newSchema = retrieveSchema(validator, value, rootSchema, formValue);
+            return score + calculateIndexScore(validator, rootSchema, newSchema, formValue || {});
+          }
+          if ((has2(value, ONE_OF_KEY) || has2(value, ANY_OF_KEY)) && formValue) {
+            const key2 = has2(value, ONE_OF_KEY) ? ONE_OF_KEY : ANY_OF_KEY;
+            const discriminator = getDiscriminatorFieldFromSchema(value);
+            return score + getClosestMatchingOption(
+              validator,
+              rootSchema,
+              formValue,
+              get4(value, key2),
+              -1,
+              discriminator
+            );
+          }
+          if (value.type === "object") {
+            return score + calculateIndexScore(validator, rootSchema, value, formValue || {});
+          }
+          if (value.type === guessType(formValue)) {
+            let newScore = score + 1;
+            if (value.default) {
+              newScore += formValue === value.default ? 1 : -1;
+            } else if (value.const) {
+              newScore += formValue === value.const ? 1 : -1;
+            }
+            return newScore;
+          }
+          return score;
+        },
+        0
+      );
+    } else if (isString2(schema.type) && schema.type === guessType(formData)) {
       totalScore += 1;
     }
   }
   return totalScore;
 }
-/** Determines which of the given `options` provided most closely matches the `formData`. Using
- * `getFirstMatchingOption()` to match two schemas that differ only by the readOnly, default or const value of a field
- * based on the `formData` and returns 0 when there is no match. Rather than passing in all the `options` at once to
- * this utility, instead an array of valid option indexes is created by iterating over the list of options, call
- * `getFirstMatchingOptions` with a list of one junk option and one good option, seeing if the good option is considered
- * matched.
- *
- * Once the list of valid indexes is created, if there is only one valid index, just return it. Otherwise, if there are
- * no valid indexes, then fill the valid indexes array with the indexes of all the options. Next, the index of the
- * option with the highest score is determined by iterating over the list of valid options, calling
- * `calculateIndexScore()` on each, comparing it against the current best score, and returning the index of the one that
- * eventually has the best score.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param rootSchema - The root JSON schema of the entire form
- * @param formData - The form data associated with the schema
- * @param options - The list of options that can be selected from
- * @param [selectedOption=-1] - The index of the currently selected option, defaulted to -1 if not specified
- * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
- *          determine which option is selected
- * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
- */
 function getClosestMatchingOption(validator, rootSchema, formData, options, selectedOption = -1, discriminatorField) {
-  // First resolve any refs in the options
-  const resolvedOptions = options.map(option => {
+  const resolvedOptions = options.map((option) => {
     return resolveAllReferences(option, rootSchema);
   });
-  // Reduce the array of options down to a list of the indexes that are considered matching options
   const allValidIndexes = resolvedOptions.reduce((validList, option, index) => {
     const testOptions = [JUNK_OPTION, option];
     const match = getFirstMatchingOption(validator, formData, testOptions, rootSchema, discriminatorField);
-    // The match is the real option, so add its index to list of valid indexes
     if (match === 1) {
       validList.push(index);
     }
     return validList;
   }, []);
-  // There is only one valid index, so return it!
   if (allValidIndexes.length === 1) {
     return allValidIndexes[0];
   }
   if (!allValidIndexes.length) {
-    // No indexes were valid, so we'll score all the options, add all the indexes
-    times(resolvedOptions.length, i => allValidIndexes.push(i));
-  }
-  const scoreCount = new Set();
-  // Score all the options in the list of valid indexes and return the index with the best score
-  const {
-    bestIndex
-  } = allValidIndexes.reduce((scoreData, index) => {
-    const {
-      bestScore
-    } = scoreData;
-    const option = resolvedOptions[index];
-    const score = calculateIndexScore(validator, rootSchema, option, formData);
-    scoreCount.add(score);
-    if (score > bestScore) {
-      return {
-        bestIndex: index,
-        bestScore: score
-      };
-    }
-    return scoreData;
-  }, {
-    bestIndex: selectedOption,
-    bestScore: 0
-  });
-  // if all scores are the same go with selectedOption
+    times2(resolvedOptions.length, (i) => allValidIndexes.push(i));
+  }
+  const scoreCount = /* @__PURE__ */ new Set();
+  const { bestIndex } = allValidIndexes.reduce(
+    (scoreData, index) => {
+      const { bestScore } = scoreData;
+      const option = resolvedOptions[index];
+      const score = calculateIndexScore(validator, rootSchema, option, formData);
+      scoreCount.add(score);
+      if (score > bestScore) {
+        return { bestIndex: index, bestScore: score };
+      }
+      return scoreData;
+    },
+    { bestIndex: selectedOption, bestScore: 0 }
+  );
   if (scoreCount.size === 1 && selectedOption >= 0) {
     return selectedOption;
   }
   return bestIndex;
 }
 
-/** Detects whether the given `schema` contains fixed items. This is the case when `schema.items` is a non-empty array
- * that only contains objects.
- *
- * @param schema - The schema in which to check for fixed items
- * @returns - True if there are fixed items in the schema, false otherwise
- */
+// src/isFixedItems.ts
 function isFixedItems(schema) {
-  return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every(item => isObject(item));
-}
-
-/** Merges the `defaults` object of type `T` into the `formData` of type `T`
- *
- * When merging defaults and form data, we want to merge in this specific way:
- * - objects are deeply merged
- * - arrays are merged in such a way that:
- *   - when the array is set in form data, only array entries set in form data
- *     are deeply merged; additional entries from the defaults are ignored unless `mergeExtraArrayDefaults` is true, in
- *     which case the extras are appended onto the end of the form data
- *   - when the array is not set in form data, the default is copied over
- * - scalars are overwritten/set by form data
- *
- * @param [defaults] - The defaults to merge
- * @param [formData] - The form data into which the defaults will be merged
- * @param [mergeExtraArrayDefaults=false] - If true, any additional default array entries are appended onto the formData
- * @returns - The resulting merged form data with defaults
- */
+  return Array.isArray(schema.items) && schema.items.length > 0 && schema.items.every((item) => isObject(item));
+}
+
+// src/mergeDefaultsWithFormData.ts
+import get5 from "lodash/get";
 function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults = false) {
   if (Array.isArray(formData)) {
     const defaultsArray = Array.isArray(defaults) ? defaults : [];
@@ -1119,40 +736,34 @@ function mergeDefaultsWithFormData(defaults, formData, mergeExtraArrayDefaults =
       }
       return value;
     });
-    // Merge any extra defaults when mergeExtraArrayDefaults is true
     if (mergeExtraArrayDefaults && mapped.length < defaultsArray.length) {
       mapped.push(...defaultsArray.slice(mapped.length));
     }
     return mapped;
   }
   if (isObject(formData)) {
-    const acc = Object.assign({}, defaults); // Prevent mutation of source object.
-    return Object.keys(formData).reduce((acc, key) => {
-      acc[key] = mergeDefaultsWithFormData(defaults ? get(defaults, key) : {}, get(formData, key), mergeExtraArrayDefaults);
-      return acc;
+    const acc = Object.assign({}, defaults);
+    return Object.keys(formData).reduce((acc2, key) => {
+      acc2[key] = mergeDefaultsWithFormData(
+        defaults ? get5(defaults, key) : {},
+        get5(formData, key),
+        mergeExtraArrayDefaults
+      );
+      return acc2;
     }, acc);
   }
   return formData;
 }
 
-/** Recursively merge deeply nested objects.
- *
- * @param obj1 - The first object to merge
- * @param obj2 - The second object to merge
- * @param [concatArrays=false] - Optional flag that, when true, will cause arrays to be concatenated. Use
- *          "preventDuplicates" to merge arrays in a manner that prevents any duplicate entries from being merged.
- *          NOTE: Uses shallow comparison for the duplicate checking.
- * @returns - A new object that is the merge of the two given objects
- */
+// src/mergeObjects.ts
 function mergeObjects(obj1, obj2, concatArrays = false) {
   return Object.keys(obj2).reduce((acc, key) => {
-    const left = obj1 ? obj1[key] : {},
-      right = obj2[key];
+    const left = obj1 ? obj1[key] : {}, right = obj2[key];
     if (obj1 && key in obj1 && isObject(right)) {
       acc[key] = mergeObjects(left, right, concatArrays);
     } else if (concatArrays && Array.isArray(left) && Array.isArray(right)) {
       let toMerge = right;
-      if (concatArrays === 'preventDuplicates') {
+      if (concatArrays === "preventDuplicates") {
         toMerge = right.reduce((result, value) => {
           if (!left.includes(value)) {
             result.push(value);
@@ -1165,216 +776,140 @@ function mergeObjects(obj1, obj2, concatArrays = false) {
       acc[key] = right;
     }
     return acc;
-  }, Object.assign({}, obj1)); // Prevent mutation of source object.
+  }, Object.assign({}, obj1));
 }
 
-/** This function checks if the given `schema` matches a single constant value. This happens when either the schema has
- * an `enum` array with a single value or there is a `const` defined.
- *
- * @param schema - The schema for a field
- * @returns - True if the `schema` has a single constant value, false otherwise
- */
+// src/isConstant.ts
 function isConstant(schema) {
   return Array.isArray(schema.enum) && schema.enum.length === 1 || CONST_KEY in schema;
 }
 
-/** Checks to see if the `schema` combination represents a select
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param theSchema - The schema for which check for a select flag is desired
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @returns - True if schema contains a select, otherwise false
- */
+// src/schema/isSelect.ts
 function isSelect(validator, theSchema, rootSchema = {}) {
-  const schema = retrieveSchema(validator, theSchema, rootSchema, undefined);
+  const schema = retrieveSchema(validator, theSchema, rootSchema, void 0);
   const altSchemas = schema.oneOf || schema.anyOf;
   if (Array.isArray(schema.enum)) {
     return true;
   }
   if (Array.isArray(altSchemas)) {
-    return altSchemas.every(altSchemas => typeof altSchemas !== 'boolean' && isConstant(altSchemas));
+    return altSchemas.every((altSchemas2) => typeof altSchemas2 !== "boolean" && isConstant(altSchemas2));
   }
   return false;
 }
 
-/** Checks to see if the `schema` combination represents a multi-select
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which check for a multi-select flag is desired
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @returns - True if schema contains a multi-select, otherwise false
- */
+// src/schema/isMultiSelect.ts
 function isMultiSelect(validator, schema, rootSchema) {
-  if (!schema.uniqueItems || !schema.items || typeof schema.items === 'boolean') {
+  if (!schema.uniqueItems || !schema.items || typeof schema.items === "boolean") {
     return false;
   }
   return isSelect(validator, schema.items, rootSchema);
 }
 
-/** Enum that indicates how `schema.additionalItems` should be handled by the `getInnerSchemaForArrayItem()` function.
- */
-var AdditionalItemsHandling;
-(function (AdditionalItemsHandling) {
-  AdditionalItemsHandling[AdditionalItemsHandling["Ignore"] = 0] = "Ignore";
-  AdditionalItemsHandling[AdditionalItemsHandling["Invert"] = 1] = "Invert";
-  AdditionalItemsHandling[AdditionalItemsHandling["Fallback"] = 2] = "Fallback";
-})(AdditionalItemsHandling || (AdditionalItemsHandling = {}));
-/** Given a `schema` will return an inner schema that for an array item. This is computed differently based on the
- * `additionalItems` enum and the value of `idx`. There are four possible returns:
- * 1. If `idx` is >= 0, then if `schema.items` is an array the `idx`th element of the array is returned if it is a valid
- *    index and not a boolean, otherwise it falls through to 3.
- * 2. If `schema.items` is not an array AND truthy and not a boolean, then `schema.items` is returned since it actually
- *    is a schema, otherwise it falls through to 3.
- * 3. If `additionalItems` is not `AdditionalItemsHandling.Ignore` and `schema.additionalItems` is an object, then
- *    `schema.additionalItems` is returned since it actually is a schema, otherwise it falls through to 4.
- * 4. {} is returned representing an empty schema
- *
- * @param schema - The schema from which to get the particular item
- * @param [additionalItems=AdditionalItemsHandling.Ignore] - How do we want to handle additional items?
- * @param [idx=-1] - Index, if non-negative, will be used to return the idx-th element in a `schema.items` array
- * @returns - The best fit schema object from the `schema` given the `additionalItems` and `idx` modifiers
- */
-function getInnerSchemaForArrayItem(schema, additionalItems = AdditionalItemsHandling.Ignore, idx = -1) {
+// src/schema/getDefaultFormState.ts
+function getInnerSchemaForArrayItem(schema, additionalItems = 0 /* Ignore */, idx = -1) {
   if (idx >= 0) {
     if (Array.isArray(schema.items) && idx < schema.items.length) {
       const item = schema.items[idx];
-      if (typeof item !== 'boolean') {
+      if (typeof item !== "boolean") {
         return item;
       }
     }
-  } else if (schema.items && !Array.isArray(schema.items) && typeof schema.items !== 'boolean') {
+  } else if (schema.items && !Array.isArray(schema.items) && typeof schema.items !== "boolean") {
     return schema.items;
   }
-  if (additionalItems !== AdditionalItemsHandling.Ignore && isObject(schema.additionalItems)) {
+  if (additionalItems !== 0 /* Ignore */ && isObject(schema.additionalItems)) {
     return schema.additionalItems;
   }
   return {};
 }
-/** Either add `computedDefault` at `key` into `obj` or not add it based on its value, the value of
- * `includeUndefinedValues`, the value of `emptyObjectFields` and if its parent field is required. Generally undefined
- * `computedDefault` values are added only when `includeUndefinedValues` is either true/"excludeObjectChildren". If `
- * includeUndefinedValues` is false and `emptyObjectFields` is not "skipDefaults", then non-undefined and non-empty-object
- * values will be added based on certain conditions.
- *
- * @param obj - The object into which the computed default may be added
- * @param key - The key into the object at which the computed default may be added
- * @param computedDefault - The computed default value that maybe should be added to the obj
- * @param includeUndefinedValues - Optional flag, if true, cause undefined values to be added as defaults.
- *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
- *          false when computing defaults for any nested object properties. If "allowEmptyObject", prevents undefined
- *          values in this object while allow the object itself to be empty and passing `includeUndefinedValues` as
- *          false when computing defaults for any nested object properties.
- * @param isParentRequired - The optional boolean that indicates whether the parent field is required
- * @param requiredFields - The list of fields that are required
- * @param experimental_defaultFormStateBehavior - Optional configuration object, if provided, allows users to override
- *        default form state behavior
- */
 function maybeAddDefaultToObject(obj, key, computedDefault, includeUndefinedValues, isParentRequired, requiredFields = [], experimental_defaultFormStateBehavior = {}) {
-  const {
-    emptyObjectFields = 'populateAllDefaults'
-  } = experimental_defaultFormStateBehavior;
+  const { emptyObjectFields = "populateAllDefaults" } = experimental_defaultFormStateBehavior;
   if (includeUndefinedValues) {
     obj[key] = computedDefault;
-  } else if (emptyObjectFields !== 'skipDefaults') {
+  } else if (emptyObjectFields !== "skipDefaults") {
     if (isObject(computedDefault)) {
-      // If isParentRequired is undefined, then we are at the root level of the schema so defer to the requiredness of
-      // the field key itself in the `requiredField` list
-      const isSelfOrParentRequired = isParentRequired === undefined ? requiredFields.includes(key) : isParentRequired;
-      // Store computedDefault if it's a non-empty object(e.g. not {}) and satisfies certain conditions
-      // Condition 1: If computedDefault is not empty or if the key is a required field
-      // Condition 2: If the parent object is required or emptyObjectFields is not 'populateRequiredDefaults'
-      if ((!isEmpty(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== 'populateRequiredDefaults')) {
+      const isSelfOrParentRequired = isParentRequired === void 0 ? requiredFields.includes(key) : isParentRequired;
+      if ((!isEmpty(computedDefault) || requiredFields.includes(key)) && (isSelfOrParentRequired || emptyObjectFields !== "populateRequiredDefaults")) {
         obj[key] = computedDefault;
       }
     } else if (
-    // Store computedDefault if it's a defined primitive (e.g., true) and satisfies certain conditions
-    // Condition 1: computedDefault is not undefined
-    // Condition 2: If emptyObjectFields is 'populateAllDefaults' or if the key is a required field
-    computedDefault !== undefined && (emptyObjectFields === 'populateAllDefaults' || requiredFields.includes(key))) {
+      // Store computedDefault if it's a defined primitive (e.g., true) and satisfies certain conditions
+      // Condition 1: computedDefault is not undefined
+      // Condition 2: If emptyObjectFields is 'populateAllDefaults' or if the key is a required field
+      computedDefault !== void 0 && (emptyObjectFields === "populateAllDefaults" || requiredFields.includes(key))
+    ) {
       obj[key] = computedDefault;
     }
   }
 }
-/** Computes the defaults for the current `schema` given the `rawFormData` and `parentDefaults` if any. This drills into
- * each level of the schema, recursively, to fill out every level of defaults provided by the schema.
- *
- * @param validator - an implementation of the `ValidatorType` interface that will be used when necessary
- * @param rawSchema - The schema for which the default state is desired
- * @param [props] - Optional props for this function
- * @param [props.parentDefaults] - Any defaults provided by the parent field in the schema
- * @param [props.rootSchema] - The options root schema, used to primarily to look up `$ref`s
- * @param [props.rawFormData] - The current formData, if any, onto which to provide any missing defaults
- * @param [props.includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
- *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
- *          false when computing defaults for any nested object properties.
- * @param [props._recurseList=[]] - The list of ref names currently being recursed, used to prevent infinite recursion
- * @param [props.experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
- * @param [props.required] - Optional flag, if true, indicates this schema was required in the parent schema.
- * @returns - The resulting `formData` with all the defaults provided
- */
 function computeDefaults(validator, rawSchema, {
   parentDefaults,
   rawFormData,
   rootSchema = {},
   includeUndefinedValues = false,
   _recurseList = [],
-  experimental_defaultFormStateBehavior = undefined,
+  experimental_defaultFormStateBehavior = void 0,
   required
 } = {}) {
   const formData = isObject(rawFormData) ? rawFormData : {};
   const schema = isObject(rawSchema) ? rawSchema : {};
-  // Compute the defaults recursively: give highest priority to deepest nodes.
   let defaults = parentDefaults;
-  // If we get a new schema, then we need to recompute defaults again for the new schema found.
   let schemaToCompute = null;
   let updatedRecurseList = _recurseList;
   if (isObject(defaults) && isObject(schema.default)) {
-    // For object defaults, only override parent defaults that are defined in
-    // schema.default.
     defaults = mergeObjects(defaults, schema.default);
   } else if (DEFAULT_KEY in schema) {
     defaults = schema.default;
   } else if (REF_KEY in schema) {
     const refName = schema[REF_KEY];
-    // Use referenced schema defaults for this node.
     if (!_recurseList.includes(refName)) {
       updatedRecurseList = _recurseList.concat(refName);
       schemaToCompute = findSchemaDefinition(refName, rootSchema);
     }
   } else if (DEPENDENCIES_KEY in schema) {
     const resolvedSchema = resolveDependencies(validator, schema, rootSchema, false, formData);
-    schemaToCompute = resolvedSchema[0]; // pick the first element from resolve dependencies
+    schemaToCompute = resolvedSchema[0];
   } else if (isFixedItems(schema)) {
-    defaults = schema.items.map((itemSchema, idx) => computeDefaults(validator, itemSchema, {
-      rootSchema,
-      includeUndefinedValues,
-      _recurseList,
-      experimental_defaultFormStateBehavior,
-      parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : undefined,
-      rawFormData: formData,
-      required
-    }));
+    defaults = schema.items.map(
+      (itemSchema, idx) => computeDefaults(validator, itemSchema, {
+        rootSchema,
+        includeUndefinedValues,
+        _recurseList,
+        experimental_defaultFormStateBehavior,
+        parentDefaults: Array.isArray(parentDefaults) ? parentDefaults[idx] : void 0,
+        rawFormData: formData,
+        required
+      })
+    );
   } else if (ONE_OF_KEY in schema) {
-    const {
-      oneOf,
-      ...remaining
-    } = schema;
+    const { oneOf, ...remaining } = schema;
     if (oneOf.length === 0) {
-      return undefined;
+      return void 0;
     }
     const discriminator = getDiscriminatorFieldFromSchema(schema);
-    schemaToCompute = oneOf[getClosestMatchingOption(validator, rootSchema, isEmpty(formData) ? undefined : formData, oneOf, 0, discriminator)];
+    schemaToCompute = oneOf[getClosestMatchingOption(
+      validator,
+      rootSchema,
+      isEmpty(formData) ? void 0 : formData,
+      oneOf,
+      0,
+      discriminator
+    )];
     schemaToCompute = mergeSchemas(remaining, schemaToCompute);
   } else if (ANY_OF_KEY in schema) {
-    const {
-      anyOf,
-      ...remaining
-    } = schema;
+    const { anyOf, ...remaining } = schema;
     if (anyOf.length === 0) {
-      return undefined;
+      return void 0;
     }
     const discriminator = getDiscriminatorFieldFromSchema(schema);
-    schemaToCompute = anyOf[getClosestMatchingOption(validator, rootSchema, isEmpty(formData) ? undefined : formData, anyOf, 0, discriminator)];
+    schemaToCompute = anyOf[getClosestMatchingOption(
+      validator,
+      rootSchema,
+      isEmpty(formData) ? void 0 : formData,
+      anyOf,
+      0,
+      discriminator
+    )];
     schemaToCompute = mergeSchemas(remaining, schemaToCompute);
   }
   if (schemaToCompute) {
@@ -1388,135 +923,130 @@ function computeDefaults(validator, rawSchema, {
       required
     });
   }
-  // No defaults defined for this node, fallback to generic typed ones.
-  if (defaults === undefined) {
+  if (defaults === void 0) {
     defaults = schema.default;
   }
   switch (getSchemaType(schema)) {
-    // We need to recurse for object schema inner default values.
-    case 'object':
-      {
-        const objectDefaults = Object.keys(schema.properties || {}).reduce((acc, key) => {
-          var _schema$required;
-          // Compute the defaults for this node, with the parent defaults we might
-          // have from a previous run: defaults[key].
-          const computedDefault = computeDefaults(validator, get(schema, [PROPERTIES_KEY, key]), {
+    case "object": {
+      const objectDefaults = Object.keys(schema.properties || {}).reduce((acc, key) => {
+        const computedDefault = computeDefaults(validator, get6(schema, [PROPERTIES_KEY, key]), {
+          rootSchema,
+          _recurseList,
+          experimental_defaultFormStateBehavior,
+          includeUndefinedValues: includeUndefinedValues === true,
+          parentDefaults: get6(defaults, [key]),
+          rawFormData: get6(formData, [key]),
+          required: schema.required?.includes(key)
+        });
+        maybeAddDefaultToObject(
+          acc,
+          key,
+          computedDefault,
+          includeUndefinedValues,
+          required,
+          schema.required,
+          experimental_defaultFormStateBehavior
+        );
+        return acc;
+      }, {});
+      if (schema.additionalProperties) {
+        const additionalPropertiesSchema = isObject(schema.additionalProperties) ? schema.additionalProperties : {};
+        const keys = /* @__PURE__ */ new Set();
+        if (isObject(defaults)) {
+          Object.keys(defaults).filter((key) => !schema.properties || !schema.properties[key]).forEach((key) => keys.add(key));
+        }
+        let formDataRequired;
+        if (isObject(formData)) {
+          formDataRequired = [];
+          Object.keys(formData).filter((key) => !schema.properties || !schema.properties[key]).forEach((key) => {
+            keys.add(key);
+            formDataRequired.push(key);
+          });
+        }
+        keys.forEach((key) => {
+          const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
             rootSchema,
             _recurseList,
             experimental_defaultFormStateBehavior,
             includeUndefinedValues: includeUndefinedValues === true,
-            parentDefaults: get(defaults, [key]),
-            rawFormData: get(formData, [key]),
-            required: (_schema$required = schema.required) === null || _schema$required === void 0 ? void 0 : _schema$required.includes(key)
-          });
-          maybeAddDefaultToObject(acc, key, computedDefault, includeUndefinedValues, required, schema.required, experimental_defaultFormStateBehavior);
-          return acc;
-        }, {});
-        if (schema.additionalProperties) {
-          // as per spec additionalProperties may be either schema or boolean
-          const additionalPropertiesSchema = isObject(schema.additionalProperties) ? schema.additionalProperties : {};
-          const keys = new Set();
-          if (isObject(defaults)) {
-            Object.keys(defaults).filter(key => !schema.properties || !schema.properties[key]).forEach(key => keys.add(key));
-          }
-          let formDataRequired;
-          if (isObject(formData)) {
-            formDataRequired = [];
-            Object.keys(formData).filter(key => !schema.properties || !schema.properties[key]).forEach(key => {
-              keys.add(key);
-              formDataRequired.push(key);
-            });
-          }
-          keys.forEach(key => {
-            var _schema$required2;
-            const computedDefault = computeDefaults(validator, additionalPropertiesSchema, {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              includeUndefinedValues: includeUndefinedValues === true,
-              parentDefaults: get(defaults, [key]),
-              rawFormData: get(formData, [key]),
-              required: (_schema$required2 = schema.required) === null || _schema$required2 === void 0 ? void 0 : _schema$required2.includes(key)
-            });
-            // Since these are additional properties we don’t need to add the `experimental_defaultFormStateBehavior` prop
-            maybeAddDefaultToObject(objectDefaults, key, computedDefault, includeUndefinedValues, required, formDataRequired);
+            parentDefaults: get6(defaults, [key]),
+            rawFormData: get6(formData, [key]),
+            required: schema.required?.includes(key)
           });
-        }
-        return objectDefaults;
+          maybeAddDefaultToObject(
+            objectDefaults,
+            key,
+            computedDefault,
+            includeUndefinedValues,
+            required,
+            formDataRequired
+          );
+        });
       }
-    case 'array':
-      {
-        var _experimental_default;
-        // Inject defaults into existing array defaults
-        if (Array.isArray(defaults)) {
-          defaults = defaults.map((item, idx) => {
-            const schemaItem = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Fallback, idx);
-            return computeDefaults(validator, schemaItem, {
-              rootSchema,
-              _recurseList,
-              experimental_defaultFormStateBehavior,
-              parentDefaults: item,
-              required
-            });
+      return objectDefaults;
+    }
+    case "array": {
+      const neverPopulate = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "never";
+      const ignoreMinItemsFlagSet = experimental_defaultFormStateBehavior?.arrayMinItems?.populate === "requiredOnly";
+      if (Array.isArray(defaults)) {
+        defaults = defaults.map((item, idx) => {
+          const schemaItem = getInnerSchemaForArrayItem(schema, 2 /* Fallback */, idx);
+          return computeDefaults(validator, schemaItem, {
+            rootSchema,
+            _recurseList,
+            experimental_defaultFormStateBehavior,
+            parentDefaults: item,
+            required
           });
-        }
-        // Deeply inject defaults into already existing form data
-        if (Array.isArray(rawFormData)) {
-          const schemaItem = getInnerSchemaForArrayItem(schema);
+        });
+      }
+      if (Array.isArray(rawFormData)) {
+        const schemaItem = getInnerSchemaForArrayItem(schema);
+        if (neverPopulate) {
+          defaults = rawFormData;
+        } else {
           defaults = rawFormData.map((item, idx) => {
             return computeDefaults(validator, schemaItem, {
               rootSchema,
               _recurseList,
               experimental_defaultFormStateBehavior,
               rawFormData: item,
-              parentDefaults: get(defaults, [idx]),
+              parentDefaults: get6(defaults, [idx]),
               required
             });
           });
         }
-        const ignoreMinItemsFlagSet = (experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : (_experimental_default = experimental_defaultFormStateBehavior.arrayMinItems) === null || _experimental_default === void 0 ? void 0 : _experimental_default.populate) === 'requiredOnly';
-        if (ignoreMinItemsFlagSet && !required) {
-          // If no form data exists or defaults are set leave the field empty/non-existent, otherwise
-          // return form data/defaults
-          return defaults ? defaults : undefined;
-        }
-        const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
-        if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
-          return defaults ? defaults : [];
-        }
-        const defaultEntries = defaults || [];
-        const fillerSchema = getInnerSchemaForArrayItem(schema, AdditionalItemsHandling.Invert);
-        const fillerDefault = fillerSchema.default;
-        // Calculate filler entries for remaining items (minItems - existing raw data/defaults)
-        const fillerEntries = new Array(schema.minItems - defaultsLength).fill(computeDefaults(validator, fillerSchema, {
+      }
+      if (neverPopulate) {
+        return defaults ?? [];
+      }
+      if (ignoreMinItemsFlagSet && !required) {
+        return defaults ? defaults : void 0;
+      }
+      const defaultsLength = Array.isArray(defaults) ? defaults.length : 0;
+      if (!schema.minItems || isMultiSelect(validator, schema, rootSchema) || schema.minItems <= defaultsLength) {
+        return defaults ? defaults : [];
+      }
+      const defaultEntries = defaults || [];
+      const fillerSchema = getInnerSchemaForArrayItem(schema, 1 /* Invert */);
+      const fillerDefault = fillerSchema.default;
+      const fillerEntries = new Array(schema.minItems - defaultsLength).fill(
+        computeDefaults(validator, fillerSchema, {
           parentDefaults: fillerDefault,
           rootSchema,
           _recurseList,
           experimental_defaultFormStateBehavior,
           required
-        }));
-        // then fill up the rest with either the item default or empty, up to minItems
-        return defaultEntries.concat(fillerEntries);
-      }
+        })
+      );
+      return defaultEntries.concat(fillerEntries);
+    }
   }
   return defaults;
 }
-/** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
- * computed to have defaults provided in the `schema`.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param theSchema - The schema for which the default state is desired
- * @param [formData] - The current formData, if any, onto which to provide any missing defaults
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
- *          If "excludeObjectChildren", cause undefined values for this object and pass `includeUndefinedValues` as
- *          false when computing defaults for any nested object properties.
- * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
- * @returns - The resulting `formData` with all the defaults provided
- */
 function getDefaultFormState(validator, theSchema, formData, rootSchema, includeUndefinedValues = false, experimental_defaultFormStateBehavior) {
   if (!isObject(theSchema)) {
-    throw new Error('Invalid schema: ' + theSchema);
+    throw new Error("Invalid schema: " + theSchema);
   }
   const schema = retrieveSchema(validator, theSchema, rootSchema, formData);
   const defaults = computeDefaults(validator, schema, {
@@ -1525,13 +1055,10 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
     experimental_defaultFormStateBehavior,
     rawFormData: formData
   });
-  if (formData === undefined || formData === null || typeof formData === 'number' && isNaN(formData)) {
-    // No form data? Use schema defaults.
+  if (formData === void 0 || formData === null || typeof formData === "number" && isNaN(formData)) {
     return defaults;
   }
-  const {
-    mergeExtraDefaults
-  } = (experimental_defaultFormStateBehavior === null || experimental_defaultFormStateBehavior === void 0 ? void 0 : experimental_defaultFormStateBehavior.arrayMinItems) || {};
+  const { mergeExtraDefaults } = experimental_defaultFormStateBehavior?.arrayMinItems || {};
   if (isObject(formData)) {
     return mergeDefaultsWithFormData(defaults, formData, mergeExtraDefaults);
   }
@@ -1541,62 +1068,40 @@ function getDefaultFormState(validator, theSchema, formData, rootSchema, include
   return formData;
 }
 
-/** Checks to see if the `uiSchema` contains the `widget` field and that the widget is not `hidden`
- *
- * @param uiSchema - The UI Schema from which to detect if it is customized
- * @returns - True if the `uiSchema` describes a custom widget, false otherwise
- */
+// src/isCustomWidget.ts
 function isCustomWidget(uiSchema = {}) {
   return (
     // TODO: Remove the `&& uiSchema['ui:widget'] !== 'hidden'` once we support hidden widgets for arrays.
     // https://rjsf-team.github.io/react-jsonschema-form/docs/usage/widgets/#hidden-widgets
-    'widget' in getUiOptions(uiSchema) && getUiOptions(uiSchema)['widget'] !== 'hidden'
+    "widget" in getUiOptions(uiSchema) && getUiOptions(uiSchema)["widget"] !== "hidden"
   );
 }
 
-/** Checks to see if the `schema` and `uiSchema` combination represents an array of files
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which check for array of files flag is desired
- * @param [uiSchema={}] - The UI schema from which to check the widget
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @returns - True if schema/uiSchema contains an array of files, otherwise false
- */
+// src/schema/isFilesArray.ts
 function isFilesArray(validator, schema, uiSchema = {}, rootSchema) {
-  if (uiSchema[UI_WIDGET_KEY] === 'files') {
+  if (uiSchema[UI_WIDGET_KEY] === "files") {
     return true;
   }
   if (schema.items) {
     const itemsSchema = retrieveSchema(validator, schema.items, rootSchema);
-    return itemsSchema.type === 'string' && itemsSchema.format === 'data-url';
+    return itemsSchema.type === "string" && itemsSchema.format === "data-url";
   }
   return false;
 }
 
-/** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
- * should be displayed in a UI.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which the display label flag is desired
- * @param [uiSchema={}] - The UI schema from which to derive potentially displayable information
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
- * @returns - True if the label should be displayed or false if it should not
- */
+// src/schema/getDisplayLabel.ts
 function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOptions) {
   const uiOptions = getUiOptions(uiSchema, globalOptions);
-  const {
-    label = true
-  } = uiOptions;
+  const { label = true } = uiOptions;
   let displayLabel = !!label;
   const schemaType = getSchemaType(schema);
-  if (schemaType === 'array') {
+  if (schemaType === "array") {
     displayLabel = isMultiSelect(validator, schema, rootSchema) || isFilesArray(validator, schema, uiSchema, rootSchema) || isCustomWidget(uiSchema);
   }
-  if (schemaType === 'object') {
+  if (schemaType === "object") {
     displayLabel = false;
   }
-  if (schemaType === 'boolean' && !uiSchema[UI_WIDGET_KEY]) {
+  if (schemaType === "boolean" && !uiSchema[UI_WIDGET_KEY]) {
     displayLabel = false;
   }
   if (uiSchema[UI_FIELD_KEY]) {
@@ -1605,152 +1110,81 @@ function getDisplayLabel(validator, schema, uiSchema = {}, rootSchema, globalOpt
   return displayLabel;
 }
 
-/** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the
- * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
- * `validator.toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then
- * `validationData` is returned.
- *
- * @param validator - The validator used to convert an ErrorSchema to a list of errors
- * @param validationData - The current `ValidationData` into which to merge the additional errors
- * @param [additionalErrorSchema] - The additional set of errors in an `ErrorSchema`
- * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
- * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
- *        removed in the next major release.
- */
+// src/schema/mergeValidationData.ts
+import isEmpty2 from "lodash/isEmpty";
 function mergeValidationData(validator, validationData, additionalErrorSchema) {
   if (!additionalErrorSchema) {
     return validationData;
   }
-  const {
-    errors: oldErrors,
-    errorSchema: oldErrorSchema
-  } = validationData;
+  const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = validator.toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!isEmpty(oldErrorSchema)) {
+  if (!isEmpty2(oldErrorSchema)) {
     errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
     errors = [...oldErrors].concat(errors);
   }
-  return {
-    errorSchema,
-    errors
-  };
+  return { errorSchema, errors };
 }
 
-const NO_VALUE = /*#__PURE__*/Symbol('no Value');
-/** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the new
- * schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the nature
- * of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the old schema
- * that are non-existent in the new schema are set to `undefined`. The data sanitization process has the following flow:
- *
- * - If the new schema is an object that contains a `properties` object then:
- *   - Create a `removeOldSchemaData` object, setting each key in the `oldSchema.properties` having `data` to undefined
- *   - Create an empty `nestedData` object for use in the key filtering below:
- *   - Iterate over each key in the `newSchema.properties` as follows:
- *     - Get the `formValue` of the key from the `data`
- *     - Get the `oldKeySchema` and `newKeyedSchema` for the key, defaulting to `{}` when it doesn't exist
- *     - Retrieve the schema for any refs within each `oldKeySchema` and/or `newKeySchema`
- *     - Get the types of the old and new keyed schemas and if the old doesn't exist or the old & new are the same then:
- *       - If `removeOldSchemaData` has an entry for the key, delete it since the new schema has the same property
- *       - If type of the key in the new schema is `object`:
- *         - Store the value from the recursive `sanitizeDataForNewSchema` call in `nestedData[key]`
- *       - Otherwise, check for default or const values:
- *         - Get the old and new `default` values from the schema and check:
- *           - If the new `default` value does not match the form value:
- *             - If the old `default` value DOES match the form value, then:
- *               - Replace `removeOldSchemaData[key]` with the new `default`
- *               - Otherwise, if the new schema is `readOnly` then replace `removeOldSchemaData[key]` with undefined
- *         - Get the old and new `const` values from the schema and check:
- *           - If the new `const` value does not match the form value:
- *           - If the old `const` value DOES match the form value, then:
- *             - Replace `removeOldSchemaData[key]` with the new `const`
- *             - Otherwise, replace `removeOldSchemaData[key]` with undefined
- *   - Once all keys have been processed, return an object built as follows:
- *     - `{ ...removeOldSchemaData, ...nestedData, ...pick(data, keysToKeep) }`
- * - If the new and old schema types are array and the `data` is an array then:
- *   - If the type of the old and new schema `items` are a non-array objects:
- *     - Retrieve the schema for any refs within each `oldKeySchema.items` and/or `newKeySchema.items`
- *     - If the `type`s of both items are the same (or the old does not have a type):
- *       - If the type is "object", then:
- *         - For each element in the `data` recursively sanitize the data, stopping at `maxItems` if specified
- *       - Otherwise, just return the `data` removing any values after `maxItems` if it is set
- *   - If the type of the old and new schema `items` are booleans of the same value, return `data` as is
- * - Otherwise return `undefined`
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param rootSchema - The root JSON schema of the entire form
- * @param [newSchema] - The new schema for which the data is being sanitized
- * @param [oldSchema] - The old schema from which the data originated
- * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
- * @returns - The new form data, with all the fields uniquely associated with the old schema set
- *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
- */
+// src/schema/sanitizeDataForNewSchema.ts
+import get7 from "lodash/get";
+import has3 from "lodash/has";
+var NO_VALUE = Symbol("no Value");
 function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, data = {}) {
-  // By default, we will clear the form data
   let newFormData;
-  // If the new schema is of type object and that object contains a list of properties
-  if (has(newSchema, PROPERTIES_KEY)) {
-    // Create an object containing root-level keys in the old schema, setting each key to undefined to remove the data
+  if (has3(newSchema, PROPERTIES_KEY)) {
     const removeOldSchemaData = {};
-    if (has(oldSchema, PROPERTIES_KEY)) {
-      const properties = get(oldSchema, PROPERTIES_KEY, {});
-      Object.keys(properties).forEach(key => {
-        if (has(data, key)) {
-          removeOldSchemaData[key] = undefined;
+    if (has3(oldSchema, PROPERTIES_KEY)) {
+      const properties = get7(oldSchema, PROPERTIES_KEY, {});
+      Object.keys(properties).forEach((key) => {
+        if (has3(data, key)) {
+          removeOldSchemaData[key] = void 0;
         }
       });
     }
-    const keys = Object.keys(get(newSchema, PROPERTIES_KEY, {}));
-    // Create a place to store nested data that will be a side-effect of the filter
+    const keys = Object.keys(get7(newSchema, PROPERTIES_KEY, {}));
     const nestedData = {};
-    keys.forEach(key => {
-      const formValue = get(data, key);
-      let oldKeyedSchema = get(oldSchema, [PROPERTIES_KEY, key], {});
-      let newKeyedSchema = get(newSchema, [PROPERTIES_KEY, key], {});
-      // Resolve the refs if they exist
-      if (has(oldKeyedSchema, REF_KEY)) {
+    keys.forEach((key) => {
+      const formValue = get7(data, key);
+      let oldKeyedSchema = get7(oldSchema, [PROPERTIES_KEY, key], {});
+      let newKeyedSchema = get7(newSchema, [PROPERTIES_KEY, key], {});
+      if (has3(oldKeyedSchema, REF_KEY)) {
         oldKeyedSchema = retrieveSchema(validator, oldKeyedSchema, rootSchema, formValue);
       }
-      if (has(newKeyedSchema, REF_KEY)) {
+      if (has3(newKeyedSchema, REF_KEY)) {
         newKeyedSchema = retrieveSchema(validator, newKeyedSchema, rootSchema, formValue);
       }
-      // Now get types and see if they are the same
-      const oldSchemaTypeForKey = get(oldKeyedSchema, 'type');
-      const newSchemaTypeForKey = get(newKeyedSchema, 'type');
-      // Check if the old option has the same key with the same type
+      const oldSchemaTypeForKey = get7(oldKeyedSchema, "type");
+      const newSchemaTypeForKey = get7(newKeyedSchema, "type");
       if (!oldSchemaTypeForKey || oldSchemaTypeForKey === newSchemaTypeForKey) {
-        if (has(removeOldSchemaData, key)) {
-          // SIDE-EFFECT: remove the undefined value for a key that has the same type between the old and new schemas
+        if (has3(removeOldSchemaData, key)) {
           delete removeOldSchemaData[key];
         }
-        // If it is an object, we'll recurse and store the resulting sanitized data for the key
-        if (newSchemaTypeForKey === 'object' || newSchemaTypeForKey === 'array' && Array.isArray(formValue)) {
-          // SIDE-EFFECT: process the new schema type of object recursively to save iterations
-          const itemData = sanitizeDataForNewSchema(validator, rootSchema, newKeyedSchema, oldKeyedSchema, formValue);
-          if (itemData !== undefined || newSchemaTypeForKey === 'array') {
-            // only put undefined values for the array type and not the object type
+        if (newSchemaTypeForKey === "object" || newSchemaTypeForKey === "array" && Array.isArray(formValue)) {
+          const itemData = sanitizeDataForNewSchema(
+            validator,
+            rootSchema,
+            newKeyedSchema,
+            oldKeyedSchema,
+            formValue
+          );
+          if (itemData !== void 0 || newSchemaTypeForKey === "array") {
             nestedData[key] = itemData;
           }
         } else {
-          // Ok, the non-object types match, let's make sure that a default or a const of a different value is replaced
-          // with the new default or const. This allows the case where two schemas differ that only by the default/const
-          // value to be properly selected
-          const newOptionDefault = get(newKeyedSchema, 'default', NO_VALUE);
-          const oldOptionDefault = get(oldKeyedSchema, 'default', NO_VALUE);
+          const newOptionDefault = get7(newKeyedSchema, "default", NO_VALUE);
+          const oldOptionDefault = get7(oldKeyedSchema, "default", NO_VALUE);
           if (newOptionDefault !== NO_VALUE && newOptionDefault !== formValue) {
             if (oldOptionDefault === formValue) {
-              // If the old default matches the formValue, we'll update the new value to match the new default
               removeOldSchemaData[key] = newOptionDefault;
-            } else if (get(newKeyedSchema, 'readOnly') === true) {
-              // If the new schema has the default set to read-only, treat it like a const and remove the value
-              removeOldSchemaData[key] = undefined;
+            } else if (get7(newKeyedSchema, "readOnly") === true) {
+              removeOldSchemaData[key] = void 0;
             }
           }
-          const newOptionConst = get(newKeyedSchema, 'const', NO_VALUE);
-          const oldOptionConst = get(oldKeyedSchema, 'const', NO_VALUE);
+          const newOptionConst = get7(newKeyedSchema, "const", NO_VALUE);
+          const oldOptionConst = get7(oldKeyedSchema, "const", NO_VALUE);
           if (newOptionConst !== NO_VALUE && newOptionConst !== formValue) {
-            // Since this is a const, if the old value matches, replace the value with the new const otherwise clear it
-            removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : undefined;
+            removeOldSchemaData[key] = oldOptionConst === formValue ? newOptionConst : void 0;
           }
         }
       }
@@ -1760,29 +1194,30 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
       ...removeOldSchemaData,
       ...nestedData
     };
-    // First apply removing the old schema data, then apply the nested data, then apply the old data keys to keep
-  } else if (get(oldSchema, 'type') === 'array' && get(newSchema, 'type') === 'array' && Array.isArray(data)) {
-    let oldSchemaItems = get(oldSchema, 'items');
-    let newSchemaItems = get(newSchema, 'items');
-    // If any of the array types `items` are arrays (remember arrays are objects) then we'll just drop the data
-    // Eventually, we may want to deal with when either of the `items` are arrays since those tuple validations
-    if (typeof oldSchemaItems === 'object' && typeof newSchemaItems === 'object' && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
-      if (has(oldSchemaItems, REF_KEY)) {
+  } else if (get7(oldSchema, "type") === "array" && get7(newSchema, "type") === "array" && Array.isArray(data)) {
+    let oldSchemaItems = get7(oldSchema, "items");
+    let newSchemaItems = get7(newSchema, "items");
+    if (typeof oldSchemaItems === "object" && typeof newSchemaItems === "object" && !Array.isArray(oldSchemaItems) && !Array.isArray(newSchemaItems)) {
+      if (has3(oldSchemaItems, REF_KEY)) {
         oldSchemaItems = retrieveSchema(validator, oldSchemaItems, rootSchema, data);
       }
-      if (has(newSchemaItems, REF_KEY)) {
+      if (has3(newSchemaItems, REF_KEY)) {
         newSchemaItems = retrieveSchema(validator, newSchemaItems, rootSchema, data);
       }
-      // Now get types and see if they are the same
-      const oldSchemaType = get(oldSchemaItems, 'type');
-      const newSchemaType = get(newSchemaItems, 'type');
-      // Check if the old option has the same key with the same type
+      const oldSchemaType = get7(oldSchemaItems, "type");
+      const newSchemaType = get7(newSchemaItems, "type");
       if (!oldSchemaType || oldSchemaType === newSchemaType) {
-        const maxItems = get(newSchema, 'maxItems', -1);
-        if (newSchemaType === 'object') {
+        const maxItems = get7(newSchema, "maxItems", -1);
+        if (newSchemaType === "object") {
           newFormData = data.reduce((newValue, aValue) => {
-            const itemValue = sanitizeDataForNewSchema(validator, rootSchema, newSchemaItems, oldSchemaItems, aValue);
-            if (itemValue !== undefined && (maxItems < 0 || newValue.length < maxItems)) {
+            const itemValue = sanitizeDataForNewSchema(
+              validator,
+              rootSchema,
+              newSchemaItems,
+              oldSchemaItems,
+              aValue
+            );
+            if (itemValue !== void 0 && (maxItems < 0 || newValue.length < maxItems)) {
               newValue.push(itemValue);
             }
             return newValue;
@@ -1791,92 +1226,92 @@ function sanitizeDataForNewSchema(validator, rootSchema, newSchema, oldSchema, d
           newFormData = maxItems > 0 && data.length > maxItems ? data.slice(0, maxItems) : data;
         }
       }
-    } else if (typeof oldSchemaItems === 'boolean' && typeof newSchemaItems === 'boolean' && oldSchemaItems === newSchemaItems) {
-      // If they are both booleans and have the same value just return the data as is otherwise fall-thru to undefined
+    } else if (typeof oldSchemaItems === "boolean" && typeof newSchemaItems === "boolean" && oldSchemaItems === newSchemaItems) {
       newFormData = data;
     }
-    // Also probably want to deal with `prefixItems` as tuples with the latest 2020 draft
   }
-
   return newFormData;
 }
 
-/** An internal helper that generates an `IdSchema` object for the `schema`, recursively with protection against
- * infinite recursion
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which the `IdSchema` is desired
- * @param idPrefix - The prefix to use for the id
- * @param idSeparator - The separator to use for the path segments in the id
- * @param [id] - The base id for the schema
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
- * @returns - The `IdSchema` object for the `schema`
- */
+// src/schema/toIdSchema.ts
+import get8 from "lodash/get";
+import isEqual from "lodash/isEqual";
 function toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList = []) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex(item => isEqual(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual(item, _schema));
     if (sameSchemaIndex === -1) {
-      return toIdSchemaInternal(validator, _schema, idPrefix, idSeparator, id, rootSchema, formData, _recurseList.concat(_schema));
+      return toIdSchemaInternal(
+        validator,
+        _schema,
+        idPrefix,
+        idSeparator,
+        id,
+        rootSchema,
+        formData,
+        _recurseList.concat(_schema)
+      );
     }
   }
-  if (ITEMS_KEY in schema && !get(schema, [ITEMS_KEY, REF_KEY])) {
-    return toIdSchemaInternal(validator, get(schema, ITEMS_KEY), idPrefix, idSeparator, id, rootSchema, formData, _recurseList);
+  if (ITEMS_KEY in schema && !get8(schema, [ITEMS_KEY, REF_KEY])) {
+    return toIdSchemaInternal(
+      validator,
+      get8(schema, ITEMS_KEY),
+      idPrefix,
+      idSeparator,
+      id,
+      rootSchema,
+      formData,
+      _recurseList
+    );
   }
   const $id = id || idPrefix;
-  const idSchema = {
-    $id
-  };
-  if (getSchemaType(schema) === 'object' && PROPERTIES_KEY in schema) {
+  const idSchema = { $id };
+  if (getSchemaType(schema) === "object" && PROPERTIES_KEY in schema) {
     for (const name in schema.properties) {
-      const field = get(schema, [PROPERTIES_KEY, name]);
+      const field = get8(schema, [PROPERTIES_KEY, name]);
       const fieldId = idSchema[ID_KEY] + idSeparator + name;
-      idSchema[name] = toIdSchemaInternal(validator, isObject(field) ? field : {}, idPrefix, idSeparator, fieldId, rootSchema,
-      // It's possible that formData is not an object -- this can happen if an
-      // array item has just been added, but not populated with data yet
-      get(formData, [name]), _recurseList);
+      idSchema[name] = toIdSchemaInternal(
+        validator,
+        isObject(field) ? field : {},
+        idPrefix,
+        idSeparator,
+        fieldId,
+        rootSchema,
+        // It's possible that formData is not an object -- this can happen if an
+        // array item has just been added, but not populated with data yet
+        get8(formData, [name]),
+        _recurseList
+      );
     }
   }
   return idSchema;
 }
-/** Generates an `IdSchema` object for the `schema`, recursively
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which the `IdSchema` is desired
- * @param [id] - The base id for the schema
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @param [idPrefix='root'] - The prefix to use for the id
- * @param [idSeparator='_'] - The separator to use for the path segments in the id
- * @returns - The `IdSchema` object for the `schema`
- */
-function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = 'root', idSeparator = '_') {
+function toIdSchema(validator, schema, id, rootSchema, formData, idPrefix = "root", idSeparator = "_") {
   return toIdSchemaInternal(validator, schema, idPrefix, idSeparator, id, rootSchema, formData);
 }
 
-/** An internal helper that generates an `PathSchema` object for the `schema`, recursively with protection against
- * infinite recursion
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which the `PathSchema` is desired
- * @param [name=''] - The base name for the schema
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @param [_recurseList=[]] - The list of retrieved schemas currently being recursed, used to prevent infinite recursion
- * @returns - The `PathSchema` object for the `schema`
- */
+// src/schema/toPathSchema.ts
+import get9 from "lodash/get";
+import isEqual2 from "lodash/isEqual";
+import set2 from "lodash/set";
 function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _recurseList = []) {
   if (REF_KEY in schema || DEPENDENCIES_KEY in schema || ALL_OF_KEY in schema) {
     const _schema = retrieveSchema(validator, schema, rootSchema, formData);
-    const sameSchemaIndex = _recurseList.findIndex(item => isEqual(item, _schema));
+    const sameSchemaIndex = _recurseList.findIndex((item) => isEqual2(item, _schema));
     if (sameSchemaIndex === -1) {
-      return toPathSchemaInternal(validator, _schema, name, rootSchema, formData, _recurseList.concat(_schema));
+      return toPathSchemaInternal(
+        validator,
+        _schema,
+        name,
+        rootSchema,
+        formData,
+        _recurseList.concat(_schema)
+      );
     }
   }
   let pathSchema = {
-    [NAME_KEY]: name.replace(/^\./, '')
+    [NAME_KEY]: name.replace(/^\./, "")
   };
   if (ONE_OF_KEY in schema || ANY_OF_KEY in schema) {
     const xxxOf = ONE_OF_KEY in schema ? schema.oneOf : schema.anyOf;
@@ -1889,71 +1324,68 @@ function toPathSchemaInternal(validator, schema, name, rootSchema, formData, _re
     };
   }
   if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
-    set(pathSchema, RJSF_ADDITONAL_PROPERTIES_FLAG, true);
+    set2(pathSchema, RJSF_ADDITONAL_PROPERTIES_FLAG, true);
   }
   if (ITEMS_KEY in schema && Array.isArray(formData)) {
     formData.forEach((element, i) => {
-      pathSchema[i] = toPathSchemaInternal(validator, schema.items, `${name}.${i}`, rootSchema, element, _recurseList);
+      pathSchema[i] = toPathSchemaInternal(
+        validator,
+        schema.items,
+        `${name}.${i}`,
+        rootSchema,
+        element,
+        _recurseList
+      );
     });
   } else if (PROPERTIES_KEY in schema) {
     for (const property in schema.properties) {
-      const field = get(schema, [PROPERTIES_KEY, property]);
-      pathSchema[property] = toPathSchemaInternal(validator, field, `${name}.${property}`, rootSchema,
-      // It's possible that formData is not an object -- this can happen if an
-      // array item has just been added, but not populated with data yet
-      get(formData, [property]), _recurseList);
+      const field = get9(schema, [PROPERTIES_KEY, property]);
+      pathSchema[property] = toPathSchemaInternal(
+        validator,
+        field,
+        `${name}.${property}`,
+        rootSchema,
+        // It's possible that formData is not an object -- this can happen if an
+        // array item has just been added, but not populated with data yet
+        get9(formData, [property]),
+        _recurseList
+      );
     }
   }
   return pathSchema;
 }
-/** Generates an `PathSchema` object for the `schema`, recursively
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which the `PathSchema` is desired
- * @param [name=''] - The base name for the schema
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The `PathSchema` object for the `schema`
- */
-function toPathSchema(validator, schema, name = '', rootSchema, formData) {
+function toPathSchema(validator, schema, name = "", rootSchema, formData) {
   return toPathSchemaInternal(validator, schema, name, rootSchema, formData);
 }
 
-/** The `SchemaUtils` class provides a wrapper around the publicly exported APIs in the `utils/schema` directory such
- * that one does not have to explicitly pass the `validator`, `rootSchema`, or `experimental_defaultFormStateBehavior` to each method.
- * Since these generally do not change across a `Form`, this allows for providing a simplified set of APIs to the
- * `@rjsf/core` components and the various themes as well. This class implements the `SchemaUtilsType` interface.
- */
-class SchemaUtils {
-  /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
-   *
-   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
-   * @param rootSchema - The root schema that will be forwarded to all the APIs
-   * @param experimental_defaultFormStateBehavior - Configuration flags to allow users to override default form state behavior
+// src/createSchemaUtils.ts
+var SchemaUtils = class {
+  /** Constructs the `SchemaUtils` instance with the given `validator` and `rootSchema` stored as instance variables
+   *
+   * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
+   * @param rootSchema - The root schema that will be forwarded to all the APIs
+   * @param experimental_defaultFormStateBehavior - Configuration flags to allow users to override default form state behavior
    */
   constructor(validator, rootSchema, experimental_defaultFormStateBehavior) {
-    this.rootSchema = void 0;
-    this.validator = void 0;
-    this.experimental_defaultFormStateBehavior = void 0;
     this.rootSchema = rootSchema;
     this.validator = validator;
     this.experimental_defaultFormStateBehavior = experimental_defaultFormStateBehavior;
   }
-  /** Returns the `ValidatorType` in the `SchemaUtilsType`
-   *
-   * @returns - The `ValidatorType`
+  /** Returns the `ValidatorType` in the `SchemaUtilsType`
+   *
+   * @returns - The `ValidatorType`
    */
   getValidator() {
     return this.validator;
   }
-  /** Determines whether either the `validator` and `rootSchema` differ from the ones associated with this instance of
-   * the `SchemaUtilsType`. If either `validator` or `rootSchema` are falsy, then return false to prevent the creation
-   * of a new `SchemaUtilsType` with incomplete properties.
-   *
-   * @param validator - An implementation of the `ValidatorType` interface that will be compared against the current one
-   * @param rootSchema - The root schema that will be compared against the current one
-   * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
-   * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
+  /** Determines whether either the `validator` and `rootSchema` differ from the ones associated with this instance of
+   * the `SchemaUtilsType`. If either `validator` or `rootSchema` are falsy, then return false to prevent the creation
+   * of a new `SchemaUtilsType` with incomplete properties.
+   *
+   * @param validator - An implementation of the `ValidatorType` interface that will be compared against the current one
+   * @param rootSchema - The root schema that will be compared against the current one
+   * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
+   * @returns - True if the `SchemaUtilsType` differs from the given `validator` or `rootSchema`
    */
   doesSchemaUtilsDiffer(validator, rootSchema, experimental_defaultFormStateBehavior = {}) {
     if (!validator || !rootSchema) {
@@ -1961,411 +1393,334 @@ class SchemaUtils {
     }
     return this.validator !== validator || !deepEquals(this.rootSchema, rootSchema) || !deepEquals(this.experimental_defaultFormStateBehavior, experimental_defaultFormStateBehavior);
   }
-  /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
-   * computed to have defaults provided in the `schema`.
-   *
-   * @param schema - The schema for which the default state is desired
-   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
-   * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
-   *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
-   *          object properties.
-   * @returns - The resulting `formData` with all the defaults provided
+  /** Returns the superset of `formData` that includes the given set updated to include any missing fields that have
+   * computed to have defaults provided in the `schema`.
+   *
+   * @param schema - The schema for which the default state is desired
+   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+   * @param [includeUndefinedValues=false] - Optional flag, if true, cause undefined values to be added as defaults.
+   *          If "excludeObjectChildren", pass `includeUndefinedValues` as false when computing defaults for any nested
+   *          object properties.
+   * @returns - The resulting `formData` with all the defaults provided
    */
   getDefaultFormState(schema, formData, includeUndefinedValues = false) {
-    return getDefaultFormState(this.validator, schema, formData, this.rootSchema, includeUndefinedValues, this.experimental_defaultFormStateBehavior);
-  }
-  /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
-   * should be displayed in a UI.
-   *
-   * @param schema - The schema for which the display label flag is desired
-   * @param [uiSchema] - The UI schema from which to derive potentially displayable information
-   * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
-   * @returns - True if the label should be displayed or false if it should not
+    return getDefaultFormState(
+      this.validator,
+      schema,
+      formData,
+      this.rootSchema,
+      includeUndefinedValues,
+      this.experimental_defaultFormStateBehavior
+    );
+  }
+  /** Determines whether the combination of `schema` and `uiSchema` properties indicates that the label for the `schema`
+   * should be displayed in a UI.
+   *
+   * @param schema - The schema for which the display label flag is desired
+   * @param [uiSchema] - The UI schema from which to derive potentially displayable information
+   * @param [globalOptions={}] - The optional Global UI Schema from which to get any fallback `xxx` options
+   * @returns - True if the label should be displayed or false if it should not
    */
   getDisplayLabel(schema, uiSchema, globalOptions) {
     return getDisplayLabel(this.validator, schema, uiSchema, this.rootSchema, globalOptions);
   }
-  /** Determines which of the given `options` provided most closely matches the `formData`.
-   * Returns the index of the option that is valid and is the closest match, or 0 if there is no match.
-   *
-   * The closest match is determined using the number of matching properties, and more heavily favors options with
-   * matching readOnly, default, or const values.
-   *
-   * @param formData - The form data associated with the schema
-   * @param options - The list of options that can be selected from
-   * @param [selectedOption] - The index of the currently selected option, defaulted to -1 if not specified
-   * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
-   *          determine which option is selected
-   * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
+  /** Determines which of the given `options` provided most closely matches the `formData`.
+   * Returns the index of the option that is valid and is the closest match, or 0 if there is no match.
+   *
+   * The closest match is determined using the number of matching properties, and more heavily favors options with
+   * matching readOnly, default, or const values.
+   *
+   * @param formData - The form data associated with the schema
+   * @param options - The list of options that can be selected from
+   * @param [selectedOption] - The index of the currently selected option, defaulted to -1 if not specified
+   * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
+   *          determine which option is selected
+   * @returns - The index of the option that is the closest match to the `formData` or the `selectedOption` if no match
    */
   getClosestMatchingOption(formData, options, selectedOption, discriminatorField) {
-    return getClosestMatchingOption(this.validator, this.rootSchema, formData, options, selectedOption, discriminatorField);
-  }
-  /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
-   * Always returns the first option if there is nothing that matches.
-   *
-   * @param formData - The current formData, if any, used to figure out a match
-   * @param options - The list of options to find a matching options from
-   * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
-   *          determine which option is selected
-   * @returns - The firstindex of the matched option or 0 if none is available
+    return getClosestMatchingOption(
+      this.validator,
+      this.rootSchema,
+      formData,
+      options,
+      selectedOption,
+      discriminatorField
+    );
+  }
+  /** Given the `formData` and list of `options`, attempts to find the index of the first option that matches the data.
+   * Always returns the first option if there is nothing that matches.
+   *
+   * @param formData - The current formData, if any, used to figure out a match
+   * @param options - The list of options to find a matching options from
+   * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
+   *          determine which option is selected
+   * @returns - The firstindex of the matched option or 0 if none is available
    */
   getFirstMatchingOption(formData, options, discriminatorField) {
     return getFirstMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
   }
-  /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
-   * Deprecated, use `getFirstMatchingOption()` instead.
-   *
-   * @param formData - The current formData, if any, onto which to provide any missing defaults
-   * @param options - The list of options to find a matching options from
-   * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
-   *          determine which option is selected
-   * @returns - The index of the matched option or 0 if none is available
-   * @deprecated
+  /** Given the `formData` and list of `options`, attempts to find the index of the option that best matches the data.
+   * Deprecated, use `getFirstMatchingOption()` instead.
+   *
+   * @param formData - The current formData, if any, onto which to provide any missing defaults
+   * @param options - The list of options to find a matching options from
+   * @param [discriminatorField] - The optional name of the field within the options object whose value is used to
+   *          determine which option is selected
+   * @returns - The index of the matched option or 0 if none is available
+   * @deprecated
    */
   getMatchingOption(formData, options, discriminatorField) {
     return getMatchingOption(this.validator, formData, options, this.rootSchema, discriminatorField);
   }
-  /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
-   *
-   * @param schema - The schema for which check for array of files flag is desired
-   * @param [uiSchema] - The UI schema from which to check the widget
-   * @returns - True if schema/uiSchema contains an array of files, otherwise false
+  /** Checks to see if the `schema` and `uiSchema` combination represents an array of files
+   *
+   * @param schema - The schema for which check for array of files flag is desired
+   * @param [uiSchema] - The UI schema from which to check the widget
+   * @returns - True if schema/uiSchema contains an array of files, otherwise false
    */
   isFilesArray(schema, uiSchema) {
     return isFilesArray(this.validator, schema, uiSchema, this.rootSchema);
   }
-  /** Checks to see if the `schema` combination represents a multi-select
-   *
-   * @param schema - The schema for which check for a multi-select flag is desired
-   * @returns - True if schema contains a multi-select, otherwise false
+  /** Checks to see if the `schema` combination represents a multi-select
+   *
+   * @param schema - The schema for which check for a multi-select flag is desired
+   * @returns - True if schema contains a multi-select, otherwise false
    */
   isMultiSelect(schema) {
     return isMultiSelect(this.validator, schema, this.rootSchema);
   }
-  /** Checks to see if the `schema` combination represents a select
-   *
-   * @param schema - The schema for which check for a select flag is desired
-   * @returns - True if schema contains a select, otherwise false
+  /** Checks to see if the `schema` combination represents a select
+   *
+   * @param schema - The schema for which check for a select flag is desired
+   * @returns - True if schema contains a select, otherwise false
    */
   isSelect(schema) {
     return isSelect(this.validator, schema, this.rootSchema);
   }
-  /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in
-   * the two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
-   * `getValidator().toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed,
-   * then `validationData` is returned.
-   *
-   * @param validationData - The current `ValidationData` into which to merge the additional errors
-   * @param [additionalErrorSchema] - The additional set of errors
-   * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
-   * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
-   *        removed in the next major release.
+  /** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in
+   * the two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
+   * `getValidator().toErrorList()` onto the `errors` in the `validationData`. If no `additionalErrorSchema` is passed,
+   * then `validationData` is returned.
+   *
+   * @param validationData - The current `ValidationData` into which to merge the additional errors
+   * @param [additionalErrorSchema] - The additional set of errors
+   * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
+   * @deprecated - Use the `validationDataMerge()` function exported from `@rjsf/utils` instead. This function will be
+   *        removed in the next major release.
    */
   mergeValidationData(validationData, additionalErrorSchema) {
     return mergeValidationData(this.validator, validationData, additionalErrorSchema);
   }
-  /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
-   * dependencies resolved and merged into the `schema` given a `rawFormData` that is used to do the potentially
-   * recursive resolution.
-   *
-   * @param schema - The schema for which retrieving a schema is desired
-   * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
-   * @returns - The schema having its conditions, additional properties, references and dependencies resolved
+  /** Retrieves an expanded schema that has had all of its conditions, additional properties, references and
+   * dependencies resolved and merged into the `schema` given a `rawFormData` that is used to do the potentially
+   * recursive resolution.
+   *
+   * @param schema - The schema for which retrieving a schema is desired
+   * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
+   * @returns - The schema having its conditions, additional properties, references and dependencies resolved
    */
   retrieveSchema(schema, rawFormData) {
     return retrieveSchema(this.validator, schema, this.rootSchema, rawFormData);
   }
-  /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the
-   * new schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the
-   * nature of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the
-   * old schemas that are non-existent in the new schema are set to `undefined`.
-   *
-   * @param [newSchema] - The new schema for which the data is being sanitized
-   * @param [oldSchema] - The old schema from which the data originated
-   * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
-   * @returns - The new form data, with all the fields uniquely associated with the old schema set
-   *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
+  /** Sanitize the `data` associated with the `oldSchema` so it is considered appropriate for the `newSchema`. If the
+   * new schema does not contain any properties, then `undefined` is returned to clear all the form data. Due to the
+   * nature of schemas, this sanitization happens recursively for nested objects of data. Also, any properties in the
+   * old schemas that are non-existent in the new schema are set to `undefined`.
+   *
+   * @param [newSchema] - The new schema for which the data is being sanitized
+   * @param [oldSchema] - The old schema from which the data originated
+   * @param [data={}] - The form data associated with the schema, defaulting to an empty object when undefined
+   * @returns - The new form data, with all the fields uniquely associated with the old schema set
+   *      to `undefined`. Will return `undefined` if the new schema is not an object containing properties.
    */
   sanitizeDataForNewSchema(newSchema, oldSchema, data) {
     return sanitizeDataForNewSchema(this.validator, this.rootSchema, newSchema, oldSchema, data);
   }
-  /** Generates an `IdSchema` object for the `schema`, recursively
-   *
-   * @param schema - The schema for which the display label flag is desired
-   * @param [id] - The base id for the schema
-   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
-   * @param [idPrefix='root'] - The prefix to use for the id
-   * @param [idSeparator='_'] - The separator to use for the path segments in the id
-   * @returns - The `IdSchema` object for the `schema`
+  /** Generates an `IdSchema` object for the `schema`, recursively
+   *
+   * @param schema - The schema for which the display label flag is desired
+   * @param [id] - The base id for the schema
+   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+   * @param [idPrefix='root'] - The prefix to use for the id
+   * @param [idSeparator='_'] - The separator to use for the path segments in the id
+   * @returns - The `IdSchema` object for the `schema`
    */
-  toIdSchema(schema, id, formData, idPrefix = 'root', idSeparator = '_') {
+  toIdSchema(schema, id, formData, idPrefix = "root", idSeparator = "_") {
     return toIdSchema(this.validator, schema, id, this.rootSchema, formData, idPrefix, idSeparator);
   }
-  /** Generates an `PathSchema` object for the `schema`, recursively
-   *
-   * @param schema - The schema for which the display label flag is desired
-   * @param [name] - The base name for the schema
-   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
-   * @returns - The `PathSchema` object for the `schema`
+  /** Generates an `PathSchema` object for the `schema`, recursively
+   *
+   * @param schema - The schema for which the display label flag is desired
+   * @param [name] - The base name for the schema
+   * @param [formData] - The current formData, if any, onto which to provide any missing defaults
+   * @returns - The `PathSchema` object for the `schema`
    */
   toPathSchema(schema, name, formData) {
     return toPathSchema(this.validator, schema, name, this.rootSchema, formData);
   }
-}
-/** Creates a `SchemaUtilsType` interface that is based around the given `validator` and `rootSchema` parameters. The
- * resulting interface implementation will forward the `validator` and `rootSchema` to all the wrapped APIs.
- *
- * @param validator - an implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param [experimental_defaultFormStateBehavior] Optional configuration object, if provided, allows users to override default form state behavior
- * @returns - An implementation of a `SchemaUtilsType` interface
- */
+};
 function createSchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior = {}) {
   return new SchemaUtils(validator, rootSchema, experimental_defaultFormStateBehavior);
 }
 
-/** Given the `FileReader.readAsDataURL()` based `dataURI` extracts that data into an actual Blob along with the name
- * of that Blob if provided in the URL. If no name is provided, then the name falls back to `unknown`.
- *
- * @param dataURI - The `DataUrl` potentially containing name and raw data to be converted to a Blob
- * @returns - an object containing a Blob and its name, extracted from the URI
- */
+// src/dataURItoBlob.ts
 function dataURItoBlob(dataURI) {
-  // Split metadata from data
-  const splitted = dataURI.split(',');
-  // Split params
-  const params = splitted[0].split(';');
-  // Get mime-type from params
-  const type = params[0].replace('data:', '');
-  // Filter the name property from params
-  const properties = params.filter(param => {
-    return param.split('=')[0] === 'name';
+  const splitted = dataURI.split(",");
+  const params = splitted[0].split(";");
+  const type = params[0].replace("data:", "");
+  const properties = params.filter((param) => {
+    return param.split("=")[0] === "name";
   });
-  // Look for the name and use unknown if no name property.
   let name;
   if (properties.length !== 1) {
-    name = 'unknown';
+    name = "unknown";
   } else {
-    // Because we filtered out the other property,
-    // we only have the name case here, which we decode to make it human-readable
-    name = decodeURI(properties[0].split('=')[1]);
+    name = decodeURI(properties[0].split("=")[1]);
   }
-  // Built the Uint8Array Blob parameter from the base64 string.
   try {
     const binary = atob(splitted[1]);
     const array = [];
     for (let i = 0; i < binary.length; i++) {
       array.push(binary.charCodeAt(i));
     }
-    // Create the blob object
-    const blob = new window.Blob([new Uint8Array(array)], {
-      type
-    });
-    return {
-      blob,
-      name
-    };
+    const blob = new window.Blob([new Uint8Array(array)], { type });
+    return { blob, name };
   } catch (error) {
-    return {
-      blob: {
-        size: 0,
-        type: error.message
-      },
-      name: dataURI
-    };
+    return { blob: { size: 0, type: error.message }, name: dataURI };
   }
 }
 
-/** Potentially substitutes all replaceable parameters with the associated value(s) from the `params` if available. When
- * a `params` array is provided, each value in the array is used to replace any of the replaceable parameters in the
- * `inputString` using the `%1`, `%2`, etc. replacement specifiers.
- *
- * @param inputString - The string which will be potentially updated with replacement parameters
- * @param params - The optional list of replaceable parameter values to substitute into the english string
- * @returns - The updated string with any replacement specifiers replaced
- */
+// src/replaceStringParameters.ts
 function replaceStringParameters(inputString, params) {
   let output = inputString;
   if (Array.isArray(params)) {
     const parts = output.split(/(%\d)/);
     params.forEach((param, index) => {
-      const partIndex = parts.findIndex(part => part === `%${index + 1}`);
+      const partIndex = parts.findIndex((part) => part === `%${index + 1}`);
       if (partIndex >= 0) {
         parts[partIndex] = param;
       }
     });
-    output = parts.join('');
+    output = parts.join("");
   }
   return output;
 }
 
-/** Translates a `TranslatableString` value `stringToTranslate` into english. When a `params` array is provided, each
- * value in the array is used to replace any of the replaceable parameters in the `stringToTranslate` using the `%1`,
- * `%2`, etc. replacement specifiers.
- *
- * @param stringToTranslate - The `TranslatableString` value to convert to english
- * @param params - The optional list of replaceable parameter values to substitute into the english string
- * @returns - The `stringToTranslate` itself with any replaceable parameter values substituted
- */
+// src/englishStringTranslator.ts
 function englishStringTranslator(stringToTranslate, params) {
   return replaceStringParameters(stringToTranslate, params);
 }
 
-/** Returns the value(s) from `allEnumOptions` at the index(es) provided by `valueIndex`. If `valueIndex` is not an
- * array AND the index is not valid for `allEnumOptions`, `emptyValue` is returned. If `valueIndex` is an array, AND it
- * contains an invalid index, the returned array will have the resulting undefined values filtered out, leaving only
- * valid values or in the worst case, an empty array.
- *
- * @param valueIndex - The index(es) of the value(s) that should be returned
- * @param [allEnumOptions=[]] - The list of all the known enumOptions
- * @param [emptyValue] - The value to return when the non-array `valueIndex` does not refer to a real option
- * @returns - The single or list of values specified by the single or list of indexes if they are valid. Otherwise,
- *        `emptyValue` or an empty list.
- */
+// src/enumOptionsDeselectValue.ts
+import isEqual3 from "lodash/isEqual";
+
+// src/enumOptionsValueForIndex.ts
 function enumOptionsValueForIndex(valueIndex, allEnumOptions = [], emptyValue) {
   if (Array.isArray(valueIndex)) {
-    return valueIndex.map(index => enumOptionsValueForIndex(index, allEnumOptions)).filter(val => val);
+    return valueIndex.map((index2) => enumOptionsValueForIndex(index2, allEnumOptions)).filter((val) => val);
   }
-  // So Number(null) and Number('') both return 0, so use emptyValue for those two values
-  const index = valueIndex === '' || valueIndex === null ? -1 : Number(valueIndex);
+  const index = valueIndex === "" || valueIndex === null ? -1 : Number(valueIndex);
   const option = allEnumOptions[index];
   return option ? option.value : emptyValue;
 }
 
-/** Removes the enum option value at the `valueIndex` from the currently `selected` (list of) value(s). If `selected` is
- * a list, then that list is updated to remove the enum option value with the `valueIndex` in `allEnumOptions`. If it is
- * a single value, then if the enum option value with the `valueIndex` in `allEnumOptions` matches `selected`, undefined
- * is returned, otherwise the `selected` value is returned.
- *
- * @param valueIndex - The index of the value to be removed from the selected list or single value
- * @param selected - The current (list of) selected value(s)
- * @param [allEnumOptions=[]] - The list of all the known enumOptions
- * @returns - The updated `selected` with the enum option value at `valueIndex` in `allEnumOptions` removed from it,
- *        unless `selected` is a single value. In that case, if the `valueIndex` value matches `selected`, returns
- *        undefined, otherwise `selected`.
- */
+// src/enumOptionsDeselectValue.ts
 function enumOptionsDeselectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
   if (Array.isArray(selected)) {
-    return selected.filter(v => !isEqual(v, value));
+    return selected.filter((v) => !isEqual3(v, value));
   }
-  return isEqual(value, selected) ? undefined : selected;
+  return isEqual3(value, selected) ? void 0 : selected;
 }
 
-/** Determines whether the given `value` is (one of) the `selected` value(s).
- *
- * @param value - The value being checked to see if it is selected
- * @param selected - The current selected value or list of values
- * @returns - true if the `value` is one of the `selected` ones, false otherwise
- */
+// src/enumOptionsIsSelected.ts
+import isEqual4 from "lodash/isEqual";
 function enumOptionsIsSelected(value, selected) {
   if (Array.isArray(selected)) {
-    return selected.some(sel => isEqual(sel, value));
-  }
-  return isEqual(selected, value);
-}
-
-/** Returns the index(es) of the options in `allEnumOptions` whose value(s) match the ones in `value`. All the
- * `enumOptions` are filtered based on whether they are a "selected" `value` and the index of each selected one is then
- * stored in an array. If `multiple` is true, that array is returned, otherwise the first element in the array is
- * returned.
- *
- * @param value - The single value or list of values for which indexes are desired
- * @param [allEnumOptions=[]] - The list of all the known enumOptions
- * @param [multiple=false] - Optional flag, if true will return a list of index, otherwise a single one
- * @returns - A single string index for the first `value` in `allEnumOptions`, if not `multiple`. Otherwise, the list
- *        of indexes for (each of) the value(s) in `value`.
- */
+    return selected.some((sel) => isEqual4(sel, value));
+  }
+  return isEqual4(selected, value);
+}
+
+// src/enumOptionsIndexForValue.ts
 function enumOptionsIndexForValue(value, allEnumOptions = [], multiple = false) {
-  const selectedIndexes = allEnumOptions.map((opt, index) => enumOptionsIsSelected(opt.value, value) ? String(index) : undefined).filter(opt => typeof opt !== 'undefined');
+  const selectedIndexes = allEnumOptions.map((opt, index) => enumOptionsIsSelected(opt.value, value) ? String(index) : void 0).filter((opt) => typeof opt !== "undefined");
   if (!multiple) {
     return selectedIndexes[0];
   }
   return selectedIndexes;
 }
 
-/** Add the enum option value at the `valueIndex` to the list of `selected` values in the proper order as defined by
- * `allEnumOptions`
- *
- * @param valueIndex - The index of the value that should be selected
- * @param selected - The current list of selected values
- * @param [allEnumOptions=[]] - The list of all the known enumOptions
- * @returns - The updated list of selected enum values with enum value at the `valueIndex` added to it
- */
+// src/enumOptionsSelectValue.ts
+import { isNil } from "lodash";
 function enumOptionsSelectValue(valueIndex, selected, allEnumOptions = []) {
   const value = enumOptionsValueForIndex(valueIndex, allEnumOptions);
   if (!isNil(value)) {
-    const index = allEnumOptions.findIndex(opt => value === opt.value);
-    const all = allEnumOptions.map(({
-      value: val
-    }) => val);
+    const index = allEnumOptions.findIndex((opt) => value === opt.value);
+    const all = allEnumOptions.map(({ value: val }) => val);
     const updated = selected.slice(0, index).concat(value, selected.slice(index));
-    // As inserting values at predefined index positions doesn't work with empty
-    // arrays, we need to reorder the updated selection to match the initial order
     return updated.sort((a, b) => Number(all.indexOf(a) > all.indexOf(b)));
   }
   return selected;
 }
 
-/** The `ErrorSchemaBuilder<T>` is used to build an `ErrorSchema<T>` since the definition of the `ErrorSchema` type is
- * designed for reading information rather than writing it. Use this class to add, replace or clear errors in an error
- * schema by using either dotted path or an array of path names. Once you are done building the `ErrorSchema`, you can
- * get the result and/or reset all the errors back to an initial set and start again.
- */
-class ErrorSchemaBuilder {
-  /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
-   *
-   * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+// src/ErrorSchemaBuilder.ts
+import cloneDeep from "lodash/cloneDeep";
+import get10 from "lodash/get";
+import set3 from "lodash/set";
+var ErrorSchemaBuilder = class {
+  /** Construct an `ErrorSchemaBuilder` with an optional initial set of errors in an `ErrorSchema`.
+   *
+   * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
    */
   constructor(initialSchema) {
-    /** The error schema being built
-     *
-     * @private
+    /** The error schema being built
+     *
+     * @private
      */
     this.errorSchema = {};
     this.resetAllErrors(initialSchema);
   }
-  /** Returns the `ErrorSchema` that has been updated by the methods of the `ErrorSchemaBuilder`
+  /** Returns the `ErrorSchema` that has been updated by the methods of the `ErrorSchemaBuilder`
    */
   get ErrorSchema() {
     return this.errorSchema;
   }
-  /** Will get an existing `ErrorSchema` at the specified `pathOfError` or create and return one.
-   *
-   * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
-   * @returns - The error block for the given `pathOfError` or the root if not provided
-   * @private
+  /** Will get an existing `ErrorSchema` at the specified `pathOfError` or create and return one.
+   *
+   * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+   * @returns - The error block for the given `pathOfError` or the root if not provided
+   * @private
    */
   getOrCreateErrorBlock(pathOfError) {
-    const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === 'string';
-    let errorBlock = hasPath ? get(this.errorSchema, pathOfError) : this.errorSchema;
+    const hasPath = Array.isArray(pathOfError) && pathOfError.length > 0 || typeof pathOfError === "string";
+    let errorBlock = hasPath ? get10(this.errorSchema, pathOfError) : this.errorSchema;
     if (!errorBlock && pathOfError) {
       errorBlock = {};
-      set(this.errorSchema, pathOfError, errorBlock);
+      set3(this.errorSchema, pathOfError, errorBlock);
     }
     return errorBlock;
   }
-  /** Resets all errors in the `ErrorSchemaBuilder` back to the `initialSchema` if provided, otherwise an empty set.
-   *
-   * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
-   * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+  /** Resets all errors in the `ErrorSchemaBuilder` back to the `initialSchema` if provided, otherwise an empty set.
+   *
+   * @param [initialSchema] - The optional set of initial errors, that will be cloned into the class
+   * @returns - The `ErrorSchemaBuilder` object for chaining purposes
    */
   resetAllErrors(initialSchema) {
     this.errorSchema = initialSchema ? cloneDeep(initialSchema) : {};
     return this;
   }
-  /** Adds the `errorOrList` to the list of errors in the `ErrorSchema` at either the root level or the location within
-   * the schema described by the `pathOfError`. For more information about how to specify the path see the
-   * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
-   *
-   * @param errorOrList - The error or list of errors to add into the `ErrorSchema`
-   * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
-   * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+  /** Adds the `errorOrList` to the list of errors in the `ErrorSchema` at either the root level or the location within
+   * the schema described by the `pathOfError`. For more information about how to specify the path see the
+   * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+   *
+   * @param errorOrList - The error or list of errors to add into the `ErrorSchema`
+   * @param [pathOfError] - The optional path into the `ErrorSchema` at which to add the error(s)
+   * @returns - The `ErrorSchemaBuilder` object for chaining purposes
    */
   addErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    let errorsList = get(errorBlock, ERRORS_KEY);
+    let errorsList = get10(errorBlock, ERRORS_KEY);
     if (!Array.isArray(errorsList)) {
       errorsList = [];
       errorBlock[ERRORS_KEY] = errorsList;
@@ -2377,41 +1732,35 @@ class ErrorSchemaBuilder {
     }
     return this;
   }
-  /** Sets/replaces the `errorOrList` as the error(s) in the `ErrorSchema` at either the root level or the location
-   * within the schema described by the `pathOfError`. For more information about how to specify the path see the
-   * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
-   *
-   * @param errorOrList - The error or list of errors to set into the `ErrorSchema`
-   * @param [pathOfError] - The optional path into the `ErrorSchema` at which to set the error(s)
-   * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+  /** Sets/replaces the `errorOrList` as the error(s) in the `ErrorSchema` at either the root level or the location
+   * within the schema described by the `pathOfError`. For more information about how to specify the path see the
+   * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+   *
+   * @param errorOrList - The error or list of errors to set into the `ErrorSchema`
+   * @param [pathOfError] - The optional path into the `ErrorSchema` at which to set the error(s)
+   * @returns - The `ErrorSchemaBuilder` object for chaining purposes
    */
   setErrors(errorOrList, pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    // Effectively clone the array being given to prevent accidental outside manipulation of the given list
     const listToAdd = Array.isArray(errorOrList) ? [...errorOrList] : [errorOrList];
-    set(errorBlock, ERRORS_KEY, listToAdd);
+    set3(errorBlock, ERRORS_KEY, listToAdd);
     return this;
   }
-  /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by
-   * the `pathOfError`. For more information about how to specify the path see the
-   * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
-   *
-   * @param [pathOfError] - The optional path into the `ErrorSchema` at which to clear the error(s)
-   * @returns - The `ErrorSchemaBuilder` object for chaining purposes
+  /** Clears the error(s) in the `ErrorSchema` at either the root level or the location within the schema described by
+   * the `pathOfError`. For more information about how to specify the path see the
+   * [eslint lodash plugin docs](https://github.com/wix/eslint-plugin-lodash/blob/master/docs/rules/path-style.md).
+   *
+   * @param [pathOfError] - The optional path into the `ErrorSchema` at which to clear the error(s)
+   * @returns - The `ErrorSchemaBuilder` object for chaining purposes
    */
   clearErrors(pathOfError) {
     const errorBlock = this.getOrCreateErrorBlock(pathOfError);
-    set(errorBlock, ERRORS_KEY, []);
+    set3(errorBlock, ERRORS_KEY, []);
     return this;
   }
-}
+};
 
-/** Extracts the range spec information `{ step?: number, min?: number, max?: number }` that can be spread onto an HTML
- * input from the range analog in the schema `{ multipleOf?: number, minimum?: number, maximum?: number }`.
- *
- * @param schema - The schema from which to extract the range spec
- * @returns - A range specification from the schema
- */
+// src/rangeSpec.ts
 function rangeSpec(schema) {
   const spec = {};
   if (schema.multipleOf) {
@@ -2426,37 +1775,23 @@ function rangeSpec(schema) {
   return spec;
 }
 
-/** Using the `schema`, `defaultType` and `options`, extract out the props for the <input> element that make sense.
- *
- * @param schema - The schema for the field provided by the widget
- * @param [defaultType] - The default type, if any, for the field provided by the widget
- * @param [options={}] - The UI Options for the field provided by the widget
- * @param [autoDefaultStepAny=true] - Determines whether to auto-default step=any when the type is number and no step
- * @returns - The extracted `InputPropsType` object
- */
+// src/getInputProps.ts
 function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = true) {
   const inputProps = {
-    type: defaultType || 'text',
+    type: defaultType || "text",
     ...rangeSpec(schema)
   };
-  // If options.inputType is set use that as the input type
   if (options.inputType) {
     inputProps.type = options.inputType;
   } else if (!defaultType) {
-    // If the schema is of type number or integer, set the input type to number
-    if (schema.type === 'number') {
-      inputProps.type = 'number';
-      // Only add step if one isn't already defined and we are auto-defaulting the "any" step
-      if (autoDefaultStepAny && inputProps.step === undefined) {
-        // Setting step to 'any' fixes a bug in Safari where decimals are not
-        // allowed in number inputs
-        inputProps.step = 'any';
+    if (schema.type === "number") {
+      inputProps.type = "number";
+      if (autoDefaultStepAny && inputProps.step === void 0) {
+        inputProps.step = "any";
       }
-    } else if (schema.type === 'integer') {
-      inputProps.type = 'number';
-      // Only add step if one isn't already defined
-      if (inputProps.step === undefined) {
-        // Since this is integer, you always want to step up or down in multiples of 1
+    } else if (schema.type === "integer") {
+      inputProps.type = "number";
+      if (inputProps.step === void 0) {
         inputProps.step = 1;
       }
     }
@@ -2467,45 +1802,27 @@ function getInputProps(schema, defaultType, options = {}, autoDefaultStepAny = t
   return inputProps;
 }
 
-/** The default submit button options, exported for testing purposes
- */
-const DEFAULT_OPTIONS = {
+// src/getSubmitButtonOptions.ts
+var DEFAULT_OPTIONS = {
   props: {
     disabled: false
   },
-  submitText: 'Submit',
+  submitText: "Submit",
   norender: false
 };
-/** Extracts any `ui:submitButtonOptions` from the `uiSchema` and merges them onto the `DEFAULT_OPTIONS`
- *
- * @param [uiSchema={}] - the UI Schema from which to extract submit button props
- * @returns - The merging of the `DEFAULT_OPTIONS` with any custom ones
- */
 function getSubmitButtonOptions(uiSchema = {}) {
   const uiOptions = getUiOptions(uiSchema);
   if (uiOptions && uiOptions[SUBMIT_BTN_OPTIONS_KEY]) {
     const options = uiOptions[SUBMIT_BTN_OPTIONS_KEY];
-    return {
-      ...DEFAULT_OPTIONS,
-      ...options
-    };
+    return { ...DEFAULT_OPTIONS, ...options };
   }
   return DEFAULT_OPTIONS;
 }
 
-/** Returns the template with the given `name` from either the `uiSchema` if it is defined or from the `registry`
- * otherwise. NOTE, since `ButtonTemplates` are not overridden in `uiSchema` only those in the `registry` are returned.
- *
- * @param name - The name of the template to fetch, restricted to the keys of `TemplatesType`
- * @param registry - The `Registry` from which to read the template
- * @param [uiOptions={}] - The `UIOptionsType` from which to read an alternate template
- * @returns - The template from either the `uiSchema` or `registry` for the `name`
- */
+// src/getTemplate.ts
 function getTemplate(name, registry, uiOptions = {}) {
-  const {
-    templates
-  } = registry;
-  if (name === 'ButtonTemplates') {
+  const { templates } = registry;
+  if (name === "ButtonTemplates") {
     return templates[name];
   }
   return (
@@ -2515,112 +1832,88 @@ function getTemplate(name, registry, uiOptions = {}) {
   );
 }
 
-/** The map of schema types to widget type to widget name
- */
-const widgetMap = {
+// src/getWidget.tsx
+import { createElement } from "react";
+import ReactIs from "react-is";
+import get11 from "lodash/get";
+import set4 from "lodash/set";
+import { jsx } from "react/jsx-runtime";
+var widgetMap = {
   boolean: {
-    checkbox: 'CheckboxWidget',
-    radio: 'RadioWidget',
-    select: 'SelectWidget',
-    hidden: 'HiddenWidget'
+    checkbox: "CheckboxWidget",
+    radio: "RadioWidget",
+    select: "SelectWidget",
+    hidden: "HiddenWidget"
   },
   string: {
-    text: 'TextWidget',
-    password: 'PasswordWidget',
-    email: 'EmailWidget',
-    hostname: 'TextWidget',
-    ipv4: 'TextWidget',
-    ipv6: 'TextWidget',
-    uri: 'URLWidget',
-    'data-url': 'FileWidget',
-    radio: 'RadioWidget',
-    select: 'SelectWidget',
-    textarea: 'TextareaWidget',
-    hidden: 'HiddenWidget',
-    date: 'DateWidget',
-    datetime: 'DateTimeWidget',
-    'date-time': 'DateTimeWidget',
-    'alt-date': 'AltDateWidget',
-    'alt-datetime': 'AltDateTimeWidget',
-    time: 'TimeWidget',
-    color: 'ColorWidget',
-    file: 'FileWidget'
+    text: "TextWidget",
+    password: "PasswordWidget",
+    email: "EmailWidget",
+    hostname: "TextWidget",
+    ipv4: "TextWidget",
+    ipv6: "TextWidget",
+    uri: "URLWidget",
+    "data-url": "FileWidget",
+    radio: "RadioWidget",
+    select: "SelectWidget",
+    textarea: "TextareaWidget",
+    hidden: "HiddenWidget",
+    date: "DateWidget",
+    datetime: "DateTimeWidget",
+    "date-time": "DateTimeWidget",
+    "alt-date": "AltDateWidget",
+    "alt-datetime": "AltDateTimeWidget",
+    time: "TimeWidget",
+    color: "ColorWidget",
+    file: "FileWidget"
   },
   number: {
-    text: 'TextWidget',
-    select: 'SelectWidget',
-    updown: 'UpDownWidget',
-    range: 'RangeWidget',
-    radio: 'RadioWidget',
-    hidden: 'HiddenWidget'
+    text: "TextWidget",
+    select: "SelectWidget",
+    updown: "UpDownWidget",
+    range: "RangeWidget",
+    radio: "RadioWidget",
+    hidden: "HiddenWidget"
   },
   integer: {
-    text: 'TextWidget',
-    select: 'SelectWidget',
-    updown: 'UpDownWidget',
-    range: 'RangeWidget',
-    radio: 'RadioWidget',
-    hidden: 'HiddenWidget'
+    text: "TextWidget",
+    select: "SelectWidget",
+    updown: "UpDownWidget",
+    range: "RangeWidget",
+    radio: "RadioWidget",
+    hidden: "HiddenWidget"
   },
   array: {
-    select: 'SelectWidget',
-    checkboxes: 'CheckboxesWidget',
-    files: 'FileWidget',
-    hidden: 'HiddenWidget'
+    select: "SelectWidget",
+    checkboxes: "CheckboxesWidget",
+    files: "FileWidget",
+    hidden: "HiddenWidget"
   }
 };
-/** Wraps the given widget with stateless functional component that will merge any `defaultProps.options` with the
- * `options` that are provided in the props. It will add the wrapper component as a `MergedWidget` property onto the
- * `Widget` so that future attempts to wrap `AWidget` will return the already existing wrapper.
- *
- * @param AWidget - A widget that will be wrapped or one that is already wrapped
- * @returns - The wrapper widget
- */
 function mergeWidgetOptions(AWidget) {
-  let MergedWidget = get(AWidget, 'MergedWidget');
-  // cache return value as property of widget for proper react reconciliation
+  let MergedWidget = get11(AWidget, "MergedWidget");
   if (!MergedWidget) {
     const defaultOptions = AWidget.defaultProps && AWidget.defaultProps.options || {};
-    MergedWidget = ({
-      options,
-      ...props
-    }) => {
-      return jsx(AWidget, {
-        options: {
-          ...defaultOptions,
-          ...options
-        },
-        ...props
-      });
+    MergedWidget = ({ options, ...props }) => {
+      return /* @__PURE__ */ jsx(AWidget, { options: { ...defaultOptions, ...options }, ...props });
     };
-    set(AWidget, 'MergedWidget', MergedWidget);
+    set4(AWidget, "MergedWidget", MergedWidget);
   }
   return MergedWidget;
 }
-/** Given a schema representing a field to render and either the name or actual `Widget` implementation, returns the
- * React component that is used to render the widget. If the `widget` is already a React component, then it is wrapped
- * with a `MergedWidget`. Otherwise an attempt is made to look up the widget inside of the `registeredWidgets` map based
- * on the schema type and `widget` name. If no widget component can be found an `Error` is thrown.
- *
- * @param schema - The schema for the field
- * @param [widget] - Either the name of the widget OR a `Widget` implementation to use
- * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation
- * @returns - The `Widget` component to use
- * @throws - An error if there is no `Widget` component that can be returned
- */
 function getWidget(schema, widget, registeredWidgets = {}) {
   const type = getSchemaType(schema);
-  if (typeof widget === 'function' || widget && ReactIs.isForwardRef( /*#__PURE__*/createElement(widget)) || ReactIs.isMemo(widget)) {
+  if (typeof widget === "function" || widget && ReactIs.isForwardRef(createElement(widget)) || ReactIs.isMemo(widget)) {
     return mergeWidgetOptions(widget);
   }
-  if (typeof widget !== 'string') {
+  if (typeof widget !== "string") {
     throw new Error(`Unsupported widget definition: ${typeof widget}`);
   }
   if (widget in registeredWidgets) {
     const registeredWidget = registeredWidgets[widget];
     return getWidget(schema, registeredWidget, registeredWidgets);
   }
-  if (typeof type === 'string') {
+  if (typeof type === "string") {
     if (!(type in widgetMap)) {
       throw new Error(`No widget for type '${type}'`);
     }
@@ -2632,148 +1925,76 @@ function getWidget(schema, widget, registeredWidgets = {}) {
   throw new Error(`No widget '${widget}' for type '${type}'`);
 }
 
-/** JS has no built-in hashing function, so rolling our own
- *  based on Java's hashing fn:
- *  http://www.java2s.com/example/nodejs-utility-method/string-hash/hashcode-4dc2b.html
- *
- * @param string - The string for which to get the hash
- * @returns - The resulting hash of the string in hex format
- */
+// src/hashForSchema.ts
 function hashString(string) {
   let hash = 0;
   for (let i = 0; i < string.length; i += 1) {
     const chr = string.charCodeAt(i);
     hash = (hash << 5) - hash + chr;
-    hash = hash & hash; // Convert to 32bit integer
+    hash = hash & hash;
   }
-
   return hash.toString(16);
 }
-/** Stringifies the schema and returns the hash of the resulting string. Sorts schema fields
- * in consistent order before stringify to prevent different hash ids for the same schema.
- *
- * @param schema - The schema for which the hash is desired
- * @returns - The string obtained from the hash of the stringified schema
- */
 function hashForSchema(schema) {
-  const allKeys = new Set();
-  // solution source: https://stackoverflow.com/questions/16167581/sort-object-properties-and-json-stringify/53593328#53593328
+  const allKeys = /* @__PURE__ */ new Set();
   JSON.stringify(schema, (key, value) => (allKeys.add(key), value));
   return hashString(JSON.stringify(schema, Array.from(allKeys).sort()));
 }
 
-/** Detects whether the `widget` exists for the `schema` with the associated `registryWidgets` and returns true if it
- * does, or false if it doesn't.
- *
- * @param schema - The schema for the field
- * @param widget - Either the name of the widget OR a `Widget` implementation to use
- * @param [registeredWidgets={}] - A registry of widget name to `Widget` implementation
- * @returns - True if the widget exists, false otherwise
- */
+// src/hasWidget.ts
 function hasWidget(schema, widget, registeredWidgets = {}) {
   try {
     getWidget(schema, widget, registeredWidgets);
     return true;
   } catch (e) {
     const err = e;
-    if (err.message && (err.message.startsWith('No widget') || err.message.startsWith('Unsupported widget'))) {
+    if (err.message && (err.message.startsWith("No widget") || err.message.startsWith("Unsupported widget"))) {
       return false;
     }
     throw e;
   }
 }
 
-/** Generates a consistent `id` pattern for a given `id` and a `suffix`
- *
- * @param id - Either simple string id or an IdSchema from which to extract it
- * @param suffix - The suffix to append to the id
- */
+// src/idGenerators.ts
+import isString3 from "lodash/isString";
 function idGenerator(id, suffix) {
-  const theId = isString(id) ? id : id[ID_KEY];
+  const theId = isString3(id) ? id : id[ID_KEY];
   return `${theId}__${suffix}`;
 }
-/** Return a consistent `id` for the field description element
- *
- * @param id - Either simple string id or an IdSchema from which to extract it
- * @returns - The consistent id for the field description element from the given `id`
- */
 function descriptionId(id) {
-  return idGenerator(id, 'description');
+  return idGenerator(id, "description");
 }
-/** Return a consistent `id` for the field error element
- *
- * @param id - Either simple string id or an IdSchema from which to extract it
- * @returns - The consistent id for the field error element from the given `id`
- */
 function errorId(id) {
-  return idGenerator(id, 'error');
+  return idGenerator(id, "error");
 }
-/** Return a consistent `id` for the field examples element
- *
- * @param id - Either simple string id or an IdSchema from which to extract it
- * @returns - The consistent id for the field examples element from the given `id`
- */
 function examplesId(id) {
-  return idGenerator(id, 'examples');
+  return idGenerator(id, "examples");
 }
-/** Return a consistent `id` for the field help element
- *
- * @param id - Either simple string id or an IdSchema from which to extract it
- * @returns - The consistent id for the field help element from the given `id`
- */
 function helpId(id) {
-  return idGenerator(id, 'help');
+  return idGenerator(id, "help");
 }
-/** Return a consistent `id` for the field title element
- *
- * @param id - Either simple string id or an IdSchema from which to extract it
- * @returns - The consistent id for the field title element from the given `id`
- */
 function titleId(id) {
-  return idGenerator(id, 'title');
-}
-/** Return a list of element ids that contain additional information about the field that can be used to as the aria
- * description of the field. This is correctly omitting `titleId` which would be "labeling" rather than "describing" the
- * element.
- *
- * @param id - Either simple string id or an IdSchema from which to extract it
- * @param [includeExamples=false] - Optional flag, if true, will add the `examplesId` into the list
- * @returns - The string containing the list of ids for use in an `aria-describedBy` attribute
- */
+  return idGenerator(id, "title");
+}
 function ariaDescribedByIds(id, includeExamples = false) {
-  const examples = includeExamples ? ` ${examplesId(id)}` : '';
+  const examples = includeExamples ? ` ${examplesId(id)}` : "";
   return `${errorId(id)} ${descriptionId(id)} ${helpId(id)}${examples}`;
 }
-/** Return a consistent `id` for the `optionIndex`s of a `Radio` or `Checkboxes` widget
- *
- * @param id - The id of the parent component for the option
- * @param optionIndex - The index of the option for which the id is desired
- * @returns - An id for the option index based on the parent `id`
- */
 function optionId(id, optionIndex) {
   return `${id}-${optionIndex}`;
 }
 
+// src/labelValue.ts
 function labelValue(label, hideLabel, fallback) {
   return hideLabel ? fallback : label;
 }
 
-/** Converts a local Date string into a UTC date string
- *
- * @param dateString - The string representation of a date as accepted by the `Date()` constructor
- * @returns - A UTC date string if `dateString` is truthy, otherwise undefined
- */
+// src/localToUTC.ts
 function localToUTC(dateString) {
-  return dateString ? new Date(dateString).toJSON() : undefined;
+  return dateString ? new Date(dateString).toJSON() : void 0;
 }
 
-/** Returns the constant value from the schema when it is either a single value enum or has a const key. Otherwise
- * throws an error.
- *
- * @param schema - The schema from which to obtain the constant value
- * @returns - The constant value for the schema
- * @throws - Error when the schema does not have a constant value
- */
+// src/toConstant.ts
 function toConstant(schema) {
   if (ENUM_KEY in schema && Array.isArray(schema.enum) && schema.enum.length === 1) {
     return schema.enum[0];
@@ -2781,35 +2002,23 @@ function toConstant(schema) {
   if (CONST_KEY in schema) {
     return schema.const;
   }
-  throw new Error('schema cannot be inferred as a constant');
+  throw new Error("schema cannot be inferred as a constant");
 }
 
-/** Gets the list of options from the schema. If the schema has an enum list, then those enum values are returned. The
- * labels for the options will be extracted from the non-standard, RJSF-deprecated `enumNames` if it exists, otherwise
- * the label will be the same as the `value`. If the schema has a `oneOf` or `anyOf`, then the value is the list of
- * `const` values from the schema and the label is either the `schema.title` or the value.
- *
- * @param schema - The schema from which to extract the options list
- * @returns - The list of options from the schema
- */
+// src/optionsList.ts
 function optionsList(schema) {
-  // enumNames was deprecated in v5 and is intentionally omitted from the RJSFSchema type.
-  // Cast the type to include enumNames so the feature still works.
   const schemaWithEnumNames = schema;
-  if (schemaWithEnumNames.enumNames && process.env.NODE_ENV !== 'production') {
-    console.warn('The enumNames property is deprecated and may be removed in a future major release.');
+  if (schemaWithEnumNames.enumNames && true) {
+    console.warn("The enumNames property is deprecated and may be removed in a future major release.");
   }
   if (schema.enum) {
     return schema.enum.map((value, i) => {
       const label = schemaWithEnumNames.enumNames && schemaWithEnumNames.enumNames[i] || String(value);
-      return {
-        label,
-        value
-      };
+      return { label, value };
     });
   }
   const altSchemas = schema.oneOf || schema.anyOf;
-  return altSchemas && altSchemas.map(aSchemaDef => {
+  return altSchemas && altSchemas.map((aSchemaDef) => {
     const aSchema = aSchemaDef;
     const value = toConstant(aSchema);
     const label = aSchema.title || String(value);
@@ -2821,65 +2030,45 @@ function optionsList(schema) {
   });
 }
 
-/** Given a list of `properties` and an `order` list, returns a list that contains the `properties` ordered correctly.
- * If `order` is not an array, then the untouched `properties` list is returned. Otherwise `properties` is ordered per
- * the `order` list. If `order` contains a '*' then any `properties` that are not mentioned explicity in `order` will be
- * places in the location of the `*`.
- *
- * @param properties - The list of property keys to be ordered
- * @param order - An array of property keys to be ordered first, with an optional '*' property
- * @returns - A list with the `properties` ordered
- * @throws - Error when the properties cannot be ordered correctly
- */
+// src/orderProperties.ts
 function orderProperties(properties, order) {
   if (!Array.isArray(order)) {
     return properties;
   }
-  const arrayToHash = arr => arr.reduce((prev, curr) => {
+  const arrayToHash = (arr) => arr.reduce((prev, curr) => {
     prev[curr] = true;
     return prev;
   }, {});
-  const errorPropList = arr => arr.length > 1 ? `properties '${arr.join("', '")}'` : `property '${arr[0]}'`;
+  const errorPropList = (arr) => arr.length > 1 ? `properties '${arr.join("', '")}'` : `property '${arr[0]}'`;
   const propertyHash = arrayToHash(properties);
-  const orderFiltered = order.filter(prop => prop === '*' || propertyHash[prop]);
+  const orderFiltered = order.filter((prop) => prop === "*" || propertyHash[prop]);
   const orderHash = arrayToHash(orderFiltered);
-  const rest = properties.filter(prop => !orderHash[prop]);
-  const restIndex = orderFiltered.indexOf('*');
+  const rest = properties.filter((prop) => !orderHash[prop]);
+  const restIndex = orderFiltered.indexOf("*");
   if (restIndex === -1) {
     if (rest.length) {
       throw new Error(`uiSchema order list does not contain ${errorPropList(rest)}`);
     }
     return orderFiltered;
   }
-  if (restIndex !== orderFiltered.lastIndexOf('*')) {
-    throw new Error('uiSchema order list contains more than one wildcard item');
+  if (restIndex !== orderFiltered.lastIndexOf("*")) {
+    throw new Error("uiSchema order list contains more than one wildcard item");
   }
   const complete = [...orderFiltered];
   complete.splice(restIndex, 1, ...rest);
   return complete;
 }
 
-/** Returns a string representation of the `num` that is padded with leading "0"s if necessary
- *
- * @param num - The number to pad
- * @param width - The width of the string at which no lead padding is necessary
- * @returns - The number converted to a string with leading zero padding if the number of digits is less than `width`
- */
+// src/pad.ts
 function pad(num, width) {
   let s = String(num);
   while (s.length < width) {
-    s = '0' + s;
+    s = "0" + s;
   }
   return s;
 }
 
-/** Parses the `dateString` into a `DateObject`, including the time information when `includeTime` is true
- *
- * @param dateString - The date string to parse into a DateObject
- * @param [includeTime=true] - Optional flag, if false, will not include the time data into the object
- * @returns - The date string converted to a `DateObject`
- * @throws - Error when the date cannot be parsed from the string
- */
+// src/parseDateString.ts
 function parseDateString(dateString, includeTime = true) {
   if (!dateString) {
     return {
@@ -2893,11 +2082,12 @@ function parseDateString(dateString, includeTime = true) {
   }
   const date = new Date(dateString);
   if (Number.isNaN(date.getTime())) {
-    throw new Error('Unable to parse date ' + dateString);
+    throw new Error("Unable to parse date " + dateString);
   }
   return {
     year: date.getUTCFullYear(),
     month: date.getUTCMonth() + 1,
+    // oh you, javascript.
     day: date.getUTCDate(),
     hour: includeTime ? date.getUTCHours() : 0,
     minute: includeTime ? date.getUTCMinutes() : 0,
@@ -2905,102 +2095,64 @@ function parseDateString(dateString, includeTime = true) {
   };
 }
 
-/** Check to see if a `schema` specifies that a value must be true. This happens when:
- * - `schema.const` is truthy
- * - `schema.enum` == `[true]`
- * - `schema.anyOf` or `schema.oneOf` has a single value which recursively returns true
- * - `schema.allOf` has at least one value which recursively returns true
- *
- * @param schema - The schema to check
- * @returns - True if the schema specifies a value that must be true, false otherwise
- */
+// src/schemaRequiresTrueValue.ts
 function schemaRequiresTrueValue(schema) {
-  // Check if const is a truthy value
   if (schema.const) {
     return true;
   }
-  // Check if an enum has a single value of true
   if (schema.enum && schema.enum.length === 1 && schema.enum[0] === true) {
     return true;
   }
-  // If anyOf has a single value, evaluate the subschema
   if (schema.anyOf && schema.anyOf.length === 1) {
     return schemaRequiresTrueValue(schema.anyOf[0]);
   }
-  // If oneOf has a single value, evaluate the subschema
   if (schema.oneOf && schema.oneOf.length === 1) {
     return schemaRequiresTrueValue(schema.oneOf[0]);
   }
-  // Evaluate each subschema in allOf, to see if one of them requires a true value
   if (schema.allOf) {
-    const schemaSome = subSchema => schemaRequiresTrueValue(subSchema);
+    const schemaSome = (subSchema) => schemaRequiresTrueValue(subSchema);
     return schema.allOf.some(schemaSome);
   }
   return false;
 }
 
-/** Determines whether the given `component` should be rerendered by comparing its current set of props and state
- * against the next set. If either of those two sets are not the same, then the component should be rerendered.
- *
- * @param component - A React component being checked
- * @param nextProps - The next set of props against which to check
- * @param nextState - The next set of state against which to check
- * @returns - True if the component should be re-rendered, false otherwise
- */
+// src/shouldRender.ts
 function shouldRender(component, nextProps, nextState) {
-  const {
-    props,
-    state
-  } = component;
+  const { props, state } = component;
   return !deepEquals(props, nextProps) || !deepEquals(state, nextState);
 }
 
-/** Returns a UTC date string for the given `dateObject`. If `time` is false, then the time portion of the string is
- * removed.
- *
- * @param dateObject - The `DateObject` to convert to a date string
- * @param [time=true] - Optional flag used to remove the time portion of the date string if false
- * @returns - The UTC date string
- */
+// src/toDateString.ts
 function toDateString(dateObject, time = true) {
-  const {
-    year,
-    month,
-    day,
-    hour = 0,
-    minute = 0,
-    second = 0
-  } = dateObject;
+  const { year, month, day, hour = 0, minute = 0, second = 0 } = dateObject;
   const utcTime = Date.UTC(year, month - 1, day, hour, minute, second);
   const datetime = new Date(utcTime).toJSON();
   return time ? datetime : datetime.slice(0, 10);
 }
 
-/** Converts an `errorSchema` into a list of `RJSFValidationErrors`
- *
- * @param errorSchema - The `ErrorSchema` instance to convert
- * @param [fieldPath=[]] - The current field path, defaults to [] if not specified
- * @returns - The list of `RJSFValidationErrors` extracted from the `errorSchema`
- */
+// src/toErrorList.ts
+import isPlainObject2 from "lodash/isPlainObject";
 function toErrorList(errorSchema, fieldPath = []) {
   if (!errorSchema) {
     return [];
   }
   let errorList = [];
   if (ERRORS_KEY in errorSchema) {
-    errorList = errorList.concat(errorSchema[ERRORS_KEY].map(message => {
-      const property = `.${fieldPath.join('.')}`;
-      return {
-        property,
-        message,
-        stack: `${property} ${message}`
-      };
-    }));
+    errorList = errorList.concat(
+      errorSchema[ERRORS_KEY].map((message) => {
+        const property = `.${fieldPath.join(".")}`;
+        return {
+          property,
+          message,
+          stack: `${property} ${message}`
+        };
+      })
+    );
   }
   return Object.keys(errorSchema).reduce((acc, key) => {
     if (key !== ERRORS_KEY) {
       const childSchema = errorSchema[key];
-      if (isPlainObject(childSchema)) {
+      if (isPlainObject2(childSchema)) {
         acc = acc.concat(toErrorList(childSchema, [...fieldPath, key]));
       }
     }
@@ -3008,38 +2160,15 @@ function toErrorList(errorSchema, fieldPath = []) {
   }, errorList);
 }
 
-/** Transforms a rjsf validation errors list:
- * [
- *   {property: '.level1.level2[2].level3', message: 'err a'},
- *   {property: '.level1.level2[2].level3', message: 'err b'},
- *   {property: '.level1.level2[4].level3', message: 'err b'},
- * ]
- * Into an error tree:
- * {
- *   level1: {
- *     level2: {
- *       2: {level3: {errors: ['err a', 'err b']}},
- *       4: {level3: {errors: ['err b']}},
- *     }
- *   }
- * };
- *
- * @param errors - The list of RJSFValidationError objects
- * @returns - The `ErrorSchema` built from the list of `RJSFValidationErrors`
- */
+// src/toErrorSchema.ts
+import toPath from "lodash/toPath";
 function toErrorSchema(errors) {
   const builder = new ErrorSchemaBuilder();
   if (errors.length) {
-    errors.forEach(error => {
-      const {
-        property,
-        message
-      } = error;
-      // When the property is the root element, just use an empty array for the path
-      const path = property === '.' ? [] : toPath(property);
-      // If the property is at the root (.level1) then toPath creates
-      // an empty array element at the first index. Remove it.
-      if (path.length > 0 && path[0] === '') {
+    errors.forEach((error) => {
+      const { property, message } = error;
+      const path = property === "." ? [] : toPath(property);
+      if (path.length > 0 && path[0] === "") {
         path.splice(0, 1);
       }
       if (message) {
@@ -3050,45 +2179,30 @@ function toErrorSchema(errors) {
   return builder.ErrorSchema;
 }
 
-/** Unwraps the `errorHandler` structure into the associated `ErrorSchema`, stripping the `addError()` functions from it
- *
- * @param errorHandler - The `FormValidation` error handling structure
- * @returns - The `ErrorSchema` resulting from the stripping of the `addError()` function
- */
+// src/unwrapErrorHandler.ts
+import isPlainObject3 from "lodash/isPlainObject";
 function unwrapErrorHandler(errorHandler) {
   return Object.keys(errorHandler).reduce((acc, key) => {
-    if (key === 'addError') {
+    if (key === "addError") {
       return acc;
     } else {
       const childSchema = errorHandler[key];
-      if (isPlainObject(childSchema)) {
+      if (isPlainObject3(childSchema)) {
         return {
           ...acc,
           [key]: unwrapErrorHandler(childSchema)
         };
       }
-      return {
-        ...acc,
-        [key]: childSchema
-      };
+      return { ...acc, [key]: childSchema };
     }
   }, {});
 }
 
-/** Converts a UTC date string into a local Date format
- *
- * @param jsonDate - A UTC date string
- * @returns - An empty string when `jsonDate` is falsey, otherwise a date string in local format
- */
+// src/utcToLocal.ts
 function utcToLocal(jsonDate) {
   if (!jsonDate) {
-    return '';
+    return "";
   }
-  // required format of `'yyyy-MM-ddThh:mm' followed by optional ':ss' or ':ss.SSS'
-  // https://html.spec.whatwg.org/multipage/input.html#local-date-and-time-state-(type%3Ddatetime-local)
-  // > should be a _valid local date and time string_ (not GMT)
-  // Note - date constructor passed local ISO-8601 does not correctly
-  // change time to UTC in node pre-8
   const date = new Date(jsonDate);
   const yyyy = pad(date.getFullYear(), 4);
   const MM = pad(date.getMonth() + 1, 2);
@@ -3100,45 +2214,29 @@ function utcToLocal(jsonDate) {
   return `${yyyy}-${MM}-${dd}T${hh}:${mm}:${ss}.${SSS}`;
 }
 
-/** Merges the errors in `additionalErrorSchema` into the existing `validationData` by combining the hierarchies in the
- * two `ErrorSchema`s and then appending the error list from the `additionalErrorSchema` obtained by calling
- * `toErrorList()` on the `errors` in the `validationData`. If no `additionalErrorSchema` is passed, then
- * `validationData` is returned.
- *
- * @param validationData - The current `ValidationData` into which to merge the additional errors
- * @param [additionalErrorSchema] - The optional additional set of errors in an `ErrorSchema`
- * @returns - The `validationData` with the additional errors from `additionalErrorSchema` merged into it, if provided.
- */
+// src/validationDataMerge.ts
+import isEmpty3 from "lodash/isEmpty";
 function validationDataMerge(validationData, additionalErrorSchema) {
   if (!additionalErrorSchema) {
     return validationData;
   }
-  const {
-    errors: oldErrors,
-    errorSchema: oldErrorSchema
-  } = validationData;
+  const { errors: oldErrors, errorSchema: oldErrorSchema } = validationData;
   let errors = toErrorList(additionalErrorSchema);
   let errorSchema = additionalErrorSchema;
-  if (!isEmpty(oldErrorSchema)) {
+  if (!isEmpty3(oldErrorSchema)) {
     errorSchema = mergeObjects(oldErrorSchema, additionalErrorSchema, true);
     errors = [...oldErrors].concat(errors);
   }
-  return {
-    errorSchema,
-    errors
-  };
+  return { errorSchema, errors };
 }
 
-/** Takes a `node` object and transforms any contained `$ref` node variables with a prefix, recursively calling
- * `withIdRefPrefix` for any other elements.
- *
- * @param node - The object node to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it
- */
+// src/withIdRefPrefix.ts
+import isObject3 from "lodash/isObject";
 function withIdRefPrefixObject(node) {
   for (const key in node) {
     const realObj = node;
     const value = realObj[key];
-    if (key === REF_KEY && typeof value === 'string' && value.startsWith('#')) {
+    if (key === REF_KEY && typeof value === "string" && value.startsWith("#")) {
       realObj[key] = ROOT_SCHEMA_PREFIX + value;
     } else {
       realObj[key] = withIdRefPrefix(value);
@@ -3146,246 +2244,271 @@ function withIdRefPrefixObject(node) {
   }
   return node;
 }
-/** Takes a `node` object list and transforms any contained `$ref` node variables with a prefix, recursively calling
- * `withIdRefPrefix` for any other elements.
- *
- * @param node - The list of object nodes to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it
- */
 function withIdRefPrefixArray(node) {
   for (let i = 0; i < node.length; i++) {
     node[i] = withIdRefPrefix(node[i]);
   }
   return node;
 }
-/** Recursively prefixes all `$ref`s in a schema with the value of the `ROOT_SCHEMA_PREFIX` constant.
- * This is used in isValid to make references to the rootSchema
- *
- * @param schemaNode - The object node to which a ROOT_SCHEMA_PREFIX is added when a REF_KEY is part of it
- * @returns - A copy of the `schemaNode` with updated `$ref`s
- */
 function withIdRefPrefix(schemaNode) {
   if (Array.isArray(schemaNode)) {
     return withIdRefPrefixArray([...schemaNode]);
   }
-  if (isObject$1(schemaNode)) {
-    return withIdRefPrefixObject({
-      ...schemaNode
-    });
+  if (isObject3(schemaNode)) {
+    return withIdRefPrefixObject({ ...schemaNode });
   }
   return schemaNode;
 }
 
-/** An enumeration of all the translatable strings used by `@rjsf/core` and its themes. The value of each of the
- * enumeration keys is expected to be the actual english string. Some strings contain replaceable parameter values
- * as indicated by `%1`, `%2`, etc. The number after the `%` indicates the order of the parameter. The ordering of
- * parameters is important because some languages may choose to put the second parameter before the first in its
- * translation. Also, some strings are rendered using `markdown-to-jsx` and thus support markdown and inline html.
- */
-var TranslatableString;
-(function (TranslatableString) {
-  /** Fallback title of an array item, used by ArrayField */
-  TranslatableString["ArrayItemTitle"] = "Item";
-  /** Missing items reason, used by ArrayField */
-  TranslatableString["MissingItems"] = "Missing items definition";
-  /** Yes label, used by BooleanField */
-  TranslatableString["YesLabel"] = "Yes";
-  /** No label, used by BooleanField */
-  TranslatableString["NoLabel"] = "No";
-  /** Close label, used by ErrorList */
-  TranslatableString["CloseLabel"] = "Close";
-  /** Errors label, used by ErrorList */
-  TranslatableString["ErrorsLabel"] = "Errors";
-  /** New additionalProperties string default value, used by ObjectField */
-  TranslatableString["NewStringDefault"] = "New Value";
-  /** Add button title, used by AddButton */
-  TranslatableString["AddButton"] = "Add";
-  /** Add button title, used by AddButton */
-  TranslatableString["AddItemButton"] = "Add Item";
-  /** Copy button title, used by IconButton */
-  TranslatableString["CopyButton"] = "Copy";
-  /** Move down button title, used by IconButton */
-  TranslatableString["MoveDownButton"] = "Move down";
-  /** Move up button title, used by IconButton */
-  TranslatableString["MoveUpButton"] = "Move up";
-  /** Remove button title, used by IconButton */
-  TranslatableString["RemoveButton"] = "Remove";
-  /** Now label, used by AltDateWidget */
-  TranslatableString["NowLabel"] = "Now";
-  /** Clear label, used by AltDateWidget */
-  TranslatableString["ClearLabel"] = "Clear";
-  /** Aria date label, used by DateWidget */
-  TranslatableString["AriaDateLabel"] = "Select a date";
-  /** File preview label, used by FileWidget */
-  TranslatableString["PreviewLabel"] = "Preview";
-  /** Decrement button aria label, used by UpDownWidget */
-  TranslatableString["DecrementAriaLabel"] = "Decrease value by 1";
-  /** Increment button aria label, used by UpDownWidget */
-  TranslatableString["IncrementAriaLabel"] = "Increase value by 1";
-  // Strings with replaceable parameters
-  /** Unknown field type reason, where %1 will be replaced with the type as provided by SchemaField */
-  TranslatableString["UnknownFieldType"] = "Unknown field type %1";
-  /** Option prefix, where %1 will be replaced with the option index as provided by MultiSchemaField */
-  TranslatableString["OptionPrefix"] = "Option %1";
-  /** Option prefix, where %1 and %2 will be replaced by the schema title and option index, respectively as provided by
-   * MultiSchemaField
-   */
-  TranslatableString["TitleOptionPrefix"] = "%1 option %2";
-  /** Key label, where %1 will be replaced by the label as provided by WrapIfAdditionalTemplate */
-  TranslatableString["KeyLabel"] = "%1 Key";
-  // Strings with replaceable parameters AND/OR that support markdown and html
-  /** Invalid object field configuration as provided by the ObjectField */
-  TranslatableString["InvalidObjectField"] = "Invalid \"%1\" object field configuration: <em>%2</em>.";
-  /** Unsupported field schema, used by UnsupportedField */
-  TranslatableString["UnsupportedField"] = "Unsupported field schema.";
-  /** Unsupported field schema, where %1 will be replaced by the idSchema.$id as provided by UnsupportedField */
-  TranslatableString["UnsupportedFieldWithId"] = "Unsupported field schema for field <code>%1</code>.";
-  /** Unsupported field schema, where %1 will be replaced by the reason string as provided by UnsupportedField */
-  TranslatableString["UnsupportedFieldWithReason"] = "Unsupported field schema: <em>%1</em>.";
-  /** Unsupported field schema, where %1 and %2 will be replaced by the idSchema.$id and reason strings, respectively,
-   * as provided by UnsupportedField
-   */
-  TranslatableString["UnsupportedFieldWithIdAndReason"] = "Unsupported field schema for field <code>%1</code>: <em>%2</em>.";
-  /** File name, type and size info, where %1, %2 and %3 will be replaced by the file name, file type and file size as
-   * provided by FileWidget
-   */
-  TranslatableString["FilesInfo"] = "<strong>%1</strong> (%2, %3 bytes)";
-})(TranslatableString || (TranslatableString = {}));
-
-/** An implementation of the `ValidatorType` interface that is designed for use in capturing schemas used by the
- * `isValid()` function. The rest of the implementation of the interface throws errors when it is attempted to be used.
- * An instance of the object allows the caller to capture the schemas used in calls to the `isValid()` function. These
- * captured schema, along with the root schema used to construct the object are stored in the map of schemas keyed by
- * the hashed value of the schema. NOTE: After hashing the schema, an $id with the hash value is added to the
- * schema IF that schema doesn't already have an $id, prior to putting the schema into the map.
- */
-class ParserValidator {
-  /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
-   * first.
-   *
-   * @param rootSchema - The root schema against which this validator will be executed
+// src/enums.ts
+var TranslatableString = /* @__PURE__ */ ((TranslatableString2) => {
+  TranslatableString2["ArrayItemTitle"] = "Item";
+  TranslatableString2["MissingItems"] = "Missing items definition";
+  TranslatableString2["YesLabel"] = "Yes";
+  TranslatableString2["NoLabel"] = "No";
+  TranslatableString2["CloseLabel"] = "Close";
+  TranslatableString2["ErrorsLabel"] = "Errors";
+  TranslatableString2["NewStringDefault"] = "New Value";
+  TranslatableString2["AddButton"] = "Add";
+  TranslatableString2["AddItemButton"] = "Add Item";
+  TranslatableString2["CopyButton"] = "Copy";
+  TranslatableString2["MoveDownButton"] = "Move down";
+  TranslatableString2["MoveUpButton"] = "Move up";
+  TranslatableString2["RemoveButton"] = "Remove";
+  TranslatableString2["NowLabel"] = "Now";
+  TranslatableString2["ClearLabel"] = "Clear";
+  TranslatableString2["AriaDateLabel"] = "Select a date";
+  TranslatableString2["PreviewLabel"] = "Preview";
+  TranslatableString2["DecrementAriaLabel"] = "Decrease value by 1";
+  TranslatableString2["IncrementAriaLabel"] = "Increase value by 1";
+  TranslatableString2["UnknownFieldType"] = "Unknown field type %1";
+  TranslatableString2["OptionPrefix"] = "Option %1";
+  TranslatableString2["TitleOptionPrefix"] = "%1 option %2";
+  TranslatableString2["KeyLabel"] = "%1 Key";
+  TranslatableString2["InvalidObjectField"] = 'Invalid "%1" object field configuration: <em>%2</em>.';
+  TranslatableString2["UnsupportedField"] = "Unsupported field schema.";
+  TranslatableString2["UnsupportedFieldWithId"] = "Unsupported field schema for field <code>%1</code>.";
+  TranslatableString2["UnsupportedFieldWithReason"] = "Unsupported field schema: <em>%1</em>.";
+  TranslatableString2["UnsupportedFieldWithIdAndReason"] = "Unsupported field schema for field <code>%1</code>: <em>%2</em>.";
+  TranslatableString2["FilesInfo"] = "<strong>%1</strong> (%2, %3 bytes)";
+  return TranslatableString2;
+})(TranslatableString || {});
+
+// src/parser/schemaParser.ts
+import forEach from "lodash/forEach";
+import isEqual6 from "lodash/isEqual";
+
+// src/parser/ParserValidator.ts
+import get12 from "lodash/get";
+import isEqual5 from "lodash/isEqual";
+var ParserValidator = class {
+  /** Construct the ParserValidator for the given `rootSchema`. This `rootSchema` will be stashed in the `schemaMap`
+   * first.
+   *
+   * @param rootSchema - The root schema against which this validator will be executed
    */
   constructor(rootSchema) {
-    /** The rootSchema provided during construction of the class */
-    this.rootSchema = void 0;
     /** The map of schemas encountered by the ParserValidator */
     this.schemaMap = {};
     this.rootSchema = rootSchema;
     this.addSchema(rootSchema, hashForSchema(rootSchema));
   }
-  /** Adds the given `schema` to the `schemaMap` keyed by the `hash` or `ID_KEY` if present on the `schema`. If the
-   * schema does not have an `ID_KEY`, then the `hash` will be added as the `ID_KEY` to allow the schema to be
-   * associated with it's `hash` for future use (by a schema compiler).
-   *
-   * @param schema - The schema which is to be added to the map
-   * @param hash - The hash value at which to map the schema
+  /** Adds the given `schema` to the `schemaMap` keyed by the `hash` or `ID_KEY` if present on the `schema`. If the
+   * schema does not have an `ID_KEY`, then the `hash` will be added as the `ID_KEY` to allow the schema to be
+   * associated with it's `hash` for future use (by a schema compiler).
+   *
+   * @param schema - The schema which is to be added to the map
+   * @param hash - The hash value at which to map the schema
    */
   addSchema(schema, hash) {
-    const key = get(schema, ID_KEY, hash);
-    const identifiedSchema = {
-      ...schema,
-      [ID_KEY]: key
-    };
+    const key = get12(schema, ID_KEY, hash);
+    const identifiedSchema = { ...schema, [ID_KEY]: key };
     const existing = this.schemaMap[key];
     if (!existing) {
       this.schemaMap[key] = identifiedSchema;
-    } else if (!isEqual(existing, identifiedSchema)) {
-      console.error('existing schema:', JSON.stringify(existing, null, 2));
-      console.error('new schema:', JSON.stringify(identifiedSchema, null, 2));
-      throw new Error(`Two different schemas exist with the same key ${key}! What a bad coincidence. If possible, try adding an $id to one of the schemas`);
+    } else if (!isEqual5(existing, identifiedSchema)) {
+      console.error("existing schema:", JSON.stringify(existing, null, 2));
+      console.error("new schema:", JSON.stringify(identifiedSchema, null, 2));
+      throw new Error(
+        `Two different schemas exist with the same key ${key}! What a bad coincidence. If possible, try adding an $id to one of the schemas`
+      );
     }
   }
-  /** Returns the current `schemaMap` to the caller
+  /** Returns the current `schemaMap` to the caller
    */
   getSchemaMap() {
     return this.schemaMap;
   }
-  /** Implements the `ValidatorType` `isValid()` method to capture the `schema` in the `schemaMap`. Throws an error when
-   * the `rootSchema` is not the same as the root schema provided during construction.
-   *
-   * @param schema - The schema to record in the `schemaMap`
-   * @param _formData - The formData parameter that is ignored
-   * @param rootSchema - The root schema associated with the schema
-   * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
+  /** Implements the `ValidatorType` `isValid()` method to capture the `schema` in the `schemaMap`. Throws an error when
+   * the `rootSchema` is not the same as the root schema provided during construction.
+   *
+   * @param schema - The schema to record in the `schemaMap`
+   * @param _formData - The formData parameter that is ignored
+   * @param rootSchema - The root schema associated with the schema
+   * @throws - Error when the given `rootSchema` differs from the root schema provided during construction
    */
   isValid(schema, _formData, rootSchema) {
-    if (!isEqual(rootSchema, this.rootSchema)) {
-      throw new Error('Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema');
+    if (!isEqual5(rootSchema, this.rootSchema)) {
+      throw new Error("Unexpectedly calling isValid() with a rootSchema that differs from the construction rootSchema");
     }
     this.addSchema(schema, hashForSchema(schema));
     return false;
   }
-  /** Implements the `ValidatorType` `rawValidation()` method to throw an error since it is never supposed to be called
-   *
-   * @param _schema - The schema parameter that is ignored
-   * @param _formData - The formData parameter that is ignored
+  /** Implements the `ValidatorType` `rawValidation()` method to throw an error since it is never supposed to be called
+   *
+   * @param _schema - The schema parameter that is ignored
+   * @param _formData - The formData parameter that is ignored
    */
   rawValidation(_schema, _formData) {
-    throw new Error('Unexpectedly calling the `rawValidation()` method during schema parsing');
+    throw new Error("Unexpectedly calling the `rawValidation()` method during schema parsing");
   }
-  /** Implements the `ValidatorType` `toErrorList()` method to throw an error since it is never supposed to be called
-   *
-   * @param _errorSchema - The error schema parameter that is ignored
-   * @param _fieldPath - The field path parameter that is ignored
+  /** Implements the `ValidatorType` `toErrorList()` method to throw an error since it is never supposed to be called
+   *
+   * @param _errorSchema - The error schema parameter that is ignored
+   * @param _fieldPath - The field path parameter that is ignored
    */
   toErrorList(_errorSchema, _fieldPath) {
-    throw new Error('Unexpectedly calling the `toErrorList()` method during schema parsing');
-  }
-  /** Implements the `ValidatorType` `validateFormData()` method to throw an error since it is never supposed to be
-   * called
-   *
-   * @param _formData - The formData parameter that is ignored
-   * @param _schema - The schema parameter that is ignored
-   * @param _customValidate - The customValidate parameter that is ignored
-   * @param _transformErrors - The transformErrors parameter that is ignored
-   * @param _uiSchema - The uiSchema parameter that is ignored
+    throw new Error("Unexpectedly calling the `toErrorList()` method during schema parsing");
+  }
+  /** Implements the `ValidatorType` `validateFormData()` method to throw an error since it is never supposed to be
+   * called
+   *
+   * @param _formData - The formData parameter that is ignored
+   * @param _schema - The schema parameter that is ignored
+   * @param _customValidate - The customValidate parameter that is ignored
+   * @param _transformErrors - The transformErrors parameter that is ignored
+   * @param _uiSchema - The uiSchema parameter that is ignored
    */
   validateFormData(_formData, _schema, _customValidate, _transformErrors, _uiSchema) {
-    throw new Error('Unexpectedly calling the `validateFormData()` method during schema parsing');
+    throw new Error("Unexpectedly calling the `validateFormData()` method during schema parsing");
   }
-}
+};
 
-/** Recursive function used to parse the given `schema` belonging to the `rootSchema`. The `validator` is used to
- * capture the sub-schemas that the `isValid()` function is called with. For each schema returned by the
- * `retrieveSchemaInternal()`, the `resolveAnyOrOneOfSchemas()` function is called. For each of the schemas returned
- * from THAT call have `properties`, then each of the sub-schema property objects are then recursively parsed.
- *
- * @param validator - The `ParserValidator` implementation used to capture `isValid()` calls during parsing
- * @param recurseList - The list of schemas returned from the `retrieveSchemaInternal`, preventing infinite recursion
- * @param rootSchema - The root schema from which the schema parsing began
- * @param schema - The current schema element being parsed
- */
+// src/parser/schemaParser.ts
 function parseSchema(validator, recurseList, rootSchema, schema) {
-  const schemas = retrieveSchemaInternal(validator, schema, rootSchema, undefined, true);
-  schemas.forEach(schema => {
-    const sameSchemaIndex = recurseList.findIndex(item => isEqual(item, schema));
+  const schemas = retrieveSchemaInternal(validator, schema, rootSchema, void 0, true);
+  schemas.forEach((schema2) => {
+    const sameSchemaIndex = recurseList.findIndex((item) => isEqual6(item, schema2));
     if (sameSchemaIndex === -1) {
-      recurseList.push(schema);
-      const allOptions = resolveAnyOrOneOfSchemas(validator, schema, rootSchema, true);
-      allOptions.forEach(s => {
+      recurseList.push(schema2);
+      const allOptions = resolveAnyOrOneOfSchemas(validator, schema2, rootSchema, true);
+      allOptions.forEach((s) => {
         if (PROPERTIES_KEY in s && s[PROPERTIES_KEY]) {
-          forEach(schema[PROPERTIES_KEY], value => {
+          forEach(schema2[PROPERTIES_KEY], (value) => {
             parseSchema(validator, recurseList, rootSchema, value);
           });
         }
       });
-      if (ITEMS_KEY in schema && !Array.isArray(schema.items) && typeof schema.items !== 'boolean') {
-        parseSchema(validator, recurseList, rootSchema, schema.items);
+      if (ITEMS_KEY in schema2 && !Array.isArray(schema2.items) && typeof schema2.items !== "boolean") {
+        parseSchema(validator, recurseList, rootSchema, schema2.items);
       }
     }
   });
 }
-/** Parses the given `rootSchema` to extract out all the sub-schemas that maybe contained within it. Returns a map of
- * the hash of the schema to schema/sub-schema.
- *
- * @param rootSchema - The root schema to parse for sub-schemas used by `isValid()` calls
- * @returns - The `SchemaMap` of all schemas that were parsed
- */
 function schemaParser(rootSchema) {
   const validator = new ParserValidator(rootSchema);
   const recurseList = [];
   parseSchema(validator, recurseList, rootSchema, rootSchema);
   return validator.getSchemaMap();
 }
-
-export { ADDITIONAL_PROPERTIES_KEY, ADDITIONAL_PROPERTY_FLAG, ALL_OF_KEY, ANY_OF_KEY, CONST_KEY, DEFAULT_KEY, DEFINITIONS_KEY, DEPENDENCIES_KEY, ENUM_KEY, ERRORS_KEY, ErrorSchemaBuilder, ID_KEY, IF_KEY, ITEMS_KEY, JUNK_OPTION_ID, NAME_KEY, ONE_OF_KEY, PROPERTIES_KEY, REF_KEY, REQUIRED_KEY, RJSF_ADDITONAL_PROPERTIES_FLAG, ROOT_SCHEMA_PREFIX, SUBMIT_BTN_OPTIONS_KEY, TranslatableString, UI_FIELD_KEY, UI_GLOBAL_OPTIONS_KEY, UI_OPTIONS_KEY, UI_WIDGET_KEY, allowAdditionalItems, ariaDescribedByIds, asNumber, canExpand, createErrorHandler, createSchemaUtils, dataURItoBlob, deepEquals, descriptionId, englishStringTranslator, enumOptionsDeselectValue, enumOptionsIndexForValue, enumOptionsIsSelected, enumOptionsSelectValue, enumOptionsValueForIndex, errorId, examplesId, findSchemaDefinition, getClosestMatchingOption, getDefaultFormState, getDiscriminatorFieldFromSchema, getDisplayLabel, getFirstMatchingOption, getInputProps, getMatchingOption, getSchemaType, getSubmitButtonOptions, getTemplate, getUiOptions, getWidget, guessType, hasWidget, hashForSchema, helpId, isConstant, isCustomWidget, isFilesArray, isFixedItems, isMultiSelect, isObject, isSelect, labelValue, localToUTC, mergeDefaultsWithFormData, mergeObjects, mergeSchemas, mergeValidationData, optionId, optionsList, orderProperties, pad, parseDateString, rangeSpec, replaceStringParameters, retrieveSchema, sanitizeDataForNewSchema, schemaParser, schemaRequiresTrueValue, shouldRender, titleId, toConstant, toDateString, toErrorList, toErrorSchema, toIdSchema, toPathSchema, unwrapErrorHandler, utcToLocal, validationDataMerge, withIdRefPrefix };
+export {
+  ADDITIONAL_PROPERTIES_KEY,
+  ADDITIONAL_PROPERTY_FLAG,
+  ALL_OF_KEY,
+  ANY_OF_KEY,
+  CONST_KEY,
+  DEFAULT_KEY,
+  DEFINITIONS_KEY,
+  DEPENDENCIES_KEY,
+  ENUM_KEY,
+  ERRORS_KEY,
+  ErrorSchemaBuilder,
+  ID_KEY,
+  IF_KEY,
+  ITEMS_KEY,
+  JUNK_OPTION_ID,
+  NAME_KEY,
+  ONE_OF_KEY,
+  PROPERTIES_KEY,
+  REF_KEY,
+  REQUIRED_KEY,
+  RJSF_ADDITONAL_PROPERTIES_FLAG,
+  ROOT_SCHEMA_PREFIX,
+  SUBMIT_BTN_OPTIONS_KEY,
+  TranslatableString,
+  UI_FIELD_KEY,
+  UI_GLOBAL_OPTIONS_KEY,
+  UI_OPTIONS_KEY,
+  UI_WIDGET_KEY,
+  allowAdditionalItems,
+  ariaDescribedByIds,
+  asNumber,
+  canExpand,
+  createErrorHandler,
+  createSchemaUtils,
+  dataURItoBlob,
+  deepEquals,
+  descriptionId,
+  englishStringTranslator,
+  enumOptionsDeselectValue,
+  enumOptionsIndexForValue,
+  enumOptionsIsSelected,
+  enumOptionsSelectValue,
+  enumOptionsValueForIndex,
+  errorId,
+  examplesId,
+  findSchemaDefinition,
+  getClosestMatchingOption,
+  getDefaultFormState,
+  getDiscriminatorFieldFromSchema,
+  getDisplayLabel,
+  getFirstMatchingOption,
+  getInputProps,
+  getMatchingOption,
+  getSchemaType,
+  getSubmitButtonOptions,
+  getTemplate,
+  getUiOptions,
+  getWidget,
+  guessType,
+  hasWidget,
+  hashForSchema,
+  helpId,
+  isConstant,
+  isCustomWidget,
+  isFilesArray,
+  isFixedItems,
+  isMultiSelect,
+  isObject,
+  isSelect,
+  labelValue,
+  localToUTC,
+  mergeDefaultsWithFormData,
+  mergeObjects,
+  mergeSchemas,
+  mergeValidationData,
+  optionId,
+  optionsList,
+  orderProperties,
+  pad,
+  parseDateString,
+  rangeSpec,
+  replaceStringParameters,
+  retrieveSchema,
+  sanitizeDataForNewSchema,
+  schemaParser,
+  schemaRequiresTrueValue,
+  shouldRender,
+  titleId,
+  toConstant,
+  toDateString,
+  toErrorList,
+  toErrorSchema,
+  toIdSchema,
+  toPathSchema,
+  unwrapErrorHandler,
+  utcToLocal,
+  validationDataMerge,
+  withIdRefPrefix
+};
 //# sourceMappingURL=utils.esm.js.map