@bonlineza/luxity-lib 2.39.5 → 2.39.6

package/LuxityFooter.js

@@ -1,2309 +1,2301 @@
-(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];
-          }
+import React, { forwardRef, useState, useRef } from 'react';
+import styled, { ThemeProvider, css } from 'styled-components';
+
+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);
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+function _taggedTemplateLiteral(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
   }
 
-  function _taggedTemplateLiteral(strings, raw) {
-    if (!raw) {
-      raw = strings.slice(0);
+  return Object.freeze(Object.defineProperties(strings, {
+    raw: {
+      value: Object.freeze(raw)
     }
+  }));
+}
 
-    return Object.freeze(Object.defineProperties(strings, {
-      raw: {
-        value: Object.freeze(raw)
-      }
-    }));
-  }
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
 
-  function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-  }
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
 
-  function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
-  }
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
 
-  function _iterableToArrayLimit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
 
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
+  var _s, _e;
 
-    var _s, _e;
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
 
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
     try {
-      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
-        _arr.push(_s.value);
-
-        if (i && _arr.length === i) break;
-      }
-    } catch (err) {
-      _d = true;
-      _e = err;
+      if (!_n && _i["return"] != null) _i["return"]();
     } finally {
-      try {
-        if (!_n && _i["return"] != null) _i["return"]();
-      } finally {
-        if (_d) throw _e;
-      }
+      if (_d) throw _e;
     }
-
-    return _arr;
   }
 
-  function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-  }
+  return _arr;
+}
 
-  function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
 
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
 
-    return arr2;
-  }
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
 
-  function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
+  return arr2;
+}
 
-  var isCheckBoxInput = (element) => element.type === 'checkbox';
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 
-  var isDateObject = (value) => value instanceof Date;
+var isCheckBoxInput = (element) => element.type === 'checkbox';
 
-  var isNullOrUndefined = (value) => value == null;
+var isDateObject = (value) => value instanceof Date;
 
-  const isObjectType = (value) => typeof value === 'object';
-  var isObject = (value) => !isNullOrUndefined(value) &&
-      !Array.isArray(value) &&
-      isObjectType(value) &&
-      !isDateObject(value);
+var isNullOrUndefined = (value) => value == null;
 
-  var getEventValue = (event) => isObject(event) && event.target
-      ? isCheckBoxInput(event.target)
-          ? event.target.checked
-          : event.target.value
-      : event;
+const isObjectType = (value) => typeof value === 'object';
+var isObject = (value) => !isNullOrUndefined(value) &&
+    !Array.isArray(value) &&
+    isObjectType(value) &&
+    !isDateObject(value);
 
-  var getNodeParentName = (name) => name.substring(0, name.search(/\.\d+(\.|$)/)) || name;
+var getEventValue = (event) => isObject(event) && event.target
+    ? isCheckBoxInput(event.target)
+        ? event.target.checked
+        : event.target.value
+    : event;
 
-  var isNameInFieldArray = (names, name) => names.has(getNodeParentName(name));
+var getNodeParentName = (name) => name.substring(0, name.search(/\.\d+(\.|$)/)) || name;
 
-  var isPlainObject = (tempObject) => {
-      const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
-      return (isObject(prototypeCopy) && prototypeCopy.hasOwnProperty('isPrototypeOf'));
-  };
+var isNameInFieldArray = (names, name) => names.has(getNodeParentName(name));
 
-  var isWeb = typeof window !== 'undefined' &&
-      typeof window.HTMLElement !== 'undefined' &&
-      typeof document !== 'undefined';
+var isPlainObject = (tempObject) => {
+    const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
+    return (isObject(prototypeCopy) && prototypeCopy.hasOwnProperty('isPrototypeOf'));
+};
 
-  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 isWeb = typeof window !== 'undefined' &&
+    typeof window.HTMLElement !== 'undefined' &&
+    typeof document !== 'undefined';
 
-  var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
+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 isUndefined = (val) => val === undefined;
+var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
 
-  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;
-  };
+var isUndefined = (val) => val === undefined;
 
-  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',
-  };
+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.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.useRef(props);
+    _props.current = props;
+    React.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,
+        };
+    }
+}
 
-  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 getValueAndMessage = (validationData) => isObject(validationData) && !isRegex(validationData)
+    ? validationData
+    : {
+        value: validationData,
+        message: '',
+    };
 
-  var isEmptyObject = (value) => isObject(value) && !Object.keys(value).length;
+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 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 isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
 
-  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]);
-  }
+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 isString = (value) => typeof value === 'string';
+var isMultipleSelect = (element) => element.type === `select-multiple`;
 
-  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 isRadioOrCheckbox = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);
 
-  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 live = (ref) => isHTMLElement(ref) && ref.isConnected;
 
-  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 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 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 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.useRef();
+    const _values = React.useRef();
+    const [formState, updateFormState] = React.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.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.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__*/forwardRef(function (props, ref) {
+    return /*#__PURE__*/React.createElement(ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/React.createElement(Component, _extends({}, props, {
+      ref: ref
+    })));
   });
+});
+
+var _templateObject;
+var FooterWrapper = styled.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 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 GALink = function GALink(props) {
+  var gaOnClick = function gaOnClick(event) {
+    Event(props.instance, props.track, 'Link', "Click on ".concat(props.href), props.label);
 
-  var isHTMLElement = (value) => {
-      if (!isWeb) {
-          return false;
-      }
-      const owner = value ? value.ownerDocument : 0;
-      return (value instanceof
-          (owner && owner.defaultView ? owner.defaultView.HTMLElement : HTMLElement));
+    if (typeof props.onClick === 'function') {
+      props.onClick(event);
+    }
   };
 
-  var isMessage = (value) => isString(value);
-
-  var isRadioInput = (element) => element.type === 'radio';
-
-  var isRegex = (value) => value instanceof RegExp;
+  return /*#__PURE__*/React.createElement("a", _extends({
+    href: "/"
+  }, props, {
+    onClick: gaOnClick
+  }), props.children);
+};
+
+var _templateObject$1, _templateObject2, _templateObject3, _templateObject4, _templateObject5;
+/* position relative is required for the Body element to be positioned correctly */
+
+var relativeInlineStyle = css(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral(["\n  position: relative;\n"])));
+var topMiddleBodyStyle = css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  position: absolute;\n  z-index: 1;\n  bottom: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n"])));
+var getTopMiddleArrowAfterStyle = function getTopMiddleArrowAfterStyle(props) {
+  return css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  /*Bottom Arrow*/\n  top: 100%; /* At the bottom of the tooltip */\n  left: calc(50% - ", ");\n  border-width: ", ";\n  border-style: solid;\n  border-color: ", " transparent transparent transparent;\n"])), props.$apexWidth, props.$apexWidth, props.theme.colors.base);
+};
+var getBottomMiddleBodyStyle = function getBottomMiddleBodyStyle(props) {
+  return css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  position: absolute;\n  top: 100%;\n  left: calc(50% - ", " / 2);\n"])), props.$bodyWidth);
+};
+var getBottomMiddleArrowAfterStyle = function getBottomMiddleArrowAfterStyle(props) {
+  return css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  /*Top Arrow*/\n  bottom: 100%; /* At the top of the tooltip */\n  top: initial;\n  left: 50%;\n  border-style: solid;\n  border-color: transparent transparent ", " transparent;\n"])), props.theme.colors.base);
+};
+
+var _templateObject$2;
+
+var getBodyStyle = function getBodyStyle() {
+  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _props$$toolTipPositi = props.$toolTipPosition,
+      $toolTipPosition = _props$$toolTipPositi === void 0 ? '' : _props$$toolTipPositi;
+
+  switch ($toolTipPosition) {
+    case 'top':
+      return topMiddleBodyStyle;
+
+    case 'bottom':
+      return getBottomMiddleBodyStyle(props);
+
+    default:
+      return null;
+  }
+};
 
-  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;
-  };
+var getAfterStyling = function getAfterStyling() {
+  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var $toolTipPosition = props.$toolTipPosition;
 
-  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,
-          };
-      }
-  }
+  switch ($toolTipPosition) {
+    case 'top':
+      return getTopMiddleArrowAfterStyle(props);
 
-  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;
-  };
+    case 'bottom':
+      return getBottomMiddleArrowAfterStyle(props);
 
-  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;
+    default:
+      return '';
   }
-  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;
+};
+
+var Body = styled.span(_templateObject$2 || (_templateObject$2 = _taggedTemplateLiteral(["\n  ", ";\n  visibility: hidden;\n  opacity: 0;\n  width: ", ";\n  transition: visibility 0.3s linear, opacity 0.3s linear;\n  background-color: ", ";\n  color: white;\n  text-align: center;\n  border-radius: 5px;\n  ", "\n  &::after {\n    content: ' ';\n    position: absolute;\n    ", "\n  }\n"])), relativeInlineStyle, function (props) {
+  return props.$bodyWidth;
+}, function (props) {
+  return props.theme.colors.base || 'black';
+}, function (props) {
+  return getBodyStyle(props);
+}, function (props) {
+  return getAfterStyling(props);
+});
+
+var _templateObject$3;
+var Container = styled.div(_templateObject$3 || (_templateObject$3 = _taggedTemplateLiteral(["\n  ", ";\n  cursor: pointer;\n  &:hover ", " {\n    opacity: 1;\n    visibility: visible;\n  }\n"])), relativeInlineStyle, Body);
+
+/* eslint-disable react/require-default-props */
+
+var Tooltip = function Tooltip(_ref) {
+  var _ref$children = _ref.children,
+      children = _ref$children === void 0 ? null : _ref$children,
+      _ref$toolTipText = _ref.toolTipText,
+      toolTipText = _ref$toolTipText === void 0 ? '' : _ref$toolTipText,
+      _ref$toolTipPosition = _ref.toolTipPosition,
+      toolTipPosition = _ref$toolTipPosition === void 0 ? 'top' : _ref$toolTipPosition,
+      _ref$bodyWidth = _ref.bodyWidth,
+      bodyWidth = _ref$bodyWidth === void 0 ? '8em' : _ref$bodyWidth,
+      _ref$apexWidth = _ref.apexWidth,
+      apexWidth = _ref$apexWidth === void 0 ? '5px' : _ref$apexWidth,
+      _ref$containerClassNa = _ref.containerClassName,
+      containerClassName = _ref$containerClassNa === void 0 ? '' : _ref$containerClassNa,
+      _ref$bodyClassName = _ref.bodyClassName,
+      bodyClassName = _ref$bodyClassName === void 0 ? '' : _ref$bodyClassName;
+  return /*#__PURE__*/React.createElement(Container, {
+    className: containerClassName
+  }, children, /*#__PURE__*/React.createElement(Body, {
+    $toolTipPosition: toolTipPosition,
+    $bodyWidth: bodyWidth,
+    $apexWidth: apexWidth,
+    className: bodyClassName
+  }, toolTipText));
+};
+
+var Tooltip$1 = themed(Tooltip);
+
+var CurrencySelect = function CurrencySelect(_ref) {
+  var currency = _ref.currency,
+      currencyOptions = _ref.currencyOptions,
+      onCurrencyChange = _ref.onCurrencyChange,
+      _ref$isCurrencySelect = _ref.isCurrencySelectionDisabled,
+      isCurrencySelectionDisabled = _ref$isCurrencySelect === void 0 ? false : _ref$isCurrencySelect,
+      _ref$tooltipContent = _ref.tooltipContent,
+      tooltipContent = _ref$tooltipContent === void 0 ? '' : _ref$tooltipContent;
+
+  if (!currencyOptions || currencyOptions.length === 0) {
+    return null;
   }
 
-  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);
+  var selectedOption = currencyOptions.find(function (opt) {
+    return opt.value === currency;
+  });
 
-  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;
+  if (!selectedOption) {
+    return null;
   }
 
-  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;
+  return /*#__PURE__*/React.createElement(Tooltip$1, {
+    toolTipText: isCurrencySelectionDisabled ? tooltipContent : '',
+    toolTipPosition: "bottom",
+    bodyWidth: "160px"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "currency-select-container ".concat(isCurrencySelectionDisabled ? 'disabled' : '')
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "currency-flag"
+  }, /*#__PURE__*/React.createElement("img", {
+    src: selectedOption.flagSrc,
+    alt: "".concat(currency, " flag")
+  })), /*#__PURE__*/React.createElement("select", {
+    value: currency,
+    onChange: function onChange(e) {
+      return onCurrencyChange(e.target.value);
+    },
+    className: "currency-select",
+    disabled: isCurrencySelectionDisabled
+  }, currencyOptions.map(function (option) {
+    return /*#__PURE__*/React.createElement("option", {
+      key: option.value,
+      value: option.value
+    }, option.value, " (", option.symbol, ")");
+  }))));
+};
+
+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$companyLinks = _ref.companyLinks,
+      companyLinks = _ref$companyLinks === void 0 ? [] : _ref$companyLinks,
+      _ref$storeLinks = _ref.storeLinks,
+      storeLinks = _ref$storeLinks === void 0 ? [] : _ref$storeLinks,
+      _ref$popularLinks = _ref.popularLinks,
+      popularLinks = _ref$popularLinks === void 0 ? [] : _ref$popularLinks,
+      _ref$socialLinks = _ref.socialLinks,
+      socialLinks = _ref$socialLinks === void 0 ? [] : _ref$socialLinks,
+      _ref$contactLinks = _ref.contactLinks,
+      contactLinks = _ref$contactLinks === void 0 ? [] : _ref$contactLinks,
+      visaImgSrc = _ref.visaImgSrc,
+      masterCardSrc = _ref.masterCardSrc,
+      logoSrc = _ref.logoSrc,
+      formIconSrc = _ref.formIconSrc,
+      onSubmit = _ref.onSubmit,
+      currency = _ref.currency,
+      currencyOptions = _ref.currencyOptions,
+      onCurrencyChange = _ref.onCurrencyChange,
+      isCurrencySelectionDisabled = _ref.isCurrencySelectionDisabled,
+      tooltipContent = _ref.tooltipContent;
+  var currentYear = new Date().getFullYear();
+
+  var _useForm = useForm(),
+      handleSubmit = _useForm.handleSubmit,
+      register = _useForm.register,
+      errors = _useForm.formState.errors,
+      reset = _useForm.reset,
+      setError = _useForm.setError;
+
+  var renderLinks = function renderLinks(links, title) {
+    return !!links.length && /*#__PURE__*/React.createElement("div", {
+      className: "footer__link-container"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "footer__link-title"
+    }, title), /*#__PURE__*/React.createElement("div", {
+      className: "footer__links"
+    }, links.map(function (link) {
+      return /*#__PURE__*/React.createElement("div", {
+        className: "footer__link-wrapper",
+        key: link.label
+      }, link.icon && /*#__PURE__*/React.createElement("img", {
+        className: "footer__link-icon",
+        src: link.icon,
+        alt: link.label
+      }), /*#__PURE__*/React.createElement(GALink, {
+        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.createElement("i", {
+        className: link.iconClassName
+      }), link.label));
+    })));
   };
 
-  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 renderSocialLinks = function renderSocialLinks(links) {
+    return /*#__PURE__*/React.createElement("div", {
+      className: "footer__link-container"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "flex gap-2 mb-5"
+    }, links.map(function (link) {
+      return /*#__PURE__*/React.createElement("a", {
+        key: link.label,
+        href: link.href,
+        target: "_blank",
+        rel: "noopener noreferrer",
+        className: ""
+      }, link.icon && /*#__PURE__*/React.createElement("img", {
+        className: "footer__link-icon",
+        src: link.icon,
+        alt: link.label,
+        width: 30,
+        height: 30
+      }));
+    })), /*#__PURE__*/React.createElement("div", {
+      className: "footer__links"
+    }, !!contactLinks.map && contactLinks.map(function (link) {
+      return !link.isContact ? /*#__PURE__*/React.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.createElement("div", {
+        key: link.label,
+        className: "footer__text"
+      }, link.label);
+    })));
   };
 
-  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,
-          };
+  var AccordionSection = function AccordionSection(_ref2) {
+    var title = _ref2.title,
+        links = _ref2.links;
+
+    var _useState = useState(false),
+        _useState2 = _slicedToArray(_useState, 2),
+        isOpen = _useState2[0],
+        setIsOpen = _useState2[1];
+
+    var contentRef = useRef(null);
+    return /*#__PURE__*/React.createElement("div", {
+      className: "border-b border-gray-200"
+    }, /*#__PURE__*/React.createElement("button", {
+      type: "button",
+      className: "w-full py-3 px-3 flex justify-between items-center",
+      onClick: function onClick() {
+        return setIsOpen(!isOpen);
       }
-      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;
+    }, /*#__PURE__*/React.createElement("span", {
+      className: "footer__link-title"
+    }, title), /*#__PURE__*/React.createElement("span", null, isOpen ? '-' : '+')), /*#__PURE__*/React.createElement("div", {
+      ref: contentRef,
+      className: "px-3 overflow-hidden transition-all duration-500 ease-in-out",
+      style: {
+        maxHeight: isOpen ? "".concat(contentRef.current.scrollHeight, "px") : '0'
       }
-      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;
+    }, links.map(function (link) {
+      return /*#__PURE__*/React.createElement("a", {
+        key: link.label,
+        href: link.href,
+        className: "footer__link block"
+      }, link.label);
+    })));
   };
 
-  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,
-          };
+  var submitForm = function submitForm(data) {
+    onSubmit(data).then(function (res) {
+      if (res.success) {
+        reset();
+      } else {
+        setError('email', {
+          type: 'custom',
+          message: res.errorMessage
+        });
       }
-      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 _templateObject$1, _templateObject2, _templateObject3, _templateObject4, _templateObject5;
-  /* position relative is required for the Body element to be positioned correctly */
-
-  var relativeInlineStyle = styled.css(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral(["\n  position: relative;\n"])));
-  var topMiddleBodyStyle = styled.css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  position: absolute;\n  z-index: 1;\n  bottom: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n"])));
-  var getTopMiddleArrowAfterStyle = function getTopMiddleArrowAfterStyle(props) {
-    return styled.css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  /*Bottom Arrow*/\n  top: 100%; /* At the bottom of the tooltip */\n  left: calc(50% - ", ");\n  border-width: ", ";\n  border-style: solid;\n  border-color: ", " transparent transparent transparent;\n"])), props.$apexWidth, props.$apexWidth, props.theme.colors.base);
-  };
-  var getBottomMiddleBodyStyle = function getBottomMiddleBodyStyle(props) {
-    return styled.css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  position: absolute;\n  top: 100%;\n  left: calc(50% - ", " / 2);\n"])), props.$bodyWidth);
-  };
-  var getBottomMiddleArrowAfterStyle = function getBottomMiddleArrowAfterStyle(props) {
-    return styled.css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  /*Top Arrow*/\n  bottom: 100%; /* At the top of the tooltip */\n  top: initial;\n  left: 50%;\n  border-style: solid;\n  border-color: transparent transparent ", " transparent;\n"])), props.theme.colors.base);
-  };
-
-  var _templateObject$2;
-
-  var getBodyStyle = function getBodyStyle() {
-    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var _props$$toolTipPositi = props.$toolTipPosition,
-        $toolTipPosition = _props$$toolTipPositi === void 0 ? '' : _props$$toolTipPositi;
-
-    switch ($toolTipPosition) {
-      case 'top':
-        return topMiddleBodyStyle;
-
-      case 'bottom':
-        return getBottomMiddleBodyStyle(props);
-
-      default:
-        return null;
-    }
   };
 
-  var getAfterStyling = function getAfterStyling() {
-    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var $toolTipPosition = props.$toolTipPosition;
-
-    switch ($toolTipPosition) {
-      case 'top':
-        return getTopMiddleArrowAfterStyle(props);
-
-      case 'bottom':
-        return getBottomMiddleArrowAfterStyle(props);
-
-      default:
-        return '';
+  return /*#__PURE__*/React.createElement(FooterWrapper, null, showNewsletter && /*#__PURE__*/React.createElement("div", {
+    className: "footer__newsletter-section"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "footer__newsletter-wrapper"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "footer__title-wrapper"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "footer__newsletter-title"
+  }, "Sign up for our newsletter"), /*#__PURE__*/React.createElement("p", {
+    className: "footer__newsletter-text"
+  }, "By signing up you agree to our terms & conditions and privacy policy. You can unsubscribe anytime.")), /*#__PURE__*/React.createElement("div", {
+    className: "footer__newsletter-form"
+  }, /*#__PURE__*/React.createElement("form", {
+    onSubmit: handleSubmit(submitForm)
+  }, /*#__PURE__*/React.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'
     }
-  };
-
-  var Body = styled__default.span(_templateObject$2 || (_templateObject$2 = _taggedTemplateLiteral(["\n  ", ";\n  visibility: hidden;\n  opacity: 0;\n  width: ", ";\n  transition: visibility 0.3s linear, opacity 0.3s linear;\n  background-color: ", ";\n  color: white;\n  text-align: center;\n  border-radius: 5px;\n  ", "\n  &::after {\n    content: ' ';\n    position: absolute;\n    ", "\n  }\n"])), relativeInlineStyle, function (props) {
-    return props.$bodyWidth;
-  }, function (props) {
-    return props.theme.colors.base || 'black';
-  }, function (props) {
-    return getBodyStyle(props);
-  }, function (props) {
-    return getAfterStyling(props);
-  });
-
-  var _templateObject$3;
-  var Container = styled__default.div(_templateObject$3 || (_templateObject$3 = _taggedTemplateLiteral(["\n  ", ";\n  cursor: pointer;\n  &:hover ", " {\n    opacity: 1;\n    visibility: visible;\n  }\n"])), relativeInlineStyle, Body);
-
-  /* eslint-disable react/require-default-props */
-
-  var Tooltip = function Tooltip(_ref) {
-    var _ref$children = _ref.children,
-        children = _ref$children === void 0 ? null : _ref$children,
-        _ref$toolTipText = _ref.toolTipText,
-        toolTipText = _ref$toolTipText === void 0 ? '' : _ref$toolTipText,
-        _ref$toolTipPosition = _ref.toolTipPosition,
-        toolTipPosition = _ref$toolTipPosition === void 0 ? 'top' : _ref$toolTipPosition,
-        _ref$bodyWidth = _ref.bodyWidth,
-        bodyWidth = _ref$bodyWidth === void 0 ? '8em' : _ref$bodyWidth,
-        _ref$apexWidth = _ref.apexWidth,
-        apexWidth = _ref$apexWidth === void 0 ? '5px' : _ref$apexWidth,
-        _ref$containerClassNa = _ref.containerClassName,
-        containerClassName = _ref$containerClassNa === void 0 ? '' : _ref$containerClassNa,
-        _ref$bodyClassName = _ref.bodyClassName,
-        bodyClassName = _ref$bodyClassName === void 0 ? '' : _ref$bodyClassName;
-    return /*#__PURE__*/React__default.createElement(Container, {
-      className: containerClassName
-    }, children, /*#__PURE__*/React__default.createElement(Body, {
-      $toolTipPosition: toolTipPosition,
-      $bodyWidth: bodyWidth,
-      $apexWidth: apexWidth,
-      className: bodyClassName
-    }, toolTipText));
-  };
-
-  var Tooltip$1 = themed(Tooltip);
-
-  var CurrencySelect = function CurrencySelect(_ref) {
-    var currency = _ref.currency,
-        currencyOptions = _ref.currencyOptions,
-        onCurrencyChange = _ref.onCurrencyChange,
-        _ref$isCurrencySelect = _ref.isCurrencySelectionDisabled,
-        isCurrencySelectionDisabled = _ref$isCurrencySelect === void 0 ? false : _ref$isCurrencySelect,
-        _ref$tooltipContent = _ref.tooltipContent,
-        tooltipContent = _ref$tooltipContent === void 0 ? '' : _ref$tooltipContent;
-
-    if (!currencyOptions || currencyOptions.length === 0) {
-      return null;
-    }
-
-    var selectedOption = currencyOptions.find(function (opt) {
-      return opt.value === currency;
-    });
-
-    if (!selectedOption) {
-      return null;
-    }
-
-    return /*#__PURE__*/React__default.createElement(Tooltip$1, {
-      toolTipText: isCurrencySelectionDisabled ? tooltipContent : '',
-      toolTipPosition: "bottom",
-      bodyWidth: "160px"
-    }, /*#__PURE__*/React__default.createElement("div", {
-      className: "currency-select-container ".concat(isCurrencySelectionDisabled ? 'disabled' : '')
-    }, /*#__PURE__*/React__default.createElement("div", {
-      className: "currency-flag"
-    }, /*#__PURE__*/React__default.createElement("img", {
-      src: selectedOption.flagSrc,
-      alt: "".concat(currency, " flag")
-    })), /*#__PURE__*/React__default.createElement("select", {
-      value: currency,
-      onChange: function onChange(e) {
-        return onCurrencyChange(e.target.value);
-      },
-      className: "currency-select",
-      disabled: isCurrencySelectionDisabled
-    }, currencyOptions.map(function (option) {
-      return /*#__PURE__*/React__default.createElement("option", {
-        key: option.value,
-        value: option.value
-      }, option.value, " (", option.symbol, ")");
-    }))));
-  };
-
-  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$companyLinks = _ref.companyLinks,
-        companyLinks = _ref$companyLinks === void 0 ? [] : _ref$companyLinks,
-        _ref$storeLinks = _ref.storeLinks,
-        storeLinks = _ref$storeLinks === void 0 ? [] : _ref$storeLinks,
-        _ref$popularLinks = _ref.popularLinks,
-        popularLinks = _ref$popularLinks === void 0 ? [] : _ref$popularLinks,
-        _ref$socialLinks = _ref.socialLinks,
-        socialLinks = _ref$socialLinks === void 0 ? [] : _ref$socialLinks,
-        _ref$contactLinks = _ref.contactLinks,
-        contactLinks = _ref$contactLinks === void 0 ? [] : _ref$contactLinks,
-        visaImgSrc = _ref.visaImgSrc,
-        masterCardSrc = _ref.masterCardSrc,
-        logoSrc = _ref.logoSrc,
-        formIconSrc = _ref.formIconSrc,
-        onSubmit = _ref.onSubmit,
-        currency = _ref.currency,
-        currencyOptions = _ref.currencyOptions,
-        onCurrencyChange = _ref.onCurrencyChange,
-        isCurrencySelectionDisabled = _ref.isCurrencySelectionDisabled,
-        tooltipContent = _ref.tooltipContent;
-    var currentYear = new Date().getFullYear();
-
-    var _useForm = useForm(),
-        handleSubmit = _useForm.handleSubmit,
-        register = _useForm.register,
-        errors = _useForm.formState.errors,
-        reset = _useForm.reset,
-        setError = _useForm.setError;
-
-    var renderLinks = function renderLinks(links, title) {
-      return !!links.length && /*#__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.map(function (link) {
-        return /*#__PURE__*/React__default.createElement("div", {
-          className: "footer__link-wrapper",
-          key: link.label
-        }, link.icon && /*#__PURE__*/React__default.createElement("img", {
-          className: "footer__link-icon",
-          src: link.icon,
-          alt: link.label
-        }), /*#__PURE__*/React__default.createElement(GALink, {
-          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));
-      })));
-    };
-
-    var renderSocialLinks = function renderSocialLinks(links) {
-      return /*#__PURE__*/React__default.createElement("div", {
-        className: "footer__link-container"
-      }, /*#__PURE__*/React__default.createElement("div", {
-        className: "flex gap-2 mb-5"
-      }, links.map(function (link) {
-        return /*#__PURE__*/React__default.createElement("a", {
-          key: link.label,
-          href: link.href,
-          target: "_blank",
-          rel: "noopener noreferrer",
-          className: ""
-        }, link.icon && /*#__PURE__*/React__default.createElement("img", {
-          className: "footer__link-icon",
-          src: link.icon,
-          alt: link.label,
-          width: 30,
-          height: 30
-        }));
-      })), /*#__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", {
-          key: link.label,
-          className: "footer__text"
-        }, link.label);
-      })));
-    };
-
-    var AccordionSection = function AccordionSection(_ref2) {
-      var title = _ref2.title,
-          links = _ref2.links;
-
-      var _useState = React.useState(false),
-          _useState2 = _slicedToArray(_useState, 2),
-          isOpen = _useState2[0],
-          setIsOpen = _useState2[1];
-
-      var contentRef = React.useRef(null);
-      return /*#__PURE__*/React__default.createElement("div", {
-        className: "border-b border-gray-200"
-      }, /*#__PURE__*/React__default.createElement("button", {
-        type: "button",
-        className: "w-full py-3 px-3 flex justify-between items-center",
-        onClick: function onClick() {
-          return setIsOpen(!isOpen);
-        }
-      }, /*#__PURE__*/React__default.createElement("span", {
-        className: "footer__link-title"
-      }, title), /*#__PURE__*/React__default.createElement("span", null, isOpen ? '-' : '+')), /*#__PURE__*/React__default.createElement("div", {
-        ref: contentRef,
-        className: "px-3 overflow-hidden transition-all duration-500 ease-in-out",
-        style: {
-          maxHeight: isOpen ? "".concat(contentRef.current.scrollHeight, "px") : '0'
-        }
-      }, links.map(function (link) {
-        return /*#__PURE__*/React__default.createElement("a", {
-          key: link.label,
-          href: link.href,
-          className: "footer__link block"
-        }, link.label);
-      })));
-    };
-
-    var submitForm = function submitForm(data) {
-      onSubmit(data).then(function (res) {
-        if (res.success) {
-          reset();
-        } else {
-          setError('email', {
-            type: 'custom',
-            message: res.errorMessage
-          });
-        }
-      });
-    };
-
-    return /*#__PURE__*/React__default.createElement(FooterWrapper, null, showNewsletter && /*#__PURE__*/React__default.createElement("div", {
-      className: "footer__newsletter-section"
-    }, /*#__PURE__*/React__default.createElement("div", {
-      className: "footer__newsletter-wrapper"
-    }, /*#__PURE__*/React__default.createElement("div", {
-      className: "footer__title-wrapper"
-    }, /*#__PURE__*/React__default.createElement("div", {
-      className: "footer__newsletter-title"
-    }, "Sign up for our newsletter"), /*#__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(submitForm)
-    }, /*#__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'), renderLinks(popularLinks, 'Popular'), renderLinks(sellLinks, 'Sell'), renderLinks(companyLinks, 'Company'), renderLinks(storeLinks, 'Connect'), renderSocialLinks(socialLinks)), /*#__PURE__*/React__default.createElement("div", {
-      className: "footer__copyrights-section"
-    }, /*#__PURE__*/React__default.createElement("div", {
-      className: "footer__payment-icons"
-    }, /*#__PURE__*/React__default.createElement("img", {
-      src: masterCardSrc,
-      alt: "mastercard",
-      width: 100,
-      height: 100
-    }), /*#__PURE__*/React__default.createElement("img", {
-      src: visaImgSrc,
-      alt: "visa",
-      width: 70,
-      height: 70
-    })), /*#__PURE__*/React__default.createElement("p", {
-      className: "footer__copyright"
-    }, "Copyright ", currentYear, " | Luxity (Pty) LTD | All Rights Reserved"))), /*#__PURE__*/React__default.createElement("div", {
-      className: "footer__wrapper footer__wrapper--mobile"
-    }, /*#__PURE__*/React__default.createElement(CurrencySelect, {
-      currency: currency,
-      currencyOptions: currencyOptions,
-      onCurrencyChange: onCurrencyChange,
-      isCurrencySelectionDisabled: isCurrencySelectionDisabled,
-      tooltipContent: tooltipContent
-    }), /*#__PURE__*/React__default.createElement(AccordionSection, {
-      title: "BUY",
-      links: buyLinks
-    }), /*#__PURE__*/React__default.createElement(AccordionSection, {
-      title: "POPULAR",
-      links: popularLinks
-    }), !!sellLinks.length && /*#__PURE__*/React__default.createElement(AccordionSection, {
-      title: "SELL",
-      links: sellLinks
-    }), /*#__PURE__*/React__default.createElement(AccordionSection, {
-      title: "COMPANY",
-      links: companyLinks
-    }), !!storeLinks.length && /*#__PURE__*/React__default.createElement(AccordionSection, {
-      title: "CONNECT",
-      links: storeLinks
-    }), /*#__PURE__*/React__default.createElement("div", {
-      className: "mt-5"
-    }, renderSocialLinks(socialLinks)), /*#__PURE__*/React__default.createElement("p", {
-      className: "footer__copyright footer__copyright--mobile"
-    }, "Copyright ", currentYear, " | Luxity (Pty) LTD | All Rights Reserved")));
-  };
-
-  var index = themed(LuxityFooter);
-
-  return index;
-
-})));
+  }), {
+    placeholder: "Your Sexy Email",
+    className: "footer__form-input"
+  })), errors.email && /*#__PURE__*/React.createElement("span", {
+    className: "footer__form-errors"
+  }, errors.email.message), /*#__PURE__*/React.createElement("button", {
+    type: "submit"
+  }, /*#__PURE__*/React.createElement("img", {
+    className: "footer__newsletter-icon",
+    src: formIconSrc,
+    alt: "submit"
+  })))))), /*#__PURE__*/React.createElement("div", {
+    className: "footer__wrapper footer__wrapper--desktop"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "footer__main-section"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "footer__logo-wrapper"
+  }, /*#__PURE__*/React.createElement("img", {
+    className: "footer__logo",
+    src: logoSrc,
+    alt: "luxity-logo"
+  })), renderLinks(buyLinks, 'Buy'), renderLinks(popularLinks, 'Popular'), renderLinks(sellLinks, 'Sell'), renderLinks(companyLinks, 'Company'), renderLinks(storeLinks, 'Connect'), renderSocialLinks(socialLinks)), /*#__PURE__*/React.createElement("div", {
+    className: "footer__copyrights-section"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "footer__payment-icons"
+  }, /*#__PURE__*/React.createElement("img", {
+    src: masterCardSrc,
+    alt: "mastercard",
+    width: 100,
+    height: 100
+  }), /*#__PURE__*/React.createElement("img", {
+    src: visaImgSrc,
+    alt: "visa",
+    width: 70,
+    height: 70
+  })), /*#__PURE__*/React.createElement("p", {
+    className: "footer__copyright"
+  }, "Copyright ", currentYear, " | Luxity (Pty) LTD | All Rights Reserved"))), /*#__PURE__*/React.createElement("div", {
+    className: "footer__wrapper footer__wrapper--mobile"
+  }, /*#__PURE__*/React.createElement(CurrencySelect, {
+    currency: currency,
+    currencyOptions: currencyOptions,
+    onCurrencyChange: onCurrencyChange,
+    isCurrencySelectionDisabled: isCurrencySelectionDisabled,
+    tooltipContent: tooltipContent
+  }), /*#__PURE__*/React.createElement(AccordionSection, {
+    title: "BUY",
+    links: buyLinks
+  }), /*#__PURE__*/React.createElement(AccordionSection, {
+    title: "POPULAR",
+    links: popularLinks
+  }), !!sellLinks.length && /*#__PURE__*/React.createElement(AccordionSection, {
+    title: "SELL",
+    links: sellLinks
+  }), /*#__PURE__*/React.createElement(AccordionSection, {
+    title: "COMPANY",
+    links: companyLinks
+  }), !!storeLinks.length && /*#__PURE__*/React.createElement(AccordionSection, {
+    title: "CONNECT",
+    links: storeLinks
+  }), /*#__PURE__*/React.createElement("div", {
+    className: "mt-5"
+  }, renderSocialLinks(socialLinks)), /*#__PURE__*/React.createElement("p", {
+    className: "footer__copyright footer__copyright--mobile"
+  }, "Copyright ", currentYear, " | Luxity (Pty) LTD | All Rights Reserved")));
+};
+
+var index = themed(LuxityFooter);
+
+export default index;