@bonlineza/luxity-lib 2.30.3 → 2.31.0

package/LuxityFooter.js

@@ -0,0 +1,2026 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('react'), require('styled-components')) :
+  typeof define === 'function' && define.amd ? define(['react', 'styled-components'], factory) :
+  (global = global || self, global.LuxityFooter = factory(global.React, global.styled));
+}(this, (function (React, styled) { 'use strict';
+
+  var React__default = 'default' in React ? React['default'] : React;
+  var styled__default = 'default' in styled ? styled['default'] : styled;
+
+  function _extends() {
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
+
+  function _taggedTemplateLiteral(strings, raw) {
+    if (!raw) {
+      raw = strings.slice(0);
+    }
+
+    return Object.freeze(Object.defineProperties(strings, {
+      raw: {
+        value: Object.freeze(raw)
+      }
+    }));
+  }
+
+  var isCheckBoxInput = (element) => element.type === 'checkbox';
+
+  var isDateObject = (value) => value instanceof Date;
+
+  var isNullOrUndefined = (value) => value == null;
+
+  const isObjectType = (value) => typeof value === 'object';
+  var isObject = (value) => !isNullOrUndefined(value) &&
+      !Array.isArray(value) &&
+      isObjectType(value) &&
+      !isDateObject(value);
+
+  var getEventValue = (event) => isObject(event) && event.target
+      ? isCheckBoxInput(event.target)
+          ? event.target.checked
+          : event.target.value
+      : event;
+
+  var getNodeParentName = (name) => name.substring(0, name.search(/\.\d+(\.|$)/)) || name;
+
+  var isNameInFieldArray = (names, name) => names.has(getNodeParentName(name));
+
+  var isPlainObject = (tempObject) => {
+      const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
+      return (isObject(prototypeCopy) && prototypeCopy.hasOwnProperty('isPrototypeOf'));
+  };
+
+  var isWeb = typeof window !== 'undefined' &&
+      typeof window.HTMLElement !== 'undefined' &&
+      typeof document !== 'undefined';
+
+  function cloneObject(data) {
+      let copy;
+      const isArray = Array.isArray(data);
+      if (data instanceof Date) {
+          copy = new Date(data);
+      }
+      else if (data instanceof Set) {
+          copy = new Set(data);
+      }
+      else if (!(isWeb && (data instanceof Blob || data instanceof FileList)) &&
+          (isArray || isObject(data))) {
+          copy = isArray ? [] : {};
+          if (!isArray && !isPlainObject(data)) {
+              copy = data;
+          }
+          else {
+              for (const key in data) {
+                  if (data.hasOwnProperty(key)) {
+                      copy[key] = cloneObject(data[key]);
+                  }
+              }
+          }
+      }
+      else {
+          return data;
+      }
+      return copy;
+  }
+
+  var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
+
+  var isUndefined = (val) => val === undefined;
+
+  var get = (obj, path, defaultValue) => {
+      if (!path || !isObject(obj)) {
+          return defaultValue;
+      }
+      const result = compact(path.split(/[,[\].]+?/)).reduce((result, key) => isNullOrUndefined(result) ? result : result[key], obj);
+      return isUndefined(result) || result === obj
+          ? isUndefined(obj[path])
+              ? defaultValue
+              : obj[path]
+          : result;
+  };
+
+  const EVENTS = {
+      BLUR: 'blur',
+      FOCUS_OUT: 'focusout',
+      CHANGE: 'change',
+  };
+  const VALIDATION_MODE = {
+      onBlur: 'onBlur',
+      onChange: 'onChange',
+      onSubmit: 'onSubmit',
+      onTouched: 'onTouched',
+      all: 'all',
+  };
+  const INPUT_VALIDATION_RULES = {
+      max: 'max',
+      min: 'min',
+      maxLength: 'maxLength',
+      minLength: 'minLength',
+      pattern: 'pattern',
+      required: 'required',
+      validate: 'validate',
+  };
+
+  const HookFormContext = React__default.createContext(null);
+
+  var getProxyFormState = (formState, control, localProxyFormState, isRoot = true) => {
+      const result = {
+          defaultValues: control._defaultValues,
+      };
+      for (const key in formState) {
+          Object.defineProperty(result, key, {
+              get: () => {
+                  const _key = key;
+                  if (control._proxyFormState[_key] !== VALIDATION_MODE.all) {
+                      control._proxyFormState[_key] = !isRoot || VALIDATION_MODE.all;
+                  }
+                  localProxyFormState && (localProxyFormState[_key] = true);
+                  return formState[_key];
+              },
+          });
+      }
+      return result;
+  };
+
+  var isEmptyObject = (value) => isObject(value) && !Object.keys(value).length;
+
+  var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => {
+      updateFormState(formStateData);
+      const { name, ...formState } = formStateData;
+      return (isEmptyObject(formState) ||
+          Object.keys(formState).length >= Object.keys(_proxyFormState).length ||
+          Object.keys(formState).find((key) => _proxyFormState[key] ===
+              (!isRoot || VALIDATION_MODE.all)));
+  };
+
+  var convertToArrayPayload = (value) => (Array.isArray(value) ? value : [value]);
+
+  function useSubscribe(props) {
+      const _props = React__default.useRef(props);
+      _props.current = props;
+      React__default.useEffect(() => {
+          const subscription = !props.disabled &&
+              _props.current.subject &&
+              _props.current.subject.subscribe({
+                  next: _props.current.next,
+              });
+          return () => {
+              subscription && subscription.unsubscribe();
+          };
+      }, [props.disabled]);
+  }
+
+  var isString = (value) => typeof value === 'string';
+
+  var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => {
+      if (isString(names)) {
+          isGlobal && _names.watch.add(names);
+          return get(formValues, names, defaultValue);
+      }
+      if (Array.isArray(names)) {
+          return names.map((fieldName) => (isGlobal && _names.watch.add(fieldName), get(formValues, fieldName)));
+      }
+      isGlobal && (_names.watchAll = true);
+      return formValues;
+  };
+
+  var isKey = (value) => /^\w*$/.test(value);
+
+  var stringToPath = (input) => compact(input.replace(/["|']|\]/g, '').split(/\.|\[/));
+
+  function set(object, path, value) {
+      let index = -1;
+      const tempPath = isKey(path) ? [path] : stringToPath(path);
+      const length = tempPath.length;
+      const lastIndex = length - 1;
+      while (++index < length) {
+          const key = tempPath[index];
+          let newValue = value;
+          if (index !== lastIndex) {
+              const objValue = object[key];
+              newValue =
+                  isObject(objValue) || Array.isArray(objValue)
+                      ? objValue
+                      : !isNaN(+tempPath[index + 1])
+                          ? []
+                          : {};
+          }
+          object[key] = newValue;
+          object = object[key];
+      }
+      return object;
+  }
+
+  var appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria
+      ? {
+          ...errors[name],
+          types: {
+              ...(errors[name] && errors[name].types ? errors[name].types : {}),
+              [type]: message || true,
+          },
+      }
+      : {};
+
+  const focusFieldBy = (fields, callback, fieldsNames) => {
+      for (const key of fieldsNames || Object.keys(fields)) {
+          const field = get(fields, key);
+          if (field) {
+              const { _f, ...currentField } = field;
+              if (_f && callback(_f.name)) {
+                  if (_f.ref.focus) {
+                      _f.ref.focus();
+                      break;
+                  }
+                  else if (_f.refs && _f.refs[0].focus) {
+                      _f.refs[0].focus();
+                      break;
+                  }
+              }
+              else if (isObject(currentField)) {
+                  focusFieldBy(currentField, callback);
+              }
+          }
+      }
+  };
+
+  var getValidationModes = (mode) => ({
+      isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,
+      isOnBlur: mode === VALIDATION_MODE.onBlur,
+      isOnChange: mode === VALIDATION_MODE.onChange,
+      isOnAll: mode === VALIDATION_MODE.all,
+      isOnTouch: mode === VALIDATION_MODE.onTouched,
+  });
+
+  var isWatched = (name, _names, isBlurEvent) => !isBlurEvent &&
+      (_names.watchAll ||
+          _names.watch.has(name) ||
+          [..._names.watch].some((watchName) => name.startsWith(watchName) &&
+              /^\.\w+/.test(name.slice(watchName.length))));
+
+  var updateFieldArrayRootError = (errors, error, name) => {
+      const fieldArrayErrors = compact(get(errors, name));
+      set(fieldArrayErrors, 'root', error[name]);
+      set(errors, name, fieldArrayErrors);
+      return errors;
+  };
+
+  var isBoolean = (value) => typeof value === 'boolean';
+
+  var isFileInput = (element) => element.type === 'file';
+
+  var isFunction = (value) => typeof value === 'function';
+
+  var isHTMLElement = (value) => {
+      if (!isWeb) {
+          return false;
+      }
+      const owner = value ? value.ownerDocument : 0;
+      return (value instanceof
+          (owner && owner.defaultView ? owner.defaultView.HTMLElement : HTMLElement));
+  };
+
+  var isMessage = (value) => isString(value);
+
+  var isRadioInput = (element) => element.type === 'radio';
+
+  var isRegex = (value) => value instanceof RegExp;
+
+  const defaultResult = {
+      value: false,
+      isValid: false,
+  };
+  const validResult = { value: true, isValid: true };
+  var getCheckboxValue = (options) => {
+      if (Array.isArray(options)) {
+          if (options.length > 1) {
+              const values = options
+                  .filter((option) => option && option.checked && !option.disabled)
+                  .map((option) => option.value);
+              return { value: values, isValid: !!values.length };
+          }
+          return options[0].checked && !options[0].disabled
+              ? // @ts-expect-error expected to work in the browser
+                  options[0].attributes && !isUndefined(options[0].attributes.value)
+                      ? isUndefined(options[0].value) || options[0].value === ''
+                          ? validResult
+                          : { value: options[0].value, isValid: true }
+                      : validResult
+              : defaultResult;
+      }
+      return defaultResult;
+  };
+
+  const defaultReturn = {
+      isValid: false,
+      value: null,
+  };
+  var getRadioValue = (options) => Array.isArray(options)
+      ? options.reduce((previous, option) => option && option.checked && !option.disabled
+          ? {
+              isValid: true,
+              value: option.value,
+          }
+          : previous, defaultReturn)
+      : defaultReturn;
+
+  function getValidateError(result, ref, type = 'validate') {
+      if (isMessage(result) ||
+          (Array.isArray(result) && result.every(isMessage)) ||
+          (isBoolean(result) && !result)) {
+          return {
+              type,
+              message: isMessage(result) ? result : '',
+              ref,
+          };
+      }
+  }
+
+  var getValueAndMessage = (validationData) => isObject(validationData) && !isRegex(validationData)
+      ? validationData
+      : {
+          value: validationData,
+          message: '',
+      };
+
+  var validateField = async (field, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
+      const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, disabled, } = field._f;
+      const inputValue = get(formValues, name);
+      if (!mount || disabled) {
+          return {};
+      }
+      const inputRef = refs ? refs[0] : ref;
+      const setCustomValidity = (message) => {
+          if (shouldUseNativeValidation && inputRef.reportValidity) {
+              inputRef.setCustomValidity(isBoolean(message) ? '' : message || '');
+              inputRef.reportValidity();
+          }
+      };
+      const error = {};
+      const isRadio = isRadioInput(ref);
+      const isCheckBox = isCheckBoxInput(ref);
+      const isRadioOrCheckbox = isRadio || isCheckBox;
+      const isEmpty = ((valueAsNumber || isFileInput(ref)) &&
+          isUndefined(ref.value) &&
+          isUndefined(inputValue)) ||
+          (isHTMLElement(ref) && ref.value === '') ||
+          inputValue === '' ||
+          (Array.isArray(inputValue) && !inputValue.length);
+      const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
+      const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => {
+          const message = exceedMax ? maxLengthMessage : minLengthMessage;
+          error[name] = {
+              type: exceedMax ? maxType : minType,
+              message,
+              ref,
+              ...appendErrorsCurry(exceedMax ? maxType : minType, message),
+          };
+      };
+      if (isFieldArray
+          ? !Array.isArray(inputValue) || !inputValue.length
+          : required &&
+              ((!isRadioOrCheckbox && (isEmpty || isNullOrUndefined(inputValue))) ||
+                  (isBoolean(inputValue) && !inputValue) ||
+                  (isCheckBox && !getCheckboxValue(refs).isValid) ||
+                  (isRadio && !getRadioValue(refs).isValid))) {
+          const { value, message } = isMessage(required)
+              ? { value: !!required, message: required }
+              : getValueAndMessage(required);
+          if (value) {
+              error[name] = {
+                  type: INPUT_VALIDATION_RULES.required,
+                  message,
+                  ref: inputRef,
+                  ...appendErrorsCurry(INPUT_VALIDATION_RULES.required, message),
+              };
+              if (!validateAllFieldCriteria) {
+                  setCustomValidity(message);
+                  return error;
+              }
+          }
+      }
+      if (!isEmpty && (!isNullOrUndefined(min) || !isNullOrUndefined(max))) {
+          let exceedMax;
+          let exceedMin;
+          const maxOutput = getValueAndMessage(max);
+          const minOutput = getValueAndMessage(min);
+          if (!isNullOrUndefined(inputValue) && !isNaN(inputValue)) {
+              const valueNumber = ref.valueAsNumber ||
+                  (inputValue ? +inputValue : inputValue);
+              if (!isNullOrUndefined(maxOutput.value)) {
+                  exceedMax = valueNumber > maxOutput.value;
+              }
+              if (!isNullOrUndefined(minOutput.value)) {
+                  exceedMin = valueNumber < minOutput.value;
+              }
+          }
+          else {
+              const valueDate = ref.valueAsDate || new Date(inputValue);
+              const convertTimeToDate = (time) => new Date(new Date().toDateString() + ' ' + time);
+              const isTime = ref.type == 'time';
+              const isWeek = ref.type == 'week';
+              if (isString(maxOutput.value) && inputValue) {
+                  exceedMax = isTime
+                      ? convertTimeToDate(inputValue) > convertTimeToDate(maxOutput.value)
+                      : isWeek
+                          ? inputValue > maxOutput.value
+                          : valueDate > new Date(maxOutput.value);
+              }
+              if (isString(minOutput.value) && inputValue) {
+                  exceedMin = isTime
+                      ? convertTimeToDate(inputValue) < convertTimeToDate(minOutput.value)
+                      : isWeek
+                          ? inputValue < minOutput.value
+                          : valueDate < new Date(minOutput.value);
+              }
+          }
+          if (exceedMax || exceedMin) {
+              getMinMaxMessage(!!exceedMax, maxOutput.message, minOutput.message, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min);
+              if (!validateAllFieldCriteria) {
+                  setCustomValidity(error[name].message);
+                  return error;
+              }
+          }
+      }
+      if ((maxLength || minLength) &&
+          !isEmpty &&
+          (isString(inputValue) || (isFieldArray && Array.isArray(inputValue)))) {
+          const maxLengthOutput = getValueAndMessage(maxLength);
+          const minLengthOutput = getValueAndMessage(minLength);
+          const exceedMax = !isNullOrUndefined(maxLengthOutput.value) &&
+              inputValue.length > +maxLengthOutput.value;
+          const exceedMin = !isNullOrUndefined(minLengthOutput.value) &&
+              inputValue.length < +minLengthOutput.value;
+          if (exceedMax || exceedMin) {
+              getMinMaxMessage(exceedMax, maxLengthOutput.message, minLengthOutput.message);
+              if (!validateAllFieldCriteria) {
+                  setCustomValidity(error[name].message);
+                  return error;
+              }
+          }
+      }
+      if (pattern && !isEmpty && isString(inputValue)) {
+          const { value: patternValue, message } = getValueAndMessage(pattern);
+          if (isRegex(patternValue) && !inputValue.match(patternValue)) {
+              error[name] = {
+                  type: INPUT_VALIDATION_RULES.pattern,
+                  message,
+                  ref,
+                  ...appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, message),
+              };
+              if (!validateAllFieldCriteria) {
+                  setCustomValidity(message);
+                  return error;
+              }
+          }
+      }
+      if (validate) {
+          if (isFunction(validate)) {
+              const result = await validate(inputValue, formValues);
+              const validateError = getValidateError(result, inputRef);
+              if (validateError) {
+                  error[name] = {
+                      ...validateError,
+                      ...appendErrorsCurry(INPUT_VALIDATION_RULES.validate, validateError.message),
+                  };
+                  if (!validateAllFieldCriteria) {
+                      setCustomValidity(validateError.message);
+                      return error;
+                  }
+              }
+          }
+          else if (isObject(validate)) {
+              let validationResult = {};
+              for (const key in validate) {
+                  if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {
+                      break;
+                  }
+                  const validateError = getValidateError(await validate[key](inputValue, formValues), inputRef, key);
+                  if (validateError) {
+                      validationResult = {
+                          ...validateError,
+                          ...appendErrorsCurry(key, validateError.message),
+                      };
+                      setCustomValidity(validateError.message);
+                      if (validateAllFieldCriteria) {
+                          error[name] = validationResult;
+                      }
+                  }
+              }
+              if (!isEmptyObject(validationResult)) {
+                  error[name] = {
+                      ref: inputRef,
+                      ...validationResult,
+                  };
+                  if (!validateAllFieldCriteria) {
+                      return error;
+                  }
+              }
+          }
+      }
+      setCustomValidity(true);
+      return error;
+  };
+
+  function baseGet(object, updatePath) {
+      const length = updatePath.slice(0, -1).length;
+      let index = 0;
+      while (index < length) {
+          object = isUndefined(object) ? index++ : object[updatePath[index++]];
+      }
+      return object;
+  }
+  function isEmptyArray(obj) {
+      for (const key in obj) {
+          if (obj.hasOwnProperty(key) && !isUndefined(obj[key])) {
+              return false;
+          }
+      }
+      return true;
+  }
+  function unset(object, path) {
+      const paths = Array.isArray(path)
+          ? path
+          : isKey(path)
+              ? [path]
+              : stringToPath(path);
+      const childObject = paths.length === 1 ? object : baseGet(object, paths);
+      const index = paths.length - 1;
+      const key = paths[index];
+      if (childObject) {
+          delete childObject[key];
+      }
+      if (index !== 0 &&
+          ((isObject(childObject) && isEmptyObject(childObject)) ||
+              (Array.isArray(childObject) && isEmptyArray(childObject)))) {
+          unset(object, paths.slice(0, -1));
+      }
+      return object;
+  }
+
+  function createSubject() {
+      let _observers = [];
+      const next = (value) => {
+          for (const observer of _observers) {
+              observer.next && observer.next(value);
+          }
+      };
+      const subscribe = (observer) => {
+          _observers.push(observer);
+          return {
+              unsubscribe: () => {
+                  _observers = _observers.filter((o) => o !== observer);
+              },
+          };
+      };
+      const unsubscribe = () => {
+          _observers = [];
+      };
+      return {
+          get observers() {
+              return _observers;
+          },
+          next,
+          subscribe,
+          unsubscribe,
+      };
+  }
+
+  var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
+
+  function deepEqual(object1, object2) {
+      if (isPrimitive(object1) || isPrimitive(object2)) {
+          return object1 === object2;
+      }
+      if (isDateObject(object1) && isDateObject(object2)) {
+          return object1.getTime() === object2.getTime();
+      }
+      const keys1 = Object.keys(object1);
+      const keys2 = Object.keys(object2);
+      if (keys1.length !== keys2.length) {
+          return false;
+      }
+      for (const key of keys1) {
+          const val1 = object1[key];
+          if (!keys2.includes(key)) {
+              return false;
+          }
+          if (key !== 'ref') {
+              const val2 = object2[key];
+              if ((isDateObject(val1) && isDateObject(val2)) ||
+                  (isObject(val1) && isObject(val2)) ||
+                  (Array.isArray(val1) && Array.isArray(val2))
+                  ? !deepEqual(val1, val2)
+                  : val1 !== val2) {
+                  return false;
+              }
+          }
+      }
+      return true;
+  }
+
+  var isMultipleSelect = (element) => element.type === `select-multiple`;
+
+  var isRadioOrCheckbox = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);
+
+  var live = (ref) => isHTMLElement(ref) && ref.isConnected;
+
+  var objectHasFunction = (data) => {
+      for (const key in data) {
+          if (isFunction(data[key])) {
+              return true;
+          }
+      }
+      return false;
+  };
+
+  function markFieldsDirty(data, fields = {}) {
+      const isParentNodeArray = Array.isArray(data);
+      if (isObject(data) || isParentNodeArray) {
+          for (const key in data) {
+              if (Array.isArray(data[key]) ||
+                  (isObject(data[key]) && !objectHasFunction(data[key]))) {
+                  fields[key] = Array.isArray(data[key]) ? [] : {};
+                  markFieldsDirty(data[key], fields[key]);
+              }
+              else if (!isNullOrUndefined(data[key])) {
+                  fields[key] = true;
+              }
+          }
+      }
+      return fields;
+  }
+  function getDirtyFieldsFromDefaultValues(data, formValues, dirtyFieldsFromValues) {
+      const isParentNodeArray = Array.isArray(data);
+      if (isObject(data) || isParentNodeArray) {
+          for (const key in data) {
+              if (Array.isArray(data[key]) ||
+                  (isObject(data[key]) && !objectHasFunction(data[key]))) {
+                  if (isUndefined(formValues) ||
+                      isPrimitive(dirtyFieldsFromValues[key])) {
+                      dirtyFieldsFromValues[key] = Array.isArray(data[key])
+                          ? markFieldsDirty(data[key], [])
+                          : { ...markFieldsDirty(data[key]) };
+                  }
+                  else {
+                      getDirtyFieldsFromDefaultValues(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
+                  }
+              }
+              else {
+                  dirtyFieldsFromValues[key] = !deepEqual(data[key], formValues[key]);
+              }
+          }
+      }
+      return dirtyFieldsFromValues;
+  }
+  var getDirtyFields = (defaultValues, formValues) => getDirtyFieldsFromDefaultValues(defaultValues, formValues, markFieldsDirty(formValues));
+
+  var getFieldValueAs = (value, { valueAsNumber, valueAsDate, setValueAs }) => isUndefined(value)
+      ? value
+      : valueAsNumber
+          ? value === ''
+              ? NaN
+              : value
+                  ? +value
+                  : value
+          : valueAsDate && isString(value)
+              ? new Date(value)
+              : setValueAs
+                  ? setValueAs(value)
+                  : value;
+
+  function getFieldValue(_f) {
+      const ref = _f.ref;
+      if (_f.refs ? _f.refs.every((ref) => ref.disabled) : ref.disabled) {
+          return;
+      }
+      if (isFileInput(ref)) {
+          return ref.files;
+      }
+      if (isRadioInput(ref)) {
+          return getRadioValue(_f.refs).value;
+      }
+      if (isMultipleSelect(ref)) {
+          return [...ref.selectedOptions].map(({ value }) => value);
+      }
+      if (isCheckBoxInput(ref)) {
+          return getCheckboxValue(_f.refs).value;
+      }
+      return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f);
+  }
+
+  var getResolverOptions = (fieldsNames, _fields, criteriaMode, shouldUseNativeValidation) => {
+      const fields = {};
+      for (const name of fieldsNames) {
+          const field = get(_fields, name);
+          field && set(fields, name, field._f);
+      }
+      return {
+          criteriaMode,
+          names: [...fieldsNames],
+          fields,
+          shouldUseNativeValidation,
+      };
+  };
+
+  var getRuleValue = (rule) => isUndefined(rule)
+      ? rule
+      : isRegex(rule)
+          ? rule.source
+          : isObject(rule)
+              ? isRegex(rule.value)
+                  ? rule.value.source
+                  : rule.value
+              : rule;
+
+  var hasValidation = (options) => options.mount &&
+      (options.required ||
+          options.min ||
+          options.max ||
+          options.maxLength ||
+          options.minLength ||
+          options.pattern ||
+          options.validate);
+
+  function schemaErrorLookup(errors, _fields, name) {
+      const error = get(errors, name);
+      if (error || isKey(name)) {
+          return {
+              error,
+              name,
+          };
+      }
+      const names = name.split('.');
+      while (names.length) {
+          const fieldName = names.join('.');
+          const field = get(_fields, fieldName);
+          const foundError = get(errors, fieldName);
+          if (field && !Array.isArray(field) && name !== fieldName) {
+              return { name };
+          }
+          if (foundError && foundError.type) {
+              return {
+                  name: fieldName,
+                  error: foundError,
+              };
+          }
+          names.pop();
+      }
+      return {
+          name,
+      };
+  }
+
+  var skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode) => {
+      if (mode.isOnAll) {
+          return false;
+      }
+      else if (!isSubmitted && mode.isOnTouch) {
+          return !(isTouched || isBlurEvent);
+      }
+      else if (isSubmitted ? reValidateMode.isOnBlur : mode.isOnBlur) {
+          return !isBlurEvent;
+      }
+      else if (isSubmitted ? reValidateMode.isOnChange : mode.isOnChange) {
+          return isBlurEvent;
+      }
+      return true;
+  };
+
+  var unsetEmptyArray = (ref, name) => !compact(get(ref, name)).length && unset(ref, name);
+
+  const defaultOptions = {
+      mode: VALIDATION_MODE.onSubmit,
+      reValidateMode: VALIDATION_MODE.onChange,
+      shouldFocusError: true,
+  };
+  function createFormControl(props = {}, flushRootRender) {
+      let _options = {
+          ...defaultOptions,
+          ...props,
+      };
+      let _formState = {
+          submitCount: 0,
+          isDirty: false,
+          isLoading: isFunction(_options.defaultValues),
+          isValidating: false,
+          isSubmitted: false,
+          isSubmitting: false,
+          isSubmitSuccessful: false,
+          isValid: false,
+          touchedFields: {},
+          dirtyFields: {},
+          errors: {},
+      };
+      let _fields = {};
+      let _defaultValues = isObject(_options.defaultValues) || isObject(_options.values)
+          ? cloneObject(_options.defaultValues || _options.values) || {}
+          : {};
+      let _formValues = _options.shouldUnregister
+          ? {}
+          : cloneObject(_defaultValues);
+      let _state = {
+          action: false,
+          mount: false,
+          watch: false,
+      };
+      let _names = {
+          mount: new Set(),
+          unMount: new Set(),
+          array: new Set(),
+          watch: new Set(),
+      };
+      let delayErrorCallback;
+      let timer = 0;
+      const _proxyFormState = {
+          isDirty: false,
+          dirtyFields: false,
+          touchedFields: false,
+          isValidating: false,
+          isValid: false,
+          errors: false,
+      };
+      const _subjects = {
+          values: createSubject(),
+          array: createSubject(),
+          state: createSubject(),
+      };
+      const shouldCaptureDirtyFields = props.resetOptions && props.resetOptions.keepDirtyValues;
+      const validationModeBeforeSubmit = getValidationModes(_options.mode);
+      const validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
+      const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
+      const debounce = (callback) => (wait) => {
+          clearTimeout(timer);
+          timer = setTimeout(callback, wait);
+      };
+      const _updateValid = async (shouldUpdateValid) => {
+          if (_proxyFormState.isValid || shouldUpdateValid) {
+              const isValid = _options.resolver
+                  ? isEmptyObject((await _executeSchema()).errors)
+                  : await executeBuiltInValidation(_fields, true);
+              if (isValid !== _formState.isValid) {
+                  _subjects.state.next({
+                      isValid,
+                  });
+              }
+          }
+      };
+      const _updateIsValidating = (value) => _proxyFormState.isValidating &&
+          _subjects.state.next({
+              isValidating: value,
+          });
+      const _updateFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
+          if (args && method) {
+              _state.action = true;
+              if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) {
+                  const fieldValues = method(get(_fields, name), args.argA, args.argB);
+                  shouldSetValues && set(_fields, name, fieldValues);
+              }
+              if (shouldUpdateFieldsAndState &&
+                  Array.isArray(get(_formState.errors, name))) {
+                  const errors = method(get(_formState.errors, name), args.argA, args.argB);
+                  shouldSetValues && set(_formState.errors, name, errors);
+                  unsetEmptyArray(_formState.errors, name);
+              }
+              if (_proxyFormState.touchedFields &&
+                  shouldUpdateFieldsAndState &&
+                  Array.isArray(get(_formState.touchedFields, name))) {
+                  const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);
+                  shouldSetValues && set(_formState.touchedFields, name, touchedFields);
+              }
+              if (_proxyFormState.dirtyFields) {
+                  _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+              }
+              _subjects.state.next({
+                  name,
+                  isDirty: _getDirty(name, values),
+                  dirtyFields: _formState.dirtyFields,
+                  errors: _formState.errors,
+                  isValid: _formState.isValid,
+              });
+          }
+          else {
+              set(_formValues, name, values);
+          }
+      };
+      const updateErrors = (name, error) => {
+          set(_formState.errors, name, error);
+          _subjects.state.next({
+              errors: _formState.errors,
+          });
+      };
+      const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {
+          const field = get(_fields, name);
+          if (field) {
+              const defaultValue = get(_formValues, name, isUndefined(value) ? get(_defaultValues, name) : value);
+              isUndefined(defaultValue) ||
+                  (ref && ref.defaultChecked) ||
+                  shouldSkipSetValueAs
+                  ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f))
+                  : setFieldValue(name, defaultValue);
+              _state.mount && _updateValid();
+          }
+      };
+      const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender) => {
+          let shouldUpdateField = false;
+          let isPreviousDirty = false;
+          const output = {
+              name,
+          };
+          if (!isBlurEvent || shouldDirty) {
+              if (_proxyFormState.isDirty) {
+                  isPreviousDirty = _formState.isDirty;
+                  _formState.isDirty = output.isDirty = _getDirty();
+                  shouldUpdateField = isPreviousDirty !== output.isDirty;
+              }
+              const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
+              isPreviousDirty = get(_formState.dirtyFields, name);
+              isCurrentFieldPristine
+                  ? unset(_formState.dirtyFields, name)
+                  : set(_formState.dirtyFields, name, true);
+              output.dirtyFields = _formState.dirtyFields;
+              shouldUpdateField =
+                  shouldUpdateField ||
+                      (_proxyFormState.dirtyFields &&
+                          isPreviousDirty !== !isCurrentFieldPristine);
+          }
+          if (isBlurEvent) {
+              const isPreviousFieldTouched = get(_formState.touchedFields, name);
+              if (!isPreviousFieldTouched) {
+                  set(_formState.touchedFields, name, isBlurEvent);
+                  output.touchedFields = _formState.touchedFields;
+                  shouldUpdateField =
+                      shouldUpdateField ||
+                          (_proxyFormState.touchedFields &&
+                              isPreviousFieldTouched !== isBlurEvent);
+              }
+          }
+          shouldUpdateField && shouldRender && _subjects.state.next(output);
+          return shouldUpdateField ? output : {};
+      };
+      const shouldRenderByError = (name, isValid, error, fieldState) => {
+          const previousFieldError = get(_formState.errors, name);
+          const shouldUpdateValid = _proxyFormState.isValid &&
+              isBoolean(isValid) &&
+              _formState.isValid !== isValid;
+          if (props.delayError && error) {
+              delayErrorCallback = debounce(() => updateErrors(name, error));
+              delayErrorCallback(props.delayError);
+          }
+          else {
+              clearTimeout(timer);
+              delayErrorCallback = null;
+              error
+                  ? set(_formState.errors, name, error)
+                  : unset(_formState.errors, name);
+          }
+          if ((error ? !deepEqual(previousFieldError, error) : previousFieldError) ||
+              !isEmptyObject(fieldState) ||
+              shouldUpdateValid) {
+              const updatedFormState = {
+                  ...fieldState,
+                  ...(shouldUpdateValid && isBoolean(isValid) ? { isValid } : {}),
+                  errors: _formState.errors,
+                  name,
+              };
+              _formState = {
+                  ..._formState,
+                  ...updatedFormState,
+              };
+              _subjects.state.next(updatedFormState);
+          }
+          _updateIsValidating(false);
+      };
+      const _executeSchema = async (name) => _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
+      const executeSchemaAndUpdateState = async (names) => {
+          const { errors } = await _executeSchema(names);
+          if (names) {
+              for (const name of names) {
+                  const error = get(errors, name);
+                  error
+                      ? set(_formState.errors, name, error)
+                      : unset(_formState.errors, name);
+              }
+          }
+          else {
+              _formState.errors = errors;
+          }
+          return errors;
+      };
+      const executeBuiltInValidation = async (fields, shouldOnlyCheckValid, context = {
+          valid: true,
+      }) => {
+          for (const name in fields) {
+              const field = fields[name];
+              if (field) {
+                  const { _f, ...fieldValue } = field;
+                  if (_f) {
+                      const isFieldArrayRoot = _names.array.has(_f.name);
+                      const fieldError = await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
+                      if (fieldError[_f.name]) {
+                          context.valid = false;
+                          if (shouldOnlyCheckValid) {
+                              break;
+                          }
+                      }
+                      !shouldOnlyCheckValid &&
+                          (get(fieldError, _f.name)
+                              ? isFieldArrayRoot
+                                  ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name)
+                                  : set(_formState.errors, _f.name, fieldError[_f.name])
+                              : unset(_formState.errors, _f.name));
+                  }
+                  fieldValue &&
+                      (await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context));
+              }
+          }
+          return context.valid;
+      };
+      const _removeUnmounted = () => {
+          for (const name of _names.unMount) {
+              const field = get(_fields, name);
+              field &&
+                  (field._f.refs
+                      ? field._f.refs.every((ref) => !live(ref))
+                      : !live(field._f.ref)) &&
+                  unregister(name);
+          }
+          _names.unMount = new Set();
+      };
+      const _getDirty = (name, data) => (name && data && set(_formValues, name, data),
+          !deepEqual(getValues(), _defaultValues));
+      const _getWatch = (names, defaultValue, isGlobal) => generateWatchOutput(names, _names, {
+          ...(_state.mount
+              ? _formValues
+              : isUndefined(defaultValue)
+                  ? _defaultValues
+                  : isString(names)
+                      ? { [names]: defaultValue }
+                      : defaultValue),
+      }, isGlobal, defaultValue);
+      const _getFieldArray = (name) => compact(get(_state.mount ? _formValues : _defaultValues, name, props.shouldUnregister ? get(_defaultValues, name, []) : []));
+      const setFieldValue = (name, value, options = {}) => {
+          const field = get(_fields, name);
+          let fieldValue = value;
+          if (field) {
+              const fieldReference = field._f;
+              if (fieldReference) {
+                  !fieldReference.disabled &&
+                      set(_formValues, name, getFieldValueAs(value, fieldReference));
+                  fieldValue =
+                      isHTMLElement(fieldReference.ref) && isNullOrUndefined(value)
+                          ? ''
+                          : value;
+                  if (isMultipleSelect(fieldReference.ref)) {
+                      [...fieldReference.ref.options].forEach((optionRef) => (optionRef.selected = fieldValue.includes(optionRef.value)));
+                  }
+                  else if (fieldReference.refs) {
+                      if (isCheckBoxInput(fieldReference.ref)) {
+                          fieldReference.refs.length > 1
+                              ? fieldReference.refs.forEach((checkboxRef) => (!checkboxRef.defaultChecked || !checkboxRef.disabled) &&
+                                  (checkboxRef.checked = Array.isArray(fieldValue)
+                                      ? !!fieldValue.find((data) => data === checkboxRef.value)
+                                      : fieldValue === checkboxRef.value))
+                              : fieldReference.refs[0] &&
+                                  (fieldReference.refs[0].checked = !!fieldValue);
+                      }
+                      else {
+                          fieldReference.refs.forEach((radioRef) => (radioRef.checked = radioRef.value === fieldValue));
+                      }
+                  }
+                  else if (isFileInput(fieldReference.ref)) {
+                      fieldReference.ref.value = '';
+                  }
+                  else {
+                      fieldReference.ref.value = fieldValue;
+                      if (!fieldReference.ref.type) {
+                          _subjects.values.next({
+                              name,
+                              values: { ..._formValues },
+                          });
+                      }
+                  }
+              }
+          }
+          (options.shouldDirty || options.shouldTouch) &&
+              updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true);
+          options.shouldValidate && trigger(name);
+      };
+      const setValues = (name, value, options) => {
+          for (const fieldKey in value) {
+              const fieldValue = value[fieldKey];
+              const fieldName = `${name}.${fieldKey}`;
+              const field = get(_fields, fieldName);
+              (_names.array.has(name) ||
+                  !isPrimitive(fieldValue) ||
+                  (field && !field._f)) &&
+                  !isDateObject(fieldValue)
+                  ? setValues(fieldName, fieldValue, options)
+                  : setFieldValue(fieldName, fieldValue, options);
+          }
+      };
+      const setValue = (name, value, options = {}) => {
+          const field = get(_fields, name);
+          const isFieldArray = _names.array.has(name);
+          const cloneValue = cloneObject(value);
+          set(_formValues, name, cloneValue);
+          if (isFieldArray) {
+              _subjects.array.next({
+                  name,
+                  values: { ..._formValues },
+              });
+              if ((_proxyFormState.isDirty || _proxyFormState.dirtyFields) &&
+                  options.shouldDirty) {
+                  _subjects.state.next({
+                      name,
+                      dirtyFields: getDirtyFields(_defaultValues, _formValues),
+                      isDirty: _getDirty(name, cloneValue),
+                  });
+              }
+          }
+          else {
+              field && !field._f && !isNullOrUndefined(cloneValue)
+                  ? setValues(name, cloneValue, options)
+                  : setFieldValue(name, cloneValue, options);
+          }
+          isWatched(name, _names) && _subjects.state.next({ ..._formState });
+          _subjects.values.next({
+              name,
+              values: { ..._formValues },
+          });
+          !_state.mount && flushRootRender();
+      };
+      const onChange = async (event) => {
+          const target = event.target;
+          let name = target.name;
+          let isFieldValueUpdated = true;
+          const field = get(_fields, name);
+          const getCurrentFieldValue = () => target.type ? getFieldValue(field._f) : getEventValue(event);
+          if (field) {
+              let error;
+              let isValid;
+              const fieldValue = getCurrentFieldValue();
+              const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
+              const shouldSkipValidation = (!hasValidation(field._f) &&
+                  !_options.resolver &&
+                  !get(_formState.errors, name) &&
+                  !field._f.deps) ||
+                  skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
+              const watched = isWatched(name, _names, isBlurEvent);
+              set(_formValues, name, fieldValue);
+              if (isBlurEvent) {
+                  field._f.onBlur && field._f.onBlur(event);
+                  delayErrorCallback && delayErrorCallback(0);
+              }
+              else if (field._f.onChange) {
+                  field._f.onChange(event);
+              }
+              const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent, false);
+              const shouldRender = !isEmptyObject(fieldState) || watched;
+              !isBlurEvent &&
+                  _subjects.values.next({
+                      name,
+                      type: event.type,
+                      values: { ..._formValues },
+                  });
+              if (shouldSkipValidation) {
+                  _proxyFormState.isValid && _updateValid();
+                  return (shouldRender &&
+                      _subjects.state.next({ name, ...(watched ? {} : fieldState) }));
+              }
+              !isBlurEvent && watched && _subjects.state.next({ ..._formState });
+              _updateIsValidating(true);
+              if (_options.resolver) {
+                  const { errors } = await _executeSchema([name]);
+                  const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
+                  const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);
+                  error = errorLookupResult.error;
+                  name = errorLookupResult.name;
+                  isValid = isEmptyObject(errors);
+              }
+              else {
+                  error = (await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
+                  isFieldValueUpdated =
+                      isNaN(fieldValue) ||
+                          fieldValue === get(_formValues, name, fieldValue);
+                  if (isFieldValueUpdated) {
+                      if (error) {
+                          isValid = false;
+                      }
+                      else if (_proxyFormState.isValid) {
+                          isValid = await executeBuiltInValidation(_fields, true);
+                      }
+                  }
+              }
+              if (isFieldValueUpdated) {
+                  field._f.deps &&
+                      trigger(field._f.deps);
+                  shouldRenderByError(name, isValid, error, fieldState);
+              }
+          }
+      };
+      const trigger = async (name, options = {}) => {
+          let isValid;
+          let validationResult;
+          const fieldNames = convertToArrayPayload(name);
+          _updateIsValidating(true);
+          if (_options.resolver) {
+              const errors = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames);
+              isValid = isEmptyObject(errors);
+              validationResult = name
+                  ? !fieldNames.some((name) => get(errors, name))
+                  : isValid;
+          }
+          else if (name) {
+              validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
+                  const field = get(_fields, fieldName);
+                  return await executeBuiltInValidation(field && field._f ? { [fieldName]: field } : field);
+              }))).every(Boolean);
+              !(!validationResult && !_formState.isValid) && _updateValid();
+          }
+          else {
+              validationResult = isValid = await executeBuiltInValidation(_fields);
+          }
+          _subjects.state.next({
+              ...(!isString(name) ||
+                  (_proxyFormState.isValid && isValid !== _formState.isValid)
+                  ? {}
+                  : { name }),
+              ...(_options.resolver || !name ? { isValid } : {}),
+              errors: _formState.errors,
+              isValidating: false,
+          });
+          options.shouldFocus &&
+              !validationResult &&
+              focusFieldBy(_fields, (key) => key && get(_formState.errors, key), name ? fieldNames : _names.mount);
+          return validationResult;
+      };
+      const getValues = (fieldNames) => {
+          const values = {
+              ..._defaultValues,
+              ...(_state.mount ? _formValues : {}),
+          };
+          return isUndefined(fieldNames)
+              ? values
+              : isString(fieldNames)
+                  ? get(values, fieldNames)
+                  : fieldNames.map((name) => get(values, name));
+      };
+      const getFieldState = (name, formState) => ({
+          invalid: !!get((formState || _formState).errors, name),
+          isDirty: !!get((formState || _formState).dirtyFields, name),
+          isTouched: !!get((formState || _formState).touchedFields, name),
+          error: get((formState || _formState).errors, name),
+      });
+      const clearErrors = (name) => {
+          name &&
+              convertToArrayPayload(name).forEach((inputName) => unset(_formState.errors, inputName));
+          _subjects.state.next({
+              errors: name ? _formState.errors : {},
+          });
+      };
+      const setError = (name, error, options) => {
+          const ref = (get(_fields, name, { _f: {} })._f || {}).ref;
+          set(_formState.errors, name, {
+              ...error,
+              ref,
+          });
+          _subjects.state.next({
+              name,
+              errors: _formState.errors,
+              isValid: false,
+          });
+          options && options.shouldFocus && ref && ref.focus && ref.focus();
+      };
+      const watch = (name, defaultValue) => isFunction(name)
+          ? _subjects.values.subscribe({
+              next: (payload) => name(_getWatch(undefined, defaultValue), payload),
+          })
+          : _getWatch(name, defaultValue, true);
+      const unregister = (name, options = {}) => {
+          for (const fieldName of name ? convertToArrayPayload(name) : _names.mount) {
+              _names.mount.delete(fieldName);
+              _names.array.delete(fieldName);
+              if (!options.keepValue) {
+                  unset(_fields, fieldName);
+                  unset(_formValues, fieldName);
+              }
+              !options.keepError && unset(_formState.errors, fieldName);
+              !options.keepDirty && unset(_formState.dirtyFields, fieldName);
+              !options.keepTouched && unset(_formState.touchedFields, fieldName);
+              !_options.shouldUnregister &&
+                  !options.keepDefaultValue &&
+                  unset(_defaultValues, fieldName);
+          }
+          _subjects.values.next({
+              values: { ..._formValues },
+          });
+          _subjects.state.next({
+              ..._formState,
+              ...(!options.keepDirty ? {} : { isDirty: _getDirty() }),
+          });
+          !options.keepIsValid && _updateValid();
+      };
+      const _updateDisabledField = ({ disabled, name, field, fields, }) => {
+          if (isBoolean(disabled)) {
+              const value = disabled
+                  ? undefined
+                  : get(_formValues, name, getFieldValue(field ? field._f : get(fields, name)._f));
+              set(_formValues, name, value);
+              updateTouchAndDirty(name, value, false, false, true);
+          }
+      };
+      const register = (name, options = {}) => {
+          let field = get(_fields, name);
+          const disabledIsDefined = isBoolean(options.disabled);
+          set(_fields, name, {
+              ...(field || {}),
+              _f: {
+                  ...(field && field._f ? field._f : { ref: { name } }),
+                  name,
+                  mount: true,
+                  ...options,
+              },
+          });
+          _names.mount.add(name);
+          if (field) {
+              _updateDisabledField({
+                  field,
+                  disabled: options.disabled,
+                  name,
+              });
+          }
+          else {
+              updateValidAndValue(name, true, options.value);
+          }
+          return {
+              ...(disabledIsDefined ? { disabled: options.disabled } : {}),
+              ...(_options.progressive
+                  ? {
+                      required: !!options.required,
+                      min: getRuleValue(options.min),
+                      max: getRuleValue(options.max),
+                      minLength: getRuleValue(options.minLength),
+                      maxLength: getRuleValue(options.maxLength),
+                      pattern: getRuleValue(options.pattern),
+                  }
+                  : {}),
+              name,
+              onChange,
+              onBlur: onChange,
+              ref: (ref) => {
+                  if (ref) {
+                      register(name, options);
+                      field = get(_fields, name);
+                      const fieldRef = isUndefined(ref.value)
+                          ? ref.querySelectorAll
+                              ? ref.querySelectorAll('input,select,textarea')[0] || ref
+                              : ref
+                          : ref;
+                      const radioOrCheckbox = isRadioOrCheckbox(fieldRef);
+                      const refs = field._f.refs || [];
+                      if (radioOrCheckbox
+                          ? refs.find((option) => option === fieldRef)
+                          : fieldRef === field._f.ref) {
+                          return;
+                      }
+                      set(_fields, name, {
+                          _f: {
+                              ...field._f,
+                              ...(radioOrCheckbox
+                                  ? {
+                                      refs: [
+                                          ...refs.filter(live),
+                                          fieldRef,
+                                          ...(Array.isArray(get(_defaultValues, name)) ? [{}] : []),
+                                      ],
+                                      ref: { type: fieldRef.type, name },
+                                  }
+                                  : { ref: fieldRef }),
+                          },
+                      });
+                      updateValidAndValue(name, false, undefined, fieldRef);
+                  }
+                  else {
+                      field = get(_fields, name, {});
+                      if (field._f) {
+                          field._f.mount = false;
+                      }
+                      (_options.shouldUnregister || options.shouldUnregister) &&
+                          !(isNameInFieldArray(_names.array, name) && _state.action) &&
+                          _names.unMount.add(name);
+                  }
+              },
+          };
+      };
+      const _focusError = () => _options.shouldFocusError &&
+          focusFieldBy(_fields, (key) => key && get(_formState.errors, key), _names.mount);
+      const handleSubmit = (onValid, onInvalid) => async (e) => {
+          if (e) {
+              e.preventDefault && e.preventDefault();
+              e.persist && e.persist();
+          }
+          let fieldValues = cloneObject(_formValues);
+          _subjects.state.next({
+              isSubmitting: true,
+          });
+          if (_options.resolver) {
+              const { errors, values } = await _executeSchema();
+              _formState.errors = errors;
+              fieldValues = values;
+          }
+          else {
+              await executeBuiltInValidation(_fields);
+          }
+          unset(_formState.errors, 'root');
+          if (isEmptyObject(_formState.errors)) {
+              _subjects.state.next({
+                  errors: {},
+              });
+              await onValid(fieldValues, e);
+          }
+          else {
+              if (onInvalid) {
+                  await onInvalid({ ..._formState.errors }, e);
+              }
+              _focusError();
+              setTimeout(_focusError);
+          }
+          _subjects.state.next({
+              isSubmitted: true,
+              isSubmitting: false,
+              isSubmitSuccessful: isEmptyObject(_formState.errors),
+              submitCount: _formState.submitCount + 1,
+              errors: _formState.errors,
+          });
+      };
+      const resetField = (name, options = {}) => {
+          if (get(_fields, name)) {
+              if (isUndefined(options.defaultValue)) {
+                  setValue(name, get(_defaultValues, name));
+              }
+              else {
+                  setValue(name, options.defaultValue);
+                  set(_defaultValues, name, options.defaultValue);
+              }
+              if (!options.keepTouched) {
+                  unset(_formState.touchedFields, name);
+              }
+              if (!options.keepDirty) {
+                  unset(_formState.dirtyFields, name);
+                  _formState.isDirty = options.defaultValue
+                      ? _getDirty(name, get(_defaultValues, name))
+                      : _getDirty();
+              }
+              if (!options.keepError) {
+                  unset(_formState.errors, name);
+                  _proxyFormState.isValid && _updateValid();
+              }
+              _subjects.state.next({ ..._formState });
+          }
+      };
+      const _reset = (formValues, keepStateOptions = {}) => {
+          const updatedValues = formValues ? cloneObject(formValues) : _defaultValues;
+          const cloneUpdatedValues = cloneObject(updatedValues);
+          const values = formValues && !isEmptyObject(formValues)
+              ? cloneUpdatedValues
+              : _defaultValues;
+          if (!keepStateOptions.keepDefaultValues) {
+              _defaultValues = updatedValues;
+          }
+          if (!keepStateOptions.keepValues) {
+              if (keepStateOptions.keepDirtyValues || shouldCaptureDirtyFields) {
+                  for (const fieldName of _names.mount) {
+                      get(_formState.dirtyFields, fieldName)
+                          ? set(values, fieldName, get(_formValues, fieldName))
+                          : setValue(fieldName, get(values, fieldName));
+                  }
+              }
+              else {
+                  if (isWeb && isUndefined(formValues)) {
+                      for (const name of _names.mount) {
+                          const field = get(_fields, name);
+                          if (field && field._f) {
+                              const fieldReference = Array.isArray(field._f.refs)
+                                  ? field._f.refs[0]
+                                  : field._f.ref;
+                              if (isHTMLElement(fieldReference)) {
+                                  const form = fieldReference.closest('form');
+                                  if (form) {
+                                      form.reset();
+                                      break;
+                                  }
+                              }
+                          }
+                      }
+                  }
+                  _fields = {};
+              }
+              _formValues = props.shouldUnregister
+                  ? keepStateOptions.keepDefaultValues
+                      ? cloneObject(_defaultValues)
+                      : {}
+                  : cloneObject(values);
+              _subjects.array.next({
+                  values: { ...values },
+              });
+              _subjects.values.next({
+                  values: { ...values },
+              });
+          }
+          _names = {
+              mount: new Set(),
+              unMount: new Set(),
+              array: new Set(),
+              watch: new Set(),
+              watchAll: false,
+              focus: '',
+          };
+          !_state.mount && flushRootRender();
+          _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid;
+          _state.watch = !!props.shouldUnregister;
+          _subjects.state.next({
+              submitCount: keepStateOptions.keepSubmitCount
+                  ? _formState.submitCount
+                  : 0,
+              isDirty: keepStateOptions.keepDirty
+                  ? _formState.isDirty
+                  : !!(keepStateOptions.keepDefaultValues &&
+                      !deepEqual(formValues, _defaultValues)),
+              isSubmitted: keepStateOptions.keepIsSubmitted
+                  ? _formState.isSubmitted
+                  : false,
+              dirtyFields: keepStateOptions.keepDirtyValues
+                  ? _formState.dirtyFields
+                  : keepStateOptions.keepDefaultValues && formValues
+                      ? getDirtyFields(_defaultValues, formValues)
+                      : {},
+              touchedFields: keepStateOptions.keepTouched
+                  ? _formState.touchedFields
+                  : {},
+              errors: keepStateOptions.keepErrors ? _formState.errors : {},
+              isSubmitting: false,
+              isSubmitSuccessful: false,
+          });
+      };
+      const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues)
+          ? formValues(_formValues)
+          : formValues, keepStateOptions);
+      const setFocus = (name, options = {}) => {
+          const field = get(_fields, name);
+          const fieldReference = field && field._f;
+          if (fieldReference) {
+              const fieldRef = fieldReference.refs
+                  ? fieldReference.refs[0]
+                  : fieldReference.ref;
+              if (fieldRef.focus) {
+                  fieldRef.focus();
+                  options.shouldSelect && fieldRef.select();
+              }
+          }
+      };
+      const _updateFormState = (updatedFormState) => {
+          _formState = {
+              ..._formState,
+              ...updatedFormState,
+          };
+      };
+      const _resetDefaultValues = () => isFunction(_options.defaultValues) &&
+          _options.defaultValues().then((values) => {
+              reset(values, _options.resetOptions);
+              _subjects.state.next({
+                  isLoading: false,
+              });
+          });
+      return {
+          control: {
+              register,
+              unregister,
+              getFieldState,
+              handleSubmit,
+              setError,
+              _executeSchema,
+              _getWatch,
+              _getDirty,
+              _updateValid,
+              _removeUnmounted,
+              _updateFieldArray,
+              _updateDisabledField,
+              _getFieldArray,
+              _reset,
+              _resetDefaultValues,
+              _updateFormState,
+              _subjects,
+              _proxyFormState,
+              get _fields() {
+                  return _fields;
+              },
+              get _formValues() {
+                  return _formValues;
+              },
+              get _state() {
+                  return _state;
+              },
+              set _state(value) {
+                  _state = value;
+              },
+              get _defaultValues() {
+                  return _defaultValues;
+              },
+              get _names() {
+                  return _names;
+              },
+              set _names(value) {
+                  _names = value;
+              },
+              get _formState() {
+                  return _formState;
+              },
+              set _formState(value) {
+                  _formState = value;
+              },
+              get _options() {
+                  return _options;
+              },
+              set _options(value) {
+                  _options = {
+                      ..._options,
+                      ...value,
+                  };
+              },
+          },
+          trigger,
+          register,
+          handleSubmit,
+          watch,
+          setValue,
+          getValues,
+          reset,
+          resetField,
+          clearErrors,
+          unregister,
+          setError,
+          setFocus,
+          getFieldState,
+      };
+  }
+
+  /**
+   * Custom hook to manage the entire form.
+   *
+   * @remarks
+   * [API](https://react-hook-form.com/docs/useform) • [Demo](https://codesandbox.io/s/react-hook-form-get-started-ts-5ksmm) • [Video](https://www.youtube.com/watch?v=RkXv4AXXC_4)
+   *
+   * @param props - form configuration and validation parameters.
+   *
+   * @returns methods - individual functions to manage the form state. {@link UseFormReturn}
+   *
+   * @example
+   * ```tsx
+   * function App() {
+   *   const { register, handleSubmit, watch, formState: { errors } } = useForm();
+   *   const onSubmit = data => console.log(data);
+   *
+   *   console.log(watch("example"));
+   *
+   *   return (
+   *     <form onSubmit={handleSubmit(onSubmit)}>
+   *       <input defaultValue="test" {...register("example")} />
+   *       <input {...register("exampleRequired", { required: true })} />
+   *       {errors.exampleRequired && <span>This field is required</span>}
+   *       <button>Submit</button>
+   *     </form>
+   *   );
+   * }
+   * ```
+   */
+  function useForm(props = {}) {
+      const _formControl = React__default.useRef();
+      const _values = React__default.useRef();
+      const [formState, updateFormState] = React__default.useState({
+          isDirty: false,
+          isValidating: false,
+          isLoading: isFunction(props.defaultValues),
+          isSubmitted: false,
+          isSubmitting: false,
+          isSubmitSuccessful: false,
+          isValid: false,
+          submitCount: 0,
+          dirtyFields: {},
+          touchedFields: {},
+          errors: {},
+          defaultValues: isFunction(props.defaultValues)
+              ? undefined
+              : props.defaultValues,
+      });
+      if (!_formControl.current) {
+          _formControl.current = {
+              ...createFormControl(props, () => updateFormState((formState) => ({ ...formState }))),
+              formState,
+          };
+      }
+      const control = _formControl.current.control;
+      control._options = props;
+      useSubscribe({
+          subject: control._subjects.state,
+          next: (value) => {
+              if (shouldRenderFormState(value, control._proxyFormState, control._updateFormState, true)) {
+                  updateFormState({ ...control._formState });
+              }
+          },
+      });
+      React__default.useEffect(() => {
+          if (props.values && !deepEqual(props.values, _values.current)) {
+              control._reset(props.values, control._options.resetOptions);
+              _values.current = props.values;
+          }
+          else {
+              control._resetDefaultValues();
+          }
+      }, [props.values, control]);
+      React__default.useEffect(() => {
+          if (!control._state.mount) {
+              control._updateValid();
+              control._state.mount = true;
+          }
+          if (control._state.watch) {
+              control._state.watch = false;
+              control._subjects.state.next({ ...control._formState });
+          }
+          control._removeUnmounted();
+      });
+      _formControl.current.formState = getProxyFormState(formState, control);
+      return _formControl.current;
+  }
+
+  var theme = {
+    breakpoints: ['40em', '52em', '64em'],
+    space: ['0px', '4px', '8px', '16px', '32px', '64px', '128px', '256px', '512px'],
+    fontSizes: ['12px', '14px', '16px', '20px', '24px', '32px', '48px', '64px', '72px'],
+    marginPaddings: ['0.5rem', '1rem', '1.5rem', '2rem', '2.5rem', '3rem', '3.5rem', '4rem', '4.5rem', '5rem', '5.5rem', '6rem'],
+    letterSpacings: ['-0.5px', '0px', '+0.5px'],
+    radii: ['0px', '2px', '4px', '8px'],
+    borderRadius: '6px',
+    colors: {
+      primary: '#000',
+      base: '#4e4949',
+      baseLt: '#817c7c',
+      borderColor: '#d8d8d8',
+      ntrlMin: '#fff',
+      ntrlMinTen: '#e6e6e6',
+      gray: '#efefef',
+      darkerGray: '#454141'
+    },
+    rareStepColors: {
+      primary: '#202b58',
+      secondary: '#ef5c2d',
+      ntrlMin: '#ffffff',
+      ntrl40: '#f4f4f4',
+      ntrl50: '#808080',
+      ntrl60: '#e8e8e8',
+      ntrl70: '#252525',
+      ntrlMax: '#000000'
+    },
+    rareStepFontWeights: {
+      normal: 400,
+      medium: 500,
+      semiBold: 600,
+      bold: 700
+    },
+    rareStepFontSize: {
+      h1: '36px',
+      h2: '30px',
+      h3: '24px',
+      h4: '20px',
+      h5: '16px',
+      h6: '14px',
+      footerTitle: '16px'
+    },
+    rareStepPageSizes: {
+      mobile: '500px',
+      tablet: '768px',
+      desktop: '992px',
+      screenl: '1280px',
+      screenxl: '1680px',
+      screenxxl: '1920px',
+      container: '1600px'
+    }
+  };
+
+  var themed = (function (Component) {
+    return /*#__PURE__*/React.forwardRef(function (props, ref) {
+      return /*#__PURE__*/React__default.createElement(styled.ThemeProvider, {
+        theme: theme
+      }, /*#__PURE__*/React__default.createElement(Component, _extends({}, props, {
+        ref: ref
+      })));
+    });
+  });
+
+  var _templateObject;
+  var FooterWrapper = styled__default.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n   {\n    background-color: ", ";\n  }\n"])), function (props) {
+    return props.theme.colors.gray;
+  });
+
+  var Event = function Event(instance, track) {
+    var category = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    var action = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+    var label = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : '';
+    var value = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : '';
+
+    if (track) {
+      instance.event({
+        category: category,
+        action: action,
+        label: label,
+        value: value
+      });
+    }
+  };
+
+  var GALink = function GALink(props) {
+    var gaOnClick = function gaOnClick(event) {
+      Event(props.instance, props.track, 'Link', "Click on ".concat(props.href), props.label);
+
+      if (typeof props.onClick === 'function') {
+        props.onClick(event);
+      }
+    };
+
+    return /*#__PURE__*/React__default.createElement("a", _extends({
+      href: "/"
+    }, props, {
+      onClick: gaOnClick
+    }), props.children);
+  };
+
+  var LuxityFooter = function LuxityFooter(_ref) {
+    var _ref$showNewsletter = _ref.showNewsletter,
+        showNewsletter = _ref$showNewsletter === void 0 ? true : _ref$showNewsletter,
+        _ref$buyLinks = _ref.buyLinks,
+        buyLinks = _ref$buyLinks === void 0 ? [] : _ref$buyLinks,
+        _ref$sellLinks = _ref.sellLinks,
+        sellLinks = _ref$sellLinks === void 0 ? [] : _ref$sellLinks,
+        _ref$helpLinks = _ref.helpLinks,
+        helpLinks = _ref$helpLinks === void 0 ? [] : _ref$helpLinks,
+        _ref$companyLinks = _ref.companyLinks,
+        companyLinks = _ref$companyLinks === void 0 ? [] : _ref$companyLinks,
+        _ref$socialLinks = _ref.socialLinks,
+        socialLinks = _ref$socialLinks === void 0 ? [] : _ref$socialLinks,
+        _ref$contactLinks = _ref.contactLinks,
+        contactLinks = _ref$contactLinks === void 0 ? [] : _ref$contactLinks,
+        _ref$quickiesLinks = _ref.quickiesLinks,
+        quickiesLinks = _ref$quickiesLinks === void 0 ? [] : _ref$quickiesLinks,
+        visaImgSrc = _ref.visaImgSrc,
+        masterCardSrc = _ref.masterCardSrc,
+        logoSrc = _ref.logoSrc,
+        formIconSrc = _ref.formIconSrc,
+        onSubmit = _ref.onSubmit;
+    var currentYear = new Date().getFullYear();
+
+    var _useForm = useForm(),
+        handleSubmit = _useForm.handleSubmit,
+        register = _useForm.register,
+        errors = _useForm.formState.errors;
+
+    var renderLinks = function renderLinks(links, title) {
+      return /*#__PURE__*/React__default.createElement("div", {
+        className: "footer__link-container"
+      }, /*#__PURE__*/React__default.createElement("div", {
+        className: "footer__link-title"
+      }, title), /*#__PURE__*/React__default.createElement("div", {
+        className: "footer__links"
+      }, !!links.length && links.map(function (link) {
+        return /*#__PURE__*/React__default.createElement(GALink, {
+          key: link.label,
+          instance: link.instance,
+          href: link.href,
+          label: link.label,
+          className: "footer__link",
+          rel: "noopener noreferrer",
+          track: link === null || link === void 0 ? void 0 : link.track,
+          target: link.target
+        }, link.iconClassName && /*#__PURE__*/React__default.createElement("i", {
+          className: link.iconClassName
+        }), link.label);
+      })));
+    };
+
+    return /*#__PURE__*/React__default.createElement(FooterWrapper, null, showNewsletter && /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__newsletter-section"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__title-wrapper"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__newsletter-title"
+    }, "Sign up to our news letter"), /*#__PURE__*/React__default.createElement("p", {
+      className: "footer__newsletter-text"
+    }, "By signing up you agree to our terms & conditions and privacy policy. You can unsubscribe anytime.")), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__newsletter-form"
+    }, /*#__PURE__*/React__default.createElement("form", {
+      onSubmit: handleSubmit(onSubmit)
+    }, /*#__PURE__*/React__default.createElement("input", _extends({}, register('email', {
+      required: 'The email field is required.',
+      pattern: {
+        value: /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i,
+        message: 'Invalid email address'
+      }
+    }), {
+      placeholder: "Your Sexy Email",
+      className: "footer__form-input"
+    })), errors.email && /*#__PURE__*/React__default.createElement("span", {
+      className: "footer__form-errors"
+    }, errors.email.message), /*#__PURE__*/React__default.createElement("button", {
+      type: "submit"
+    }, /*#__PURE__*/React__default.createElement("img", {
+      className: "footer__newsletter-icon",
+      src: formIconSrc,
+      alt: "submit"
+    }))))), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__wrapper footer__wrapper--desktop"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__main-section"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__logo-wrapper"
+    }, /*#__PURE__*/React__default.createElement("img", {
+      className: "footer__logo",
+      src: logoSrc,
+      alt: "luxity-logo"
+    })), renderLinks(buyLinks, 'Buy'), /*#__PURE__*/React__default.createElement("div", null, renderLinks(sellLinks, 'Sell'), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__link-child"
+    }, renderLinks(companyLinks, 'Company'))), renderLinks(helpLinks, 'Help'), renderLinks(socialLinks, 'Follow us'), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__link-container"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__link-title"
+    }, "Contact"), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__links"
+    }, !!contactLinks.map && contactLinks.map(function (link) {
+      return !link.isContact ? /*#__PURE__*/React__default.createElement(GALink, {
+        key: link.label,
+        instance: link.instance,
+        href: link.href,
+        label: link.label,
+        className: "footer__link",
+        rel: "noopener noreferrer",
+        track: link === null || link === void 0 ? void 0 : link.track,
+        target: link.target
+      }, link.label) : /*#__PURE__*/React__default.createElement("div", {
+        className: "footer__text"
+      }, link.label);
+    })), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__store-hours"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__text"
+    }, "Monday - Friday"), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__text"
+    }, "8:30am - 5pm")))), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__copyrights-section"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__payment-icons"
+    }, /*#__PURE__*/React__default.createElement("img", {
+      alt: "visa",
+      src: masterCardSrc
+    }), /*#__PURE__*/React__default.createElement("img", {
+      src: visaImgSrc,
+      alt: "button"
+    })), /*#__PURE__*/React__default.createElement("p", {
+      className: "footer__copyright"
+    }, "Copyright ", currentYear, " | Luxity (Pty) LTD | All Rights Reserved | Website Developed by B Online"))), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__wrapper footer__wrapper--mobile"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__section-row"
+    }, renderLinks(quickiesLinks, 'Quickies'), renderLinks(socialLinks, 'Follow us')), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__section-row"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__link-container"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__link-title"
+    }, "We love"), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__links"
+    }, /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__text"
+    }, "Visa"), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__text"
+    }, "Mastercard"), /*#__PURE__*/React__default.createElement("div", {
+      className: "footer__text"
+    }, "EFT"))), renderLinks(helpLinks, 'Legal Stuff')), /*#__PURE__*/React__default.createElement("p", {
+      className: "footer__copyright footer__copyright--mobile"
+    }, "Copyright ", currentYear, " | Luxity (Pty) LTD | All Rights Reserved | Website Developed by B Online")));
+  };
+
+  var index = themed(LuxityFooter);
+
+  return index;
+
+})));