@regle/core 1.1.0-beta.1 → 1.1.0-beta.3

package/dist/regle-core.cjs

@@ -1,2710 +0,0 @@
-'use strict';
-
-var vue = require('vue');
-
-// ../shared/utils/isEmpty.ts
-function isEmpty(value, considerEmptyArrayInvalid = true) {
-  if (value === void 0 || value === null) {
-    return true;
-  }
-  if (value instanceof Date) {
-    return isNaN(value.getTime());
-  } else if (value.constructor.name == "File" || value.constructor.name == "FileList") {
-    return value.size <= 0;
-  } else if (Array.isArray(value)) {
-    if (considerEmptyArrayInvalid) {
-      return value.length === 0;
-    }
-    return false;
-  } else if (typeof value === "object" && value != null) {
-    return Object.keys(value).length === 0;
-  }
-  return !String(value).length;
-}
-
-// ../shared/utils/symbol.ts
-var RegleRuleSymbol = Symbol("regle-rule");
-
-// ../shared/utils/cloneDeep.ts
-function getRegExpFlags(regExp) {
-  if (typeof regExp.source.flags == "string") {
-    return regExp.source.flags;
-  } else {
-    let flags = [];
-    regExp.global && flags.push("g");
-    regExp.ignoreCase && flags.push("i");
-    regExp.multiline && flags.push("m");
-    regExp.sticky && flags.push("y");
-    regExp.unicode && flags.push("u");
-    return flags.join("");
-  }
-}
-function cloneDeep(obj) {
-  let result = obj;
-  let type = {}.toString.call(obj).slice(8, -1);
-  if (type == "Set") {
-    result = new Set([...obj].map((value) => cloneDeep(value)));
-  }
-  if (type == "Map") {
-    result = new Map([...obj].map((kv) => [cloneDeep(kv[0]), cloneDeep(kv[1])]));
-  }
-  if (type == "Date") {
-    result = new Date(obj.getTime());
-  }
-  if (type == "RegExp") {
-    result = RegExp(obj.source, getRegExpFlags(obj));
-  }
-  if (type == "Array" || type == "Object") {
-    result = Array.isArray(obj) ? [] : {};
-    for (let key in obj) {
-      result[key] = cloneDeep(obj[key]);
-    }
-  }
-  return result;
-}
-
-// ../shared/utils/object.utils.ts
-function isObject(obj) {
-  if (obj && (obj instanceof Date || obj.constructor.name == "File" || obj.constructor.name == "FileList")) {
-    return false;
-  }
-  return typeof obj === "object" && obj !== null && !Array.isArray(obj);
-}
-
-// ../shared/utils/toDate.ts
-function toDate(argument) {
-  const argStr = Object.prototype.toString.call(argument);
-  if (argument == null) {
-    return /* @__PURE__ */ new Date(NaN);
-  } else if (argument instanceof Date || typeof argument === "object" && argStr === "[object Date]") {
-    return new Date(argument.getTime());
-  } else if (typeof argument === "number" || argStr === "[object Number]") {
-    return new Date(argument);
-  } else if (typeof argument === "string" || argStr === "[object String]") {
-    return new Date(argument);
-  } else {
-    return /* @__PURE__ */ new Date(NaN);
-  }
-}
-
-// ../shared/utils/debounce.ts
-function debounce(func, wait, immediate) {
-  let timeout;
-  const debouncedFn = (...args) => new Promise((resolve) => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => {
-      timeout = void 0;
-      {
-        Promise.resolve(func.apply(this, [...args])).then(resolve);
-      }
-    }, wait);
-  });
-  debouncedFn.cancel = () => {
-    clearTimeout(timeout);
-    timeout = void 0;
-  };
-  return debouncedFn;
-}
-
-// src/types/rules/rule.internal.types.ts
-var InternalRuleType = {
-  Inline: "__inline",
-  Async: "__async"
-};
-function mergeBooleanGroupProperties(entries, property) {
-  return entries.some((entry) => {
-    return entry[property];
-  });
-}
-function mergeArrayGroupProperties(entries, property) {
-  return entries.reduce((all, entry) => {
-    const fetchedProperty = entry[property] || [];
-    return all.concat(fetchedProperty);
-  }, []);
-}
-function unwrapRuleParameters(params) {
-  try {
-    return params.map((param) => vue.toValue(param));
-  } catch (e) {
-    return [];
-  }
-}
-function createReactiveParams(params) {
-  return params.map((param) => {
-    if (param instanceof Function) {
-      return vue.computed(param);
-    } else if (vue.isRef(param)) {
-      return param;
-    }
-    return vue.toRef(() => param);
-  });
-}
-function getFunctionParametersLength(func) {
-  const funcStr = func.toString();
-  const cleanStr = funcStr.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
-  const paramsMatch = cleanStr.match(
-    /^(?:async\s*)?(?:function\b.*?\(|\((.*?)\)|(\w+))\s*=>|\((.*?)\)\s*=>|function.*?\((.*?)\)|\((.*?)\)/
-  );
-  if (!paramsMatch) return 0;
-  const paramsSection = paramsMatch[0] || paramsMatch[1] || paramsMatch[2] || paramsMatch[3] || paramsMatch[4] || "";
-  const paramList = paramsSection.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
-  return paramList.length;
-}
-
-// src/core/createRule/defineRuleProcessors.ts
-function defineRuleProcessors(definition, ...params) {
-  const { validator, type } = definition;
-  const isAsync = type === InternalRuleType.Async || validator.constructor.name === "AsyncFunction";
-  const defaultProcessors = {
-    validator(value, ...args) {
-      return definition.validator(value, ...unwrapRuleParameters(args.length ? args : params));
-    },
-    message(metadata) {
-      if (typeof definition.message === "function") {
-        return definition.message({
-          ...metadata,
-          $params: unwrapRuleParameters(metadata?.$params?.length ? metadata.$params : params)
-        });
-      } else {
-        return definition.message;
-      }
-    },
-    active(metadata) {
-      if (typeof definition.active === "function") {
-        return definition.active({
-          ...metadata,
-          $params: unwrapRuleParameters(metadata?.$params?.length ? metadata.$params : params)
-        });
-      } else {
-        return definition.active ?? true;
-      }
-    },
-    tooltip(metadata) {
-      if (typeof definition.tooltip === "function") {
-        return definition.tooltip({
-          ...metadata,
-          $params: unwrapRuleParameters(metadata?.$params?.length ? metadata.$params : params)
-        });
-      } else {
-        return definition.tooltip ?? [];
-      }
-    },
-    exec(value) {
-      const validator2 = definition.validator(value, ...unwrapRuleParameters(params));
-      let rawResult;
-      if (validator2 instanceof Promise) {
-        return validator2.then((result) => {
-          rawResult = result;
-          if (typeof rawResult === "object" && "$valid" in rawResult) {
-            return rawResult.$valid;
-          } else if (typeof rawResult === "boolean") {
-            return rawResult;
-          }
-          return false;
-        });
-      } else {
-        rawResult = validator2;
-      }
-      if (typeof rawResult === "object" && "$valid" in rawResult) {
-        return rawResult.$valid;
-      } else if (typeof rawResult === "boolean") {
-        return rawResult;
-      }
-      return false;
-    }
-  };
-  const processors = {
-    ...defaultProcessors,
-    _validator: definition.validator,
-    _message: definition.message,
-    _active: definition.active,
-    _tooltip: definition.tooltip,
-    _type: definition.type,
-    _message_patched: false,
-    _tooltip_patched: false,
-    _async: isAsync,
-    _params: createReactiveParams(params),
-    _brand: RegleRuleSymbol
-  };
-  return processors;
-}
-
-// src/core/createRule/createRule.ts
-function createRule(definition) {
-  if (typeof definition.validator === "function") {
-    let fakeParams = [];
-    const staticProcessors = defineRuleProcessors(definition, ...fakeParams);
-    const isAsync = definition.async ?? definition.validator.constructor.name === "AsyncFunction";
-    if (getFunctionParametersLength(definition.validator) > 1) {
-      const ruleFactory = function(...params) {
-        return defineRuleProcessors(definition, ...params);
-      };
-      ruleFactory.validator = staticProcessors.validator;
-      ruleFactory.message = staticProcessors.message;
-      ruleFactory.active = staticProcessors.active;
-      ruleFactory.tooltip = staticProcessors.tooltip;
-      ruleFactory.type = staticProcessors.type;
-      ruleFactory.exec = staticProcessors.exec;
-      ruleFactory._validator = staticProcessors.validator;
-      ruleFactory._message = staticProcessors.message;
-      ruleFactory._active = staticProcessors.active;
-      ruleFactory._tooltip = staticProcessors.tooltip;
-      ruleFactory._type = definition.type;
-      ruleFactory._message_pacthed = false;
-      ruleFactory._tooltip_pacthed = false;
-      ruleFactory._async = isAsync;
-      return ruleFactory;
-    } else {
-      return staticProcessors;
-    }
-  }
-  throw new Error("Validator must be a function");
-}
-function useStorage() {
-  const ruleDeclStorage = vue.shallowRef(/* @__PURE__ */ new Map());
-  const fieldsStorage = vue.shallowRef(/* @__PURE__ */ new Map());
-  const collectionsStorage = vue.shallowRef(/* @__PURE__ */ new Map());
-  const dirtyStorage = vue.shallowRef(/* @__PURE__ */ new Map());
-  const ruleStatusStorage = vue.shallowRef(/* @__PURE__ */ new Map());
-  const arrayStatusStorage = vue.shallowRef(/* @__PURE__ */ new Map());
-  function getFieldsEntry($path) {
-    const existingFields = fieldsStorage.value.get($path);
-    if (existingFields) {
-      return existingFields;
-    } else {
-      const $fields = vue.ref({});
-      fieldsStorage.value.set($path, $fields);
-      return $fields;
-    }
-  }
-  function getCollectionsEntry($path) {
-    const existingEach = collectionsStorage.value.get($path);
-    if (existingEach) {
-      return existingEach;
-    } else {
-      const $each = vue.ref([]);
-      collectionsStorage.value.set($path, $each);
-      return $each;
-    }
-  }
-  function addArrayStatus($arrayId, itemId, value) {
-    arrayStatusStorage.value.set(`${$arrayId}-${itemId}`, value);
-  }
-  function getArrayStatus($arrayId, itemId) {
-    return arrayStatusStorage.value.get(`${$arrayId}-${itemId}`);
-  }
-  function deleteArrayStatus($arrayId, itemId) {
-    if ($arrayId && itemId != null) {
-      arrayStatusStorage.value.delete(`${$arrayId}-${itemId}`);
-    }
-  }
-  function setDirtyEntry($path, dirty) {
-    dirtyStorage.value.set($path, dirty);
-  }
-  function getDirtyState(path) {
-    return dirtyStorage.value.get(path) ?? false;
-  }
-  function addRuleDeclEntry($path, options) {
-    ruleDeclStorage.value.set($path, options);
-  }
-  function checkRuleDeclEntry($path, newRules) {
-    const storedRulesDefs = ruleDeclStorage.value.get($path);
-    if (!storedRulesDefs) return void 0;
-    const storedRules = storedRulesDefs;
-    const isValidCache = areRulesChanged(newRules, storedRules);
-    if (!isValidCache) return { valid: false };
-    return { valid: true };
-  }
-  function areRulesChanged(newRules, storedRules) {
-    const storedRulesKeys = Object.keys(storedRules);
-    const newRulesKeys = Object.keys(newRules);
-    if (newRulesKeys.length !== storedRulesKeys.length) return false;
-    const hasAllValidators = newRulesKeys.every((ruleKey) => storedRulesKeys.includes(ruleKey));
-    if (!hasAllValidators) return false;
-    return newRulesKeys.every((ruleKey) => {
-      const newRuleElement = newRules[ruleKey];
-      const storedRuleElement = storedRules[ruleKey];
-      if (!storedRuleElement || !newRuleElement || typeof newRuleElement === "function" || typeof storedRuleElement === "function")
-        return false;
-      if (typeof newRuleElement === "number") {
-        return false;
-      } else if (typeof newRuleElement === "boolean") {
-        return false;
-      } else if (!newRuleElement._params) return true;
-      else {
-        return newRuleElement._params?.every((paramKey, index) => {
-          if (typeof storedRuleElement === "number" || typeof storedRuleElement === "boolean") {
-            return true;
-          } else {
-            const storedParams = unwrapRuleParameters(storedRuleElement._params);
-            const newParams = unwrapRuleParameters(newRuleElement._params);
-            return storedParams?.[index] === newParams?.[index];
-          }
-        });
-      }
-    });
-  }
-  function trySetRuleStatusRef(path) {
-    const ruleStatus = ruleStatusStorage.value.get(path);
-    if (ruleStatus) {
-      return ruleStatus;
-    } else {
-      const $pending = vue.ref(false);
-      const $valid = vue.ref(true);
-      const $metadata = vue.ref({});
-      const $validating = vue.ref(false);
-      ruleStatusStorage.value.set(path, { $pending, $valid, $metadata, $validating });
-      return { $pending, $valid, $metadata, $validating };
-    }
-  }
-  if (vue.getCurrentScope()) {
-    vue.onScopeDispose(() => {
-      ruleDeclStorage.value.clear();
-      fieldsStorage.value.clear();
-      collectionsStorage.value.clear();
-      dirtyStorage.value.clear();
-      ruleStatusStorage.value.clear();
-      arrayStatusStorage.value.clear();
-    });
-  }
-  return {
-    addRuleDeclEntry,
-    setDirtyEntry,
-    checkRuleDeclEntry,
-    getDirtyState,
-    trySetRuleStatusRef,
-    getFieldsEntry,
-    getCollectionsEntry,
-    getArrayStatus,
-    addArrayStatus,
-    deleteArrayStatus,
-    arrayStatusStorage
-  };
-}
-function isRefObject(obj) {
-  return isObject(obj.value);
-}
-function unwrapGetter(getter, value, index) {
-  const scope = vue.effectScope();
-  let unwrapped;
-  if (getter instanceof Function) {
-    unwrapped = scope.run(() => getter(value, index ?? 0));
-  } else {
-    unwrapped = getter;
-  }
-  return { scope, unwrapped };
-}
-var VersionIs = {
-  LessThan: -1,
-  EqualTo: 0,
-  GreaterThan: 1
-};
-function versionCompare(current, other) {
-  const cp = String(current).split(".");
-  const op = String(other).split(".");
-  for (let depth = 0; depth < Math.min(cp.length, op.length); depth++) {
-    const cn = Number(cp[depth]);
-    const on = Number(op[depth]);
-    if (cn > on) return VersionIs.GreaterThan;
-    if (on > cn) return VersionIs.LessThan;
-    if (!isNaN(cn) && isNaN(on)) return VersionIs.GreaterThan;
-    if (isNaN(cn) && !isNaN(on)) return VersionIs.LessThan;
-  }
-  return VersionIs.EqualTo;
-}
-var isVueSuperiorOrEqualTo3dotFive = versionCompare(vue.version, "3.5.0") === -1 ? false : true;
-
-// src/utils/randomId.ts
-function uniqueIDNuxt() {
-  return Math.floor(Math.random() * Date.now()).toString();
-}
-function randomId() {
-  if (typeof window === "undefined") {
-    return uniqueIDNuxt();
-  } else {
-    const uint32 = window.crypto.getRandomValues(new Uint32Array(1))[0];
-    return uint32.toString(10);
-  }
-}
-function tryOnScopeDispose(fn) {
-  if (vue.getCurrentScope()) {
-    vue.onScopeDispose(fn);
-    return true;
-  }
-  return false;
-}
-function createGlobalState(stateFactory) {
-  let initialized = false;
-  let state;
-  const scope = vue.effectScope(true);
-  return (...args) => {
-    if (!initialized) {
-      state = scope.run(() => stateFactory(...args));
-      initialized = true;
-    }
-    return state;
-  };
-}
-
-// src/core/useRegle/guards/ruleDef.guards.ts
-function isNestedRulesDef(state, rules) {
-  return isRefObject(state) || isObject(rules.value) && !isEmpty(rules.value) && !Object.entries(rules.value).some(([key, rule]) => isRuleDef(rule) || typeof rule === "function");
-}
-function isCollectionRulesDef(rules, state, schemaMode = false) {
-  return !!rules.value && isObject(rules.value) && "$each" in rules.value || schemaMode && Array.isArray(state.value) && state.value.some(isObject) || Array.isArray(state.value) && state.value.some(isObject);
-}
-function isValidatorRulesDef(rules) {
-  return !!rules.value && isObject(rules.value);
-}
-function isRuleDef(rule) {
-  return isObject(rule) && "_validator" in rule;
-}
-function isFormRuleDefinition(rule) {
-  return !(typeof rule.value === "function");
-}
-
-// src/core/useRegle/guards/rule.status.guards.ts
-function isNestedRulesStatus(rule) {
-  return isObject(rule) && "$fields" in rule;
-}
-function isFieldStatus(rule) {
-  return !!rule && "$rules" in rule;
-}
-
-// src/core/useRegle/useErrors.ts
-function extractRulesErrors({
-  field,
-  silent = false
-}) {
-  return Object.entries(field.$rules ?? {}).map(([_, rule]) => {
-    if (silent && !rule.$valid) {
-      return rule.$message;
-    } else if (!rule.$valid && field.$error && !rule.$validating) {
-      return rule.$message;
-    }
-    return null;
-  }).filter((msg) => !!msg).reduce((acc, value) => {
-    if (typeof value === "string") {
-      return acc?.concat([value]);
-    } else {
-      return acc?.concat(value);
-    }
-  }, []).concat(field.$error ? field.$externalErrors ?? [] : []).concat(field.$error ? field.$schemaErrors ?? [] : []);
-}
-function extractRulesTooltips({ field }) {
-  return Object.entries(field.$rules ?? {}).map(([_, rule]) => rule.$tooltip).filter((tooltip) => !!tooltip).reduce((acc, value) => {
-    if (typeof value === "string") {
-      return acc?.concat([value]);
-    } else {
-      return acc?.concat(value);
-    }
-  }, []);
-}
-function isCollectionError(errors) {
-  return isObject(errors) && "$each" in errors;
-}
-function flatErrors(errors, options) {
-  const { includePath = false } = options ?? {};
-  if (Array.isArray(errors) && errors.every((err) => !isObject(err))) {
-    return errors;
-  } else if (isCollectionError(errors)) {
-    const selfErrors = includePath ? errors.$self?.map((err) => ({ error: err, path: "" })) ?? [] : errors.$self ?? [];
-    const eachErrors = errors.$each?.map((err) => interateErrors(err, includePath)) ?? [];
-    return selfErrors?.concat(eachErrors.flat());
-  } else {
-    return Object.entries(errors).map(([key, value]) => interateErrors(value, includePath, [key])).flat();
-  }
-}
-function interateErrors(errors, includePath = false, _path) {
-  const path = includePath && !_path ? [] : _path;
-  if (Array.isArray(errors) && errors.every((err) => !isObject(err))) {
-    if (includePath) {
-      return errors.map((err) => ({ error: err, path: path?.join(".") ?? "" }));
-    }
-    return errors;
-  } else if (isCollectionError(errors)) {
-    const selfErrors = path?.length ? errors.$self?.map((err) => ({ error: err, path: path.join(".") })) ?? [] : errors.$self ?? [];
-    const eachErrors = errors.$each?.map((err, index) => interateErrors(err, includePath, path?.concat(index.toString()))) ?? [];
-    return selfErrors?.concat(eachErrors.flat());
-  } else {
-    return Object.entries(errors).map(([key, value]) => interateErrors(value, includePath, path?.concat(key))).flat();
-  }
-}
-function createReactiveRuleStatus({
-  customMessages,
-  rule,
-  ruleKey,
-  state,
-  path,
-  storage,
-  $debounce,
-  modifiers
-}) {
-  let scope = vue.effectScope();
-  let scopeState = {};
-  let $unwatchState;
-  const $haveAsync = vue.ref(false);
-  const { $pending, $valid, $metadata, $validating } = storage.trySetRuleStatusRef(`${path}.${ruleKey}`);
-  function $watch() {
-    scope = vue.effectScope();
-    scopeState = scope.run(() => {
-      const $fieldDirty = vue.ref(false);
-      const $fieldError = vue.ref(false);
-      const $fieldInvalid = vue.ref(true);
-      const $fieldPending = vue.ref(false);
-      const $fieldCorrect = vue.ref(false);
-      const $defaultMetadata = vue.computed(() => ({
-        $value: state.value,
-        $error: $fieldError.value,
-        $dirty: $fieldDirty.value,
-        $pending: $fieldPending.value,
-        $correct: $fieldCorrect.value,
-        $invalid: $fieldInvalid.value,
-        $rule: {
-          $valid: $valid.value,
-          $invalid: !$valid.value,
-          $pending: $pending.value
-        },
-        $params: $params.value,
-        ...$metadata.value
-      }));
-      const $active = vue.computed(() => {
-        if (isFormRuleDefinition(rule)) {
-          if (typeof rule.value.active === "function") {
-            return rule.value.active($defaultMetadata.value);
-          } else {
-            return !!rule.value.active;
-          }
-        } else {
-          return true;
-        }
-      });
-      function computeRuleProcessor(key) {
-        let result = "";
-        const customProcessor = customMessages ? customMessages[ruleKey]?.[key] : void 0;
-        if (customProcessor) {
-          if (typeof customProcessor === "function") {
-            result = customProcessor($defaultMetadata.value);
-          } else {
-            result = customProcessor;
-          }
-        }
-        if (isFormRuleDefinition(rule)) {
-          const patchedKey = `_${key}_patched`;
-          if (!(customProcessor && !rule.value[patchedKey])) {
-            if (typeof rule.value[key] === "function") {
-              result = rule.value[key]($defaultMetadata.value);
-            } else {
-              result = rule.value[key] ?? "";
-            }
-          }
-        }
-        return result;
-      }
-      const $message = vue.computed(() => {
-        let message = computeRuleProcessor("message");
-        if (isEmpty(message)) {
-          message = "This field is not valid";
-        }
-        return message;
-      });
-      const $tooltip = vue.computed(() => {
-        return computeRuleProcessor("tooltip");
-      });
-      const $type = vue.computed(() => {
-        if (isFormRuleDefinition(rule) && rule.value.type) {
-          return rule.value.type;
-        } else {
-          return ruleKey;
-        }
-      });
-      const $validator = vue.computed(() => {
-        if (isFormRuleDefinition(rule)) {
-          return rule.value.validator;
-        } else {
-          return rule.value;
-        }
-      });
-      const $params = vue.computed(() => {
-        if (typeof rule.value === "function") {
-          return [];
-        }
-        return unwrapRuleParameters(rule.value._params ?? []);
-      });
-      const $path = vue.computed(() => `${path}.${$type.value}`);
-      return {
-        $active,
-        $message,
-        $type,
-        $validator,
-        $params,
-        $path,
-        $tooltip,
-        $fieldCorrect,
-        $fieldError,
-        $fieldDirty,
-        $fieldPending,
-        $fieldInvalid
-      };
-    });
-    $unwatchState = vue.watch(scopeState?.$params, () => {
-      if (modifiers.$autoDirty.value || modifiers.$rewardEarly.value && scopeState.$fieldError.value) {
-        $parse();
-      }
-    });
-  }
-  $watch();
-  function updatePendingState() {
-    $valid.value = true;
-    if (scopeState.$fieldDirty.value) {
-      $pending.value = true;
-    }
-  }
-  async function computeAsyncResult() {
-    let ruleResult = false;
-    try {
-      const validator = scopeState.$validator.value;
-      if (typeof validator !== "function") {
-        console.error(`${path}: Incorrect rule format, it needs to be either a function or created with "createRule".`);
-        return false;
-      }
-      const resultOrPromise = validator(state.value, ...scopeState.$params.value);
-      let cachedValue = state.value;
-      updatePendingState();
-      let validatorResult;
-      if (resultOrPromise instanceof Promise) {
-        validatorResult = await resultOrPromise;
-      } else {
-        validatorResult = resultOrPromise;
-      }
-      if (state.value !== cachedValue) {
-        return true;
-      }
-      if (typeof validatorResult === "boolean") {
-        ruleResult = validatorResult;
-      } else {
-        const { $valid: $valid2, ...rest } = validatorResult;
-        ruleResult = $valid2;
-        $metadata.value = rest;
-      }
-    } catch (e) {
-      ruleResult = false;
-    } finally {
-      $pending.value = false;
-    }
-    return ruleResult;
-  }
-  const $computeAsyncDebounce = debounce(computeAsyncResult, $debounce ?? 200);
-  async function $parse() {
-    try {
-      $validating.value = true;
-      let ruleResult = false;
-      if (isRuleDef(rule.value) && rule.value._async) {
-        ruleResult = await $computeAsyncDebounce();
-      } else {
-        const validator = scopeState.$validator.value;
-        const resultOrPromise = validator(state.value, ...scopeState.$params.value);
-        if (resultOrPromise instanceof Promise) {
-          console.warn(
-            'You used a async validator function on a non-async rule, please use "async await" or the "withAsync" helper'
-          );
-        } else {
-          if (resultOrPromise != null) {
-            if (typeof resultOrPromise === "boolean") {
-              ruleResult = resultOrPromise;
-            } else {
-              const { $valid: $valid2, ...rest } = resultOrPromise;
-              ruleResult = $valid2;
-              $metadata.value = rest;
-            }
-          }
-        }
-      }
-      $valid.value = ruleResult;
-      return ruleResult;
-    } catch (e) {
-      return false;
-    } finally {
-      $validating.value = false;
-    }
-  }
-  function $reset() {
-    $valid.value = true;
-    $metadata.value = {};
-    $pending.value = false;
-    $validating.value = false;
-    $watch();
-  }
-  function $unwatch() {
-    $unwatchState();
-    scope.stop();
-    scope = vue.effectScope();
-  }
-  return vue.reactive({
-    ...scopeState,
-    $pending,
-    $valid,
-    $metadata,
-    $haveAsync,
-    $validating,
-    $parse,
-    $unwatch,
-    $watch,
-    $reset
-  });
-}
-
-// src/core/useRegle/root/createReactiveFieldStatus.ts
-function createReactiveFieldStatus({
-  state,
-  rulesDef,
-  customMessages,
-  path,
-  fieldName,
-  storage,
-  options,
-  externalErrors,
-  schemaErrors,
-  schemaMode,
-  onUnwatch,
-  $isArray,
-  initialState,
-  shortcuts,
-  onValidate
-}) {
-  let scope = vue.effectScope();
-  let scopeState;
-  let fieldScopes = [];
-  let $unwatchState;
-  let $unwatchValid;
-  let $unwatchDirty;
-  let $unwatchAsync;
-  let $unwatchRuleFieldValues;
-  let $commit = () => {
-  };
-  function createReactiveRulesResult() {
-    const declaredRules = rulesDef.value;
-    const storeResult = storage.checkRuleDeclEntry(path, declaredRules);
-    $localOptions.value = Object.fromEntries(
-      Object.entries(declaredRules).filter(([ruleKey]) => ruleKey.startsWith("$"))
-    );
-    $watch();
-    $rules.value = Object.fromEntries(
-      Object.entries(rulesDef.value).filter(([ruleKey]) => !ruleKey.startsWith("$")).map(([ruleKey, rule]) => {
-        if (rule) {
-          const ruleRef = vue.toRef(() => rule);
-          return [
-            ruleKey,
-            createReactiveRuleStatus({
-              modifiers: {
-                $autoDirty: scopeState.$autoDirty,
-                $rewardEarly: scopeState.$rewardEarly
-              },
-              customMessages,
-              rule: ruleRef,
-              ruleKey,
-              state,
-              path,
-              storage,
-              $debounce: $localOptions.value.$debounce
-            })
-          ];
-        }
-        return [];
-      }).filter((ruleDef) => !!ruleDef.length)
-    );
-    scopeState.processShortcuts();
-    define$commit();
-    if (storeResult?.valid != null) {
-      scopeState.$dirty.value = storage.getDirtyState(path);
-      if (scopeState.$dirty.value && scopeState.$autoDirty.value || scopeState.$rewardEarly.value && scopeState.$error.value) {
-        $commit();
-      }
-    }
-    storage.addRuleDeclEntry(path, declaredRules);
-  }
-  function define$commit() {
-    $commit = scopeState.$debounce.value ? debounce($commitHandler, scopeState.$debounce.value ?? scopeState.$haveAnyAsyncRule ? 100 : 0) : $commitHandler;
-  }
-  function $unwatch() {
-    if ($rules.value) {
-      Object.entries($rules.value).forEach(([_, rule]) => {
-        rule.$unwatch();
-      });
-    }
-    $unwatchDirty();
-    $unwatchRuleFieldValues?.();
-    if (scopeState.$dirty.value) {
-      storage.setDirtyEntry(path, scopeState.$dirty.value);
-    }
-    $unwatchState?.();
-    $unwatchValid?.();
-    scope.stop();
-    scope = vue.effectScope();
-    fieldScopes.forEach((s) => s.stop());
-    fieldScopes = [];
-    onUnwatch?.();
-    $unwatchAsync?.();
-  }
-  function $watch() {
-    if ($rules.value) {
-      Object.entries($rules.value).forEach(([_, rule]) => {
-        rule.$watch();
-      });
-    }
-    scopeState = scope.run(() => {
-      const $dirty = vue.ref(false);
-      const triggerPunishment2 = vue.ref(false);
-      const $anyDirty = vue.computed(() => $dirty.value);
-      const $debounce2 = vue.computed(() => {
-        return $localOptions.value.$debounce;
-      });
-      const $lazy2 = vue.computed(() => {
-        if ($localOptions.value.$lazy != null) {
-          return $localOptions.value.$lazy;
-        } else if (vue.unref(options.lazy) != null) {
-          return vue.unref(options.lazy);
-        }
-        return false;
-      });
-      const $rewardEarly2 = vue.computed(() => {
-        if ($localOptions.value.$rewardEarly != null) {
-          return $localOptions.value.$rewardEarly;
-        } else if (vue.unref(options.rewardEarly) != null) {
-          return vue.unref(options.rewardEarly);
-        }
-        return false;
-      });
-      const $clearExternalErrorsOnChange2 = vue.computed(() => {
-        if ($localOptions.value.$clearExternalErrorsOnChange != null) {
-          return $localOptions.value.$clearExternalErrorsOnChange;
-        } else if (vue.unref(options.clearExternalErrorsOnChange) != null) {
-          return vue.unref(options.clearExternalErrorsOnChange);
-        }
-        return true;
-      });
-      const $autoDirty2 = vue.computed(() => {
-        if ($localOptions.value.$autoDirty != null) {
-          return $localOptions.value.$autoDirty;
-        } else if (vue.unref(options.autoDirty) != null) {
-          return vue.unref(options.autoDirty);
-        } else if ($rewardEarly2.value) {
-          return false;
-        }
-        return true;
-      });
-      const $validating2 = vue.computed(() => {
-        return Object.entries($rules.value).some(([key, ruleResult]) => {
-          return ruleResult.$validating;
-        });
-      });
-      const $silentValue = vue.computed({
-        get: () => state.value,
-        set(value) {
-          $unwatchState();
-          state.value = value;
-          define$watchState();
-        }
-      });
-      const $error = vue.computed(() => {
-        return $invalid.value && !$pending.value && $dirty.value;
-      });
-      const $errors = vue.computed(() => {
-        return extractRulesErrors({
-          field: {
-            $rules: $rules.value,
-            $error: $error.value,
-            $externalErrors: externalErrors?.value,
-            $schemaErrors: schemaErrors?.value
-          }
-        });
-      });
-      const $silentErrors = vue.computed(() => {
-        return extractRulesErrors({
-          field: {
-            $rules: $rules.value,
-            $error: $error.value,
-            $externalErrors: externalErrors?.value,
-            $schemaErrors: schemaErrors?.value
-          },
-          silent: true
-        });
-      });
-      const $edited = vue.computed(() => {
-        if ($dirty.value) {
-          if (initialState.value instanceof Date && state.value instanceof Date) {
-            return toDate(initialState.value).getDate() !== toDate(state.value).getDate();
-          }
-          if (initialState.value == null) {
-            return !!state.value;
-          }
-          if (Array.isArray(state.value) && Array.isArray(initialState.value)) {
-            return state.value.length !== initialState.value.length;
-          }
-          return initialState.value !== state.value;
-        }
-        return false;
-      });
-      const $anyEdited = vue.computed(() => $edited.value);
-      const $tooltips = vue.computed(() => {
-        return extractRulesTooltips({
-          field: {
-            $rules: $rules.value
-          }
-        });
-      });
-      const $ready = vue.computed(() => {
-        if (!$autoDirty2.value) {
-          return !($invalid.value || $pending.value);
-        }
-        return $anyDirty.value && !($invalid.value || $pending.value);
-      });
-      const $pending = vue.computed(() => {
-        if (triggerPunishment2.value || !$rewardEarly2.value) {
-          return Object.entries($rules.value).some(([key, ruleResult]) => {
-            return ruleResult.$pending;
-          });
-        }
-        return false;
-      });
-      const $invalid = vue.computed(() => {
-        if (externalErrors?.value?.length || schemaErrors?.value?.length) {
-          return true;
-        } else if ($inactive.value) {
-          return false;
-        } else if (!$rewardEarly2.value || $rewardEarly2.value && triggerPunishment2.value) {
-          return Object.entries($rules.value).some(([_, ruleResult]) => {
-            return !ruleResult.$valid;
-          });
-        }
-        return false;
-      });
-      const $name = vue.computed(() => fieldName);
-      const $inactive = vue.computed(() => {
-        if (isEmpty($rules.value) && !schemaMode) {
-          return true;
-        }
-        return false;
-      });
-      const $correct = vue.computed(() => {
-        if (externalErrors?.value?.length) {
-          return false;
-        } else if ($inactive.value) {
-          return false;
-        } else if ($dirty.value && !isEmpty(state.value) && !$validating2.value) {
-          if (schemaMode) {
-            return !schemaErrors?.value?.length;
-          } else {
-            const atLeastOneActiveRule = Object.values($rules.value).some((ruleResult) => ruleResult.$active);
-            if (atLeastOneActiveRule) {
-              return Object.values($rules.value).filter((ruleResult) => ruleResult.$active).every((ruleResult) => ruleResult.$valid);
-            } else {
-              return false;
-            }
-          }
-        }
-        return false;
-      });
-      const $haveAnyAsyncRule2 = vue.computed(() => {
-        return Object.entries($rules.value).some(([key, ruleResult]) => {
-          return ruleResult.$haveAsync;
-        });
-      });
-      function processShortcuts() {
-        if (shortcuts?.fields) {
-          Object.entries(shortcuts.fields).forEach(([key, value]) => {
-            const scope2 = vue.effectScope();
-            $shortcuts2[key] = scope2.run(() => {
-              const result = vue.ref();
-              vue.watchEffect(() => {
-                result.value = value(
-                  vue.reactive({
-                    $dirty,
-                    $externalErrors: externalErrors?.value ?? [],
-                    $value: state,
-                    $silentValue,
-                    $rules,
-                    $error,
-                    $pending,
-                    $invalid,
-                    $correct,
-                    $errors,
-                    $ready,
-                    $silentErrors,
-                    $anyDirty,
-                    $tooltips,
-                    $name,
-                    $inactive,
-                    $edited,
-                    $anyEdited
-                  })
-                );
-              });
-              return result;
-            });
-            fieldScopes.push(scope2);
-          });
-        }
-      }
-      const $shortcuts2 = {};
-      vue.watch($invalid, (value) => {
-        if (!value) {
-          triggerPunishment2.value = false;
-        }
-      });
-      return {
-        $error,
-        $pending,
-        $invalid,
-        $correct,
-        $debounce: $debounce2,
-        $lazy: $lazy2,
-        $errors,
-        $ready,
-        $silentErrors,
-        $rewardEarly: $rewardEarly2,
-        $autoDirty: $autoDirty2,
-        $clearExternalErrorsOnChange: $clearExternalErrorsOnChange2,
-        $anyDirty,
-        $edited,
-        $anyEdited,
-        $name,
-        $haveAnyAsyncRule: $haveAnyAsyncRule2,
-        $shortcuts: $shortcuts2,
-        $validating: $validating2,
-        $tooltips,
-        $dirty,
-        triggerPunishment: triggerPunishment2,
-        processShortcuts,
-        $silentValue,
-        $inactive
-      };
-    });
-    define$watchState();
-    $unwatchDirty = vue.watch(scopeState.$dirty, (newDirty) => {
-      storage.setDirtyEntry(path, newDirty);
-      Object.values($rules.value).forEach((rule) => {
-        rule.$fieldDirty = newDirty;
-      });
-    });
-    $unwatchRuleFieldValues = vue.watch(
-      [scopeState.$error, scopeState.$correct, scopeState.$invalid, scopeState.$pending],
-      () => {
-        Object.values($rules.value).forEach((rule) => {
-          rule.$fieldError = scopeState.$error.value;
-          rule.$fieldInvalid = scopeState.$invalid.value;
-          rule.$fieldPending = scopeState.$pending.value;
-          rule.$fieldCorrect = scopeState.$correct.value;
-        });
-      }
-    );
-    $unwatchValid = vue.watch(scopeState.$invalid, (invalid) => {
-      if (scopeState.$rewardEarly.value && !invalid) {
-        scopeState.triggerPunishment.value = false;
-      }
-    });
-    $unwatchAsync = vue.watch(scopeState.$haveAnyAsyncRule, define$commit);
-  }
-  function define$watchState() {
-    $unwatchState = vue.watch(
-      state,
-      () => {
-        if (scopeState.$autoDirty.value) {
-          if (!scopeState.$dirty.value) {
-            scopeState.$dirty.value = true;
-          }
-        }
-        if (rulesDef.value instanceof Function) {
-          createReactiveRulesResult();
-        }
-        if (scopeState.$autoDirty.value || scopeState.$rewardEarly.value && scopeState.$error.value) {
-          $commit();
-        }
-        if (scopeState.$rewardEarly.value !== true && scopeState.$clearExternalErrorsOnChange.value) {
-          $clearExternalErrors();
-        }
-      },
-      { deep: $isArray ? true : isVueSuperiorOrEqualTo3dotFive ? 1 : true }
-    );
-  }
-  function $commitHandler() {
-    Object.values($rules.value).forEach((rule) => {
-      rule.$parse();
-    });
-  }
-  const $rules = vue.ref({});
-  const $localOptions = vue.ref({});
-  createReactiveRulesResult();
-  function $reset(options2, fromParent) {
-    $clearExternalErrors();
-    scopeState.$dirty.value = false;
-    scopeState.triggerPunishment.value = false;
-    storage.setDirtyEntry(path, false);
-    if (!fromParent) {
-      if (options2?.toInitialState) {
-        $unwatch();
-        state.value = cloneDeep(initialState);
-      } else if (options2?.toState) {
-        $unwatch();
-        let newInitialState;
-        if (typeof options2?.toState === "function") {
-          newInitialState = options2?.toState();
-        } else {
-          newInitialState = options2?.toState;
-        }
-        initialState.value = cloneDeep(newInitialState);
-        state.value = cloneDeep(newInitialState);
-      } else {
-        initialState.value = isObject(state.value) ? cloneDeep(state.value) : Array.isArray(state.value) ? [...state.value] : state.value;
-      }
-    }
-    if (options2?.clearExternalErrors) {
-      $clearExternalErrors();
-    }
-    if (!fromParent) {
-      Object.entries($rules.value).forEach(([_, rule]) => {
-        rule.$reset();
-      });
-    }
-    if (!scopeState.$lazy.value && scopeState.$autoDirty.value) {
-      Object.values($rules.value).forEach((rule) => {
-        return rule.$parse();
-      });
-    }
-    if (!fromParent) {
-      createReactiveRulesResult();
-    }
-  }
-  function $touch(runCommit = true, withConditions = false) {
-    if (!scopeState.$dirty.value) {
-      scopeState.$dirty.value = true;
-    }
-    if (withConditions && runCommit) {
-      if (scopeState.$autoDirty.value || scopeState.$rewardEarly.value && scopeState.$error.value) {
-        $commit();
-      }
-    } else if (runCommit) {
-      $commit();
-    }
-  }
-  async function $validate() {
-    try {
-      if (schemaMode) {
-        if (onValidate) {
-          $touch(false);
-          return onValidate();
-        } else {
-          return { valid: false, data: state.value };
-        }
-      }
-      const data = state.value;
-      scopeState.triggerPunishment.value = true;
-      if (!scopeState.$dirty.value) {
-        scopeState.$dirty.value = true;
-      } else if (scopeState.$autoDirty.value && scopeState.$dirty.value && !scopeState.$pending.value) {
-        return { valid: !scopeState.$error.value, data };
-      }
-      if (schemaMode) {
-        return { valid: !schemaErrors?.value?.length, data };
-      } else if (isEmpty($rules.value)) {
-        return { valid: true, data };
-      }
-      const results = await Promise.allSettled(
-        Object.entries($rules.value).map(([key, rule]) => {
-          return rule.$parse();
-        })
-      );
-      const validationResults = results.every((value) => {
-        if (value.status === "fulfilled") {
-          return value.value === true;
-        } else {
-          return false;
-        }
-      });
-      return { valid: validationResults, data };
-    } catch (e) {
-      return { valid: false, data: state.value };
-    }
-  }
-  function $extractDirtyFields(filterNullishValues = true) {
-    if (scopeState.$dirty.value) {
-      return state.value;
-    }
-    if (filterNullishValues) {
-      return { _null: true };
-    }
-    return null;
-  }
-  function $clearExternalErrors() {
-    if (externalErrors?.value?.length) {
-      externalErrors.value = [];
-    }
-  }
-  if (!scopeState.$lazy.value && !scopeState.$dirty.value && scopeState.$autoDirty.value) {
-    $commit();
-  }
-  const {
-    $shortcuts,
-    $validating,
-    $autoDirty,
-    $rewardEarly,
-    $clearExternalErrorsOnChange,
-    $haveAnyAsyncRule,
-    $debounce,
-    $lazy,
-    triggerPunishment,
-    ...restScope
-  } = scopeState;
-  return vue.reactive({
-    ...restScope,
-    $externalErrors: externalErrors,
-    $value: state,
-    $rules,
-    ...$shortcuts,
-    $reset,
-    $touch,
-    $validate,
-    $unwatch,
-    $watch,
-    $extractDirtyFields,
-    $clearExternalErrors
-  });
-}
-function createCollectionElement({
-  $id,
-  path,
-  index,
-  options,
-  storage,
-  stateValue,
-  customMessages,
-  rules,
-  externalErrors,
-  schemaErrors,
-  initialState,
-  shortcuts,
-  fieldName,
-  schemaMode
-}) {
-  const $fieldId = rules.$key ? rules.$key : randomId();
-  let $path = `${path}.${String($fieldId)}`;
-  if (typeof stateValue.value === "object" && stateValue.value != null) {
-    if (!stateValue.value.$id) {
-      Object.defineProperties(stateValue.value, {
-        $id: {
-          value: $fieldId,
-          enumerable: false,
-          configurable: false,
-          writable: false
-        }
-      });
-    } else {
-      $path = `${path}.${stateValue.value.$id}`;
-    }
-  }
-  const $externalErrors = vue.toRef(externalErrors?.value ?? [], index);
-  const $schemaErrors = vue.computed(() => schemaErrors?.value?.[index]);
-  const $status = createReactiveChildrenStatus({
-    state: stateValue,
-    rulesDef: vue.toRef(() => rules),
-    customMessages,
-    path: $path,
-    storage,
-    options,
-    externalErrors: $externalErrors,
-    schemaErrors: $schemaErrors,
-    initialState,
-    shortcuts,
-    fieldName,
-    schemaMode
-  });
-  if ($status) {
-    const valueId = stateValue.value?.$id;
-    $status.$id = valueId ?? String($fieldId);
-    storage.addArrayStatus($id, $status.$id, $status);
-  }
-  return $status;
-}
-
-// src/core/useRegle/root/collections/createReactiveCollectionRoot.ts
-function createReactiveCollectionStatus({
-  state,
-  rulesDef,
-  customMessages,
-  path,
-  storage,
-  options,
-  externalErrors,
-  schemaErrors,
-  schemaMode,
-  initialState,
-  shortcuts,
-  fieldName
-}) {
-  let scope = vue.effectScope();
-  let scopeState;
-  let immediateScope = vue.effectScope();
-  let immediateScopeState;
-  let collectionScopes = [];
-  if (!Array.isArray(state.value) && !rulesDef.value.$each) {
-    return void 0;
-  }
-  const $id = vue.ref();
-  const $value = vue.ref(state.value);
-  let $unwatchState;
-  const $selfStatus = vue.ref({});
-  const $eachStatus = storage.getCollectionsEntry(path);
-  immediateScopeState = immediateScope.run(() => {
-    const isPrimitiveArray = vue.computed(() => {
-      if (Array.isArray(state.value) && state.value.length) {
-        return state.value.every((s) => typeof s !== "object");
-      } else if (rulesDef.value.$each && !(rulesDef.value.$each instanceof Function)) {
-        return Object.values(rulesDef.value.$each).every((rule) => isRuleDef(rule) || typeof rule === "function");
-      }
-      return false;
-    });
-    return {
-      isPrimitiveArray
-    };
-  });
-  createStatus();
-  $watch();
-  function createStatus() {
-    if (typeof state.value === "object") {
-      if (state.value != null && !state.value?.$id && state.value !== null) {
-        $id.value = randomId();
-        Object.defineProperties(state.value, {
-          $id: {
-            value: $id.value,
-            enumerable: false,
-            configurable: false,
-            writable: false
-          }
-        });
-      } else if (state.value?.$id) {
-        $id.value = state.value.$id;
-      }
-    }
-    $value.value = $selfStatus.value.$value;
-    if (Array.isArray(state.value) && !immediateScopeState.isPrimitiveArray.value) {
-      $eachStatus.value = state.value.filter((value) => typeof value === "object").map((value, index) => {
-        const { scope: scope2, unwrapped } = unwrapGetter(
-          rulesDef.value.$each,
-          vue.toRef(() => value),
-          index
-        );
-        if (scope2) {
-          collectionScopes.push(scope2);
-        }
-        const initialStateRef = vue.toRef(initialState.value ?? [], index);
-        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, `$each`);
-        const $schemaErrors = vue.computed(() => schemaErrors?.value?.$each);
-        const element = createCollectionElement({
-          $id: $id.value,
-          path,
-          customMessages,
-          rules: unwrapped ?? {},
-          stateValue: vue.toRef(() => value),
-          index,
-          options,
-          storage,
-          externalErrors: $externalErrors,
-          schemaErrors: $schemaErrors,
-          initialState: initialStateRef,
-          shortcuts,
-          fieldName,
-          schemaMode
-        });
-        if (element) {
-          return element;
-        }
-        return null;
-      }).filter((each) => !!each);
-    } else {
-      $eachStatus.value = [];
-    }
-    $selfStatus.value = createReactiveFieldStatus({
-      state,
-      rulesDef,
-      customMessages,
-      path,
-      storage,
-      options,
-      externalErrors: vue.toRef(externalErrors?.value ?? {}, `$self`),
-      schemaErrors: vue.computed(() => schemaErrors?.value?.$self),
-      $isArray: true,
-      initialState,
-      shortcuts,
-      fieldName,
-      schemaMode
-    });
-  }
-  function updateStatus() {
-    if (Array.isArray(state.value) && !immediateScopeState.isPrimitiveArray.value) {
-      const previousStatus = cloneDeep($eachStatus.value);
-      $eachStatus.value = state.value.filter((value) => typeof value === "object").map((value, index) => {
-        const currentValue = vue.toRef(() => value);
-        if (value.$id && $eachStatus.value.find((each) => each.$id === value.$id)) {
-          const existingStatus = storage.getArrayStatus($id.value, value.$id);
-          if (existingStatus) {
-            existingStatus.$value = currentValue;
-            return existingStatus;
-          }
-          return null;
-        } else {
-          const { scope: scope2, unwrapped } = unwrapGetter(rulesDef.value.$each, currentValue, index);
-          if (scope2) {
-            collectionScopes.push(scope2);
-          }
-          const $externalErrors = vue.toRef(externalErrors?.value ?? {}, `$each`);
-          const $schemaErrors = vue.computed(() => schemaErrors?.value?.$each ?? []);
-          const element = createCollectionElement({
-            $id: $id.value,
-            path,
-            customMessages,
-            rules: unwrapped ?? {},
-            stateValue: currentValue,
-            index,
-            options,
-            storage,
-            externalErrors: $externalErrors,
-            schemaErrors: $schemaErrors,
-            initialState: vue.toRef(initialState.value ?? [], index),
-            shortcuts,
-            fieldName,
-            schemaMode
-          });
-          if (element) {
-            return element;
-          }
-          return null;
-        }
-      }).filter((each) => !!each);
-      previousStatus.filter(($each) => !state.value?.find((f) => $each.$id === f.$id)).forEach((_, index) => {
-        storage.deleteArrayStatus($id.value, index.toString());
-      });
-    } else {
-      $eachStatus.value = [];
-    }
-  }
-  function define$watchState() {
-    $unwatchState = vue.watch(
-      state,
-      () => {
-        if (state.value != null && !Object.hasOwn(state.value, "$id")) {
-          createStatus();
-        } else {
-          updateStatus();
-        }
-      },
-      { deep: isVueSuperiorOrEqualTo3dotFive ? 1 : true, flush: "pre" }
-    );
-  }
-  function $watch() {
-    define$watchState();
-    scope = vue.effectScope();
-    scopeState = scope.run(() => {
-      const $silentValue = vue.computed({
-        get: () => state.value,
-        set(value) {
-          $unwatchState();
-          state.value = value;
-          define$watchState();
-        }
-      });
-      const $dirty = vue.computed(() => {
-        return $selfStatus.value.$dirty && (!$eachStatus.value.length || $eachStatus.value.every((statusOrField) => {
-          return statusOrField.$dirty;
-        }));
-      });
-      const $anyDirty = vue.computed(() => {
-        return $selfStatus.value.$anyDirty || $eachStatus.value.some((statusOrField) => {
-          return statusOrField.$anyDirty;
-        });
-      });
-      const $invalid = vue.computed(() => {
-        return $selfStatus.value.$invalid || $eachStatus.value.some((statusOrField) => {
-          return statusOrField.$invalid;
-        });
-      });
-      const $correct = vue.computed(() => {
-        return (isEmpty($selfStatus.value.$rules) ? true : $selfStatus.value.$correct) && (!$eachStatus.value.length || $eachStatus.value.every((statusOrField) => {
-          return statusOrField.$correct || statusOrField.$anyDirty && !statusOrField.$invalid;
-        }));
-      });
-      const $error = vue.computed(() => {
-        return $selfStatus.value.$error || $eachStatus.value.some((statusOrField) => {
-          return statusOrField.$error;
-        });
-      });
-      const $ready = vue.computed(() => {
-        return !($invalid.value || $pending.value);
-      });
-      const $pending = vue.computed(() => {
-        return $selfStatus.value.$pending || $eachStatus.value.some((statusOrField) => {
-          return statusOrField.$pending;
-        });
-      });
-      const $edited = vue.computed(() => {
-        return !!$eachStatus.value.length && $eachStatus.value.every((statusOrField) => {
-          return statusOrField.$edited;
-        });
-      });
-      const $anyEdited = vue.computed(() => {
-        return $selfStatus.value.$anyEdited || $eachStatus.value.some((statusOrField) => {
-          return statusOrField.$anyEdited;
-        });
-      });
-      const $errors = vue.computed(() => {
-        return {
-          $self: $selfStatus.value.$errors,
-          $each: $eachStatus.value.map(($each) => $each.$errors)
-        };
-      });
-      const $silentErrors = vue.computed(() => {
-        return {
-          $self: $selfStatus.value.$silentErrors,
-          $each: $eachStatus.value.map(($each) => $each.$silentErrors)
-        };
-      });
-      const $name = vue.computed(() => fieldName);
-      function processShortcuts() {
-        if (shortcuts?.collections) {
-          Object.entries(shortcuts?.collections).forEach(([key, value]) => {
-            const scope2 = vue.effectScope();
-            $shortcuts2[key] = scope2.run(() => {
-              const result = vue.ref();
-              vue.watchEffect(() => {
-                result.value = value(
-                  vue.reactive({
-                    $dirty,
-                    $error,
-                    $silentValue,
-                    $pending,
-                    $invalid,
-                    $correct,
-                    $errors,
-                    $ready,
-                    $silentErrors,
-                    $anyDirty,
-                    $name,
-                    $each: $eachStatus,
-                    $self: $selfStatus,
-                    $value: state,
-                    $edited,
-                    $anyEdited
-                  })
-                );
-              });
-              return result;
-            });
-            collectionScopes.push(scope2);
-          });
-        }
-      }
-      const $shortcuts2 = {};
-      processShortcuts();
-      return {
-        $dirty,
-        $anyDirty,
-        $invalid,
-        $correct,
-        $error,
-        $pending,
-        $errors,
-        $silentErrors,
-        $ready,
-        $name,
-        $shortcuts: $shortcuts2,
-        $silentValue,
-        $edited,
-        $anyEdited
-      };
-    });
-    if (immediateScopeState.isPrimitiveArray.value && rulesDef.value.$each) {
-      console.warn(
-        `${path} is a Array of primitives. Tracking can be lost when reassigning the Array. We advise to use an Array of objects instead`
-      );
-    }
-  }
-  function $unwatch() {
-    if ($unwatchState) {
-      $unwatchState();
-    }
-    if ($selfStatus.value) {
-      $selfStatus.value.$unwatch();
-    }
-    if ($eachStatus.value) {
-      $eachStatus.value.forEach((element) => {
-        if ("$dirty" in element) {
-          element.$unwatch();
-        }
-      });
-    }
-    scope.stop();
-    scope = vue.effectScope();
-    immediateScope.stop();
-    immediateScope = vue.effectScope(true);
-    collectionScopes.forEach((s) => s.stop());
-    collectionScopes = [];
-  }
-  function $touch(runCommit = true, withConditions = false) {
-    $selfStatus.value.$touch(runCommit, withConditions);
-    $eachStatus.value.forEach(($each) => {
-      $each.$touch(runCommit, withConditions);
-    });
-  }
-  function $reset(options2, fromParent) {
-    $unwatch();
-    if (!fromParent) {
-      if (options2?.toInitialState) {
-        state.value = cloneDeep(initialState.value);
-      } else if (options2?.toState) {
-        let newInitialState;
-        if (typeof options2?.toState === "function") {
-          newInitialState = options2?.toState();
-        } else {
-          newInitialState = options2?.toState;
-        }
-        initialState.value = cloneDeep(newInitialState);
-        state.value = cloneDeep(newInitialState);
-      } else {
-        initialState.value = cloneDeep(state.value);
-      }
-    }
-    if (options2?.clearExternalErrors) {
-      $clearExternalErrors();
-    }
-    $selfStatus.value.$reset();
-    $eachStatus.value.forEach(($each) => {
-      $each.$reset(options2, true);
-    });
-    if (!fromParent) {
-      createStatus();
-    }
-  }
-  async function $validate() {
-    const data = state.value;
-    try {
-      const results = await Promise.allSettled([
-        $selfStatus.value.$validate(),
-        ...$eachStatus.value.map((status) => {
-          return status.$validate();
-        })
-      ]);
-      const validationResults = results.every((value) => {
-        if (value.status === "fulfilled") {
-          return value.value.valid === true;
-        } else {
-          return false;
-        }
-      });
-      return { valid: validationResults, data };
-    } catch (e) {
-      return { valid: false, data };
-    }
-  }
-  function $clearExternalErrors() {
-    $selfStatus.value.$clearExternalErrors();
-    $eachStatus.value.forEach(($each) => {
-      $each.$clearExternalErrors();
-    });
-  }
-  function $extractDirtyFields(filterNullishValues = true) {
-    let dirtyFields = $eachStatus.value.map(($each) => {
-      if (isNestedRulesStatus($each)) {
-        return $each.$extractDirtyFields(filterNullishValues);
-      }
-    });
-    if (filterNullishValues) {
-      if (dirtyFields.every((value) => {
-        return isEmpty(value);
-      })) {
-        dirtyFields = [];
-      }
-    }
-    return dirtyFields;
-  }
-  const { $shortcuts, ...restScopeState } = scopeState;
-  return vue.reactive({
-    $self: $selfStatus,
-    ...restScopeState,
-    ...$shortcuts,
-    $each: $eachStatus,
-    $value: state,
-    $validate,
-    $unwatch,
-    $watch,
-    $touch,
-    $reset,
-    $extractDirtyFields,
-    $clearExternalErrors
-  });
-}
-
-// src/core/useRegle/root/createReactiveNestedStatus.ts
-function createReactiveNestedStatus({
-  rulesDef,
-  state,
-  path = "",
-  rootRules,
-  externalErrors,
-  schemaErrors,
-  rootSchemaErrors,
-  validationGroups,
-  initialState,
-  fieldName,
-  ...commonArgs
-}) {
-  let scope = vue.effectScope();
-  let scopeState;
-  let nestedScopes = [];
-  let $unwatchRules = null;
-  let $unwatchSchemaErrors = null;
-  let $unwatchExternalErrors = null;
-  let $unwatchState = null;
-  async function createReactiveFieldsStatus(watchSources = true) {
-    const mapOfRulesDef = Object.entries(rulesDef.value);
-    const scopedRulesStatus = Object.fromEntries(
-      mapOfRulesDef.filter(([_, rule]) => !!rule).map(([statePropKey, statePropRules]) => {
-        if (statePropRules) {
-          const stateRef = vue.toRef(state.value ?? {}, statePropKey);
-          const statePropRulesRef = vue.toRef(() => statePropRules);
-          const $externalErrors = vue.toRef(externalErrors?.value ?? {}, statePropKey);
-          const $schemaErrors = vue.computed(() => schemaErrors?.value?.[statePropKey]);
-          const initialStateRef = vue.toRef(initialState?.value ?? {}, statePropKey);
-          return [
-            statePropKey,
-            createReactiveChildrenStatus({
-              state: stateRef,
-              rulesDef: statePropRulesRef,
-              path: path ? `${path}.${statePropKey}` : statePropKey,
-              externalErrors: $externalErrors,
-              schemaErrors: $schemaErrors,
-              initialState: initialStateRef,
-              fieldName: statePropKey,
-              ...commonArgs
-            })
-          ];
-        }
-        return [];
-      })
-    );
-    const externalRulesStatus = Object.fromEntries(
-      Object.entries(vue.unref(externalErrors) ?? {}).filter(([key, errors]) => !(key in rulesDef.value) && !!errors).map(([key]) => {
-        const stateRef = vue.toRef(state.value ?? {}, key);
-        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, key);
-        const $schemaErrors = vue.computed(() => schemaErrors?.value?.[key]);
-        const initialStateRef = vue.toRef(initialState?.value ?? {}, key);
-        return [
-          key,
-          createReactiveChildrenStatus({
-            state: stateRef,
-            rulesDef: vue.computed(() => ({})),
-            path: path ? `${path}.${key}` : key,
-            externalErrors: $externalErrors,
-            schemaErrors: $schemaErrors,
-            initialState: initialStateRef,
-            fieldName: key,
-            ...commonArgs
-          })
-        ];
-      })
-    );
-    const schemasRulesStatus = Object.fromEntries(
-      Object.entries(vue.unref(schemaErrors) ?? {}).map(([key]) => {
-        const stateRef = vue.toRef(state.value ?? {}, key);
-        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, key);
-        const $schemaErrors = vue.computed(() => schemaErrors?.value?.[key]);
-        const initialStateRef = vue.toRef(initialState?.value ?? {}, key);
-        return [
-          key,
-          createReactiveChildrenStatus({
-            state: stateRef,
-            rulesDef: vue.computed(() => ({})),
-            path: path ? `${path}.${key}` : key,
-            externalErrors: $externalErrors,
-            schemaErrors: $schemaErrors,
-            initialState: initialStateRef,
-            fieldName: key,
-            ...commonArgs
-          })
-        ];
-      })
-    );
-    const statesWithNoRules = Object.fromEntries(
-      Object.entries(state.value ?? {}).filter(
-        ([key]) => !(key in rulesDef.value) && !(key in (externalRulesStatus ?? {})) && !(key in (schemasRulesStatus ?? {}))
-      ).map(([key]) => {
-        const stateRef = vue.toRef(state.value ?? {}, key);
-        const $externalErrors = vue.toRef(externalErrors?.value ?? {}, key);
-        const $schemaErrors = vue.computed(() => schemaErrors?.value?.[key]);
-        const initialStateRef = vue.toRef(initialState?.value ?? {}, key);
-        return [
-          key,
-          createReactiveChildrenStatus({
-            state: stateRef,
-            rulesDef: vue.computed(() => ({})),
-            path: path ? `${path}.${key}` : key,
-            externalErrors: $externalErrors,
-            schemaErrors: $schemaErrors,
-            initialState: initialStateRef,
-            fieldName: key,
-            ...commonArgs
-          })
-        ];
-      })
-    );
-    $fields.value = {
-      ...scopedRulesStatus,
-      ...externalRulesStatus,
-      ...schemasRulesStatus,
-      ...statesWithNoRules
-    };
-    if (watchSources) {
-      $watch();
-    }
-  }
-  const $fields = commonArgs.storage.getFieldsEntry(path);
-  createReactiveFieldsStatus();
-  function define$WatchExternalErrors() {
-    if (externalErrors) {
-      $unwatchExternalErrors = vue.watch(
-        externalErrors,
-        () => {
-          $unwatch();
-          createReactiveFieldsStatus();
-        },
-        { deep: true }
-      );
-    }
-  }
-  function define$watchState() {
-    $unwatchState = vue.watch(
-      state,
-      () => {
-        $unwatch();
-        createReactiveFieldsStatus();
-        $touch(true, true);
-      },
-      { flush: "sync" }
-    );
-  }
-  function $watch() {
-    if (rootRules) {
-      $unwatchRules?.();
-      $unwatchRules = vue.watch(
-        rootRules,
-        () => {
-          $unwatch();
-          createReactiveFieldsStatus();
-        },
-        { deep: true, flush: "pre" }
-      );
-      define$WatchExternalErrors();
-    }
-    if (rootSchemaErrors) {
-      $unwatchSchemaErrors?.();
-      $unwatchSchemaErrors = vue.watch(
-        rootSchemaErrors,
-        () => {
-          $unwatch();
-          createReactiveFieldsStatus();
-        },
-        { deep: true, flush: "post" }
-      );
-    }
-    define$watchState();
-    scopeState = scope.run(() => {
-      const $silentValue = vue.computed({
-        get: () => state.value,
-        set(value) {
-          $unwatch();
-          state.value = value;
-          createReactiveFieldsStatus();
-        }
-      });
-      const $dirty = vue.computed(() => {
-        return !!Object.entries($fields.value).length && Object.entries($fields.value).every(([_, statusOrField]) => {
-          return statusOrField?.$dirty;
-        });
-      });
-      const $anyDirty = vue.computed(() => {
-        return Object.entries($fields.value).some(([_, statusOrField]) => {
-          return statusOrField?.$anyDirty;
-        });
-      });
-      const $invalid = vue.computed(() => {
-        return !!Object.entries($fields.value).length && Object.entries($fields.value).some(([_, statusOrField]) => {
-          return statusOrField?.$invalid;
-        });
-      });
-      const $correct = vue.computed(() => {
-        const fields = Object.entries($fields.value).filter(([_, statusOrField]) => {
-          if (isFieldStatus(statusOrField)) {
-            return !statusOrField.$inactive;
-          }
-          return true;
-        });
-        if (fields.length) {
-          return fields.every(([_, statusOrField]) => {
-            return statusOrField?.$correct || statusOrField.$anyDirty && !statusOrField.$invalid;
-          });
-        }
-        return false;
-      });
-      const $error = vue.computed(() => {
-        return !!Object.entries($fields.value).length && Object.entries($fields.value).some(([_, statusOrField]) => {
-          return statusOrField?.$error;
-        });
-      });
-      const $rewardEarly = vue.computed(() => {
-        if (vue.unref(commonArgs.options.rewardEarly) != null) {
-          return vue.unref(commonArgs.options.rewardEarly);
-        }
-        return false;
-      });
-      const $autoDirty = vue.computed(() => {
-        if (vue.unref(commonArgs.options.autoDirty) != null) {
-          return vue.unref(commonArgs.options.autoDirty);
-        } else if ($rewardEarly.value) {
-          return false;
-        }
-        return true;
-      });
-      const $ready = vue.computed(() => {
-        if (!$autoDirty.value) {
-          return !($invalid.value || $pending.value);
-        }
-        return $anyDirty.value && !($invalid.value || $pending.value);
-      });
-      const $localPending2 = vue.ref(false);
-      const $pending = vue.computed(() => {
-        return $localPending2.value || Object.entries($fields.value).some(([key, statusOrField]) => {
-          return statusOrField?.$pending;
-        });
-      });
-      const $errors = vue.computed(() => {
-        return Object.fromEntries(
-          Object.entries($fields.value).map(([key, statusOrField]) => {
-            return [key, statusOrField?.$errors];
-          })
-        );
-      });
-      const $silentErrors = vue.computed(() => {
-        return Object.fromEntries(
-          Object.entries($fields.value).map(([key, statusOrField]) => {
-            return [key, statusOrField?.$silentErrors];
-          })
-        );
-      });
-      const $edited = vue.computed(() => {
-        return !!Object.entries($fields.value).length && Object.entries($fields.value).every(([_, statusOrField]) => {
-          return statusOrField?.$edited;
-        });
-      });
-      const $anyEdited = vue.computed(() => {
-        return Object.entries($fields.value).some(([_, statusOrField]) => {
-          return statusOrField?.$anyEdited;
-        });
-      });
-      const $name = vue.computed(() => fieldName);
-      function processShortcuts() {
-        if (commonArgs.shortcuts?.nested) {
-          Object.entries(commonArgs.shortcuts.nested).forEach(([key, value]) => {
-            const scope2 = vue.effectScope();
-            $shortcuts2[key] = scope2.run(() => {
-              const result = vue.ref();
-              vue.watchEffect(() => {
-                result.value = value(
-                  vue.reactive({
-                    $dirty,
-                    $value: state,
-                    $silentValue,
-                    $error,
-                    $pending,
-                    $invalid,
-                    $correct,
-                    $ready,
-                    $anyDirty,
-                    $name,
-                    $silentErrors,
-                    $errors,
-                    $fields,
-                    $edited,
-                    $anyEdited
-                  })
-                );
-              });
-              return result;
-            });
-            nestedScopes.push(scope2);
-          });
-        }
-      }
-      const $groups = vue.computed({
-        get: () => {
-          if (validationGroups) {
-            return Object.fromEntries(
-              Object.entries(validationGroups?.($fields.value) ?? {}).map(([key, entries]) => {
-                if (entries.length) {
-                  return [
-                    key,
-                    {
-                      ...Object.fromEntries(
-                        ["$invalid", "$error", "$pending", "$dirty", "$correct"].map((property) => [
-                          property,
-                          mergeBooleanGroupProperties(entries, property)
-                        ])
-                      ),
-                      ...Object.fromEntries(
-                        ["$errors", "$silentErrors"].map((property) => [
-                          property,
-                          mergeArrayGroupProperties(entries, property)
-                        ])
-                      )
-                    }
-                  ];
-                }
-                return [];
-              })
-            );
-          }
-          return {};
-        },
-        set() {
-        }
-      });
-      const $shortcuts2 = {};
-      processShortcuts();
-      return {
-        $dirty,
-        $anyDirty,
-        $invalid,
-        $correct,
-        $error,
-        $pending,
-        $errors,
-        $silentErrors,
-        $ready,
-        $name,
-        $shortcuts: $shortcuts2,
-        $groups,
-        $silentValue,
-        $edited,
-        $anyEdited,
-        $localPending: $localPending2
-      };
-    });
-  }
-  function $unwatch() {
-    $unwatchRules?.();
-    $unwatchExternalErrors?.();
-    $unwatchState?.();
-    $unwatchSchemaErrors?.();
-    nestedScopes = [];
-    scopeState = {};
-    if ($fields.value) {
-      Object.entries($fields.value).forEach(([_, field]) => {
-        field.$unwatch();
-      });
-    }
-  }
-  function $clearExternalErrors() {
-    Object.entries($fields.value).forEach(([_, field]) => {
-      field.$clearExternalErrors();
-    });
-  }
-  function $reset(options, fromParent) {
-    $unwatchExternalErrors?.();
-    $unwatch();
-    if (!fromParent) {
-      if (options?.toInitialState) {
-        state.value = cloneDeep({ ...initialState.value ?? {} });
-      } else if (options?.toState) {
-        let newInitialState;
-        if (typeof options?.toState === "function") {
-          newInitialState = options?.toState();
-        } else {
-          newInitialState = options?.toState;
-        }
-        initialState.value = cloneDeep(newInitialState);
-        state.value = cloneDeep(newInitialState);
-      } else {
-        initialState.value = cloneDeep(state.value);
-      }
-    }
-    Object.values($fields.value).forEach((statusOrField) => {
-      statusOrField.$reset(options, true);
-    });
-    if (options?.clearExternalErrors) {
-      $clearExternalErrors();
-    }
-    define$WatchExternalErrors();
-    if (!fromParent) {
-      createReactiveFieldsStatus();
-    }
-  }
-  function $touch(runCommit = true, withConditions = false) {
-    Object.values($fields.value).forEach((statusOrField) => {
-      statusOrField.$touch(runCommit, withConditions);
-    });
-  }
-  function filterNullishFields(fields) {
-    return fields.filter(([key, value]) => {
-      if (isObject(value)) {
-        return !(value && typeof value === "object" && "_null" in value) && !isEmpty(value);
-      } else if (Array.isArray(value)) {
-        return value.length;
-      } else {
-        return true;
-      }
-    });
-  }
-  function $extractDirtyFields(filterNullishValues = true) {
-    let dirtyFields = Object.entries($fields.value).map(([key, field]) => {
-      return [key, field.$extractDirtyFields(filterNullishValues)];
-    });
-    if (filterNullishValues) {
-      dirtyFields = filterNullishFields(dirtyFields);
-    }
-    return Object.fromEntries(dirtyFields);
-  }
-  async function $validate() {
-    try {
-      if (commonArgs.schemaMode) {
-        if (commonArgs.onValidate) {
-          $touch(false);
-          scopeState.$localPending.value = true;
-          return commonArgs.onValidate();
-        } else {
-          return { valid: false, data: state.value };
-        }
-      } else {
-        const data = state.value;
-        const results = await Promise.allSettled(
-          Object.values($fields.value).map((statusOrField) => {
-            return statusOrField.$validate();
-          })
-        );
-        const validationResults = results.every((value) => {
-          if (value.status === "fulfilled") {
-            return value.value.valid === true;
-          } else {
-            return false;
-          }
-        });
-        return { valid: validationResults, data };
-      }
-    } catch (e) {
-      return { valid: false, data: state.value };
-    } finally {
-      scopeState.$localPending.value = false;
-    }
-  }
-  const { $shortcuts, $localPending, ...restScopeState } = scopeState;
-  return vue.reactive({
-    ...restScopeState,
-    ...$shortcuts,
-    $fields,
-    $value: state,
-    $reset,
-    $touch,
-    $validate,
-    $unwatch,
-    $watch,
-    $clearExternalErrors,
-    $extractDirtyFields
-  });
-}
-function createReactiveChildrenStatus({
-  rulesDef,
-  ...properties
-}) {
-  if (isCollectionRulesDef(rulesDef, properties.state, properties.schemaMode)) {
-    return createReactiveCollectionStatus({
-      rulesDef,
-      ...properties
-    });
-  } else if (isNestedRulesDef(properties.state, rulesDef)) {
-    if (isRefObject(properties.state)) {
-      return createReactiveNestedStatus({
-        rulesDef,
-        ...properties
-      });
-    } else {
-      const scope = vue.effectScope();
-      const scopeState = scope.run(() => {
-        const fakeState = vue.toRef(properties.state.value ? properties.state : vue.ref({}));
-        vue.watch(
-          () => properties.state.value,
-          (value) => {
-            fakeState.value = value;
-          },
-          { deep: true }
-        );
-        vue.watch(
-          fakeState,
-          (value) => {
-            properties.state.value = value;
-          },
-          { deep: true }
-        );
-        return { fakeState };
-      });
-      const { state, ...restProperties } = properties;
-      return createReactiveNestedStatus({
-        rulesDef,
-        ...restProperties,
-        state: scopeState.fakeState
-      });
-    }
-  } else if (isValidatorRulesDef(rulesDef)) {
-    return createReactiveFieldStatus({
-      rulesDef,
-      ...properties
-    });
-  }
-  return void 0;
-}
-
-// src/core/useRegle/root/useRootStorage.ts
-function useRootStorage({
-  initialState,
-  options,
-  scopeRules,
-  state,
-  customRules,
-  shortcuts,
-  schemaErrors,
-  schemaMode = false,
-  onValidate
-}) {
-  const storage = useStorage();
-  const regle = vue.ref();
-  if (isNestedRulesDef(state, scopeRules)) {
-    regle.value = createReactiveNestedStatus({
-      rootRules: scopeRules,
-      rulesDef: scopeRules,
-      state,
-      customMessages: customRules?.(),
-      storage,
-      options,
-      externalErrors: options.externalErrors,
-      validationGroups: options.validationGroups,
-      initialState,
-      shortcuts,
-      fieldName: "root",
-      path: "",
-      schemaErrors,
-      rootSchemaErrors: schemaErrors,
-      schemaMode,
-      onValidate
-    });
-  } else if (isValidatorRulesDef(scopeRules)) {
-    regle.value = createReactiveFieldStatus({
-      rulesDef: scopeRules,
-      state,
-      customMessages: customRules?.(),
-      storage,
-      options,
-      externalErrors: options.externalErrors,
-      initialState,
-      shortcuts,
-      fieldName: "root",
-      path: "",
-      schemaMode,
-      schemaErrors,
-      onValidate
-    });
-  }
-  if (vue.getCurrentScope()) {
-    vue.onScopeDispose(() => {
-      regle.value?.$unwatch();
-    });
-  }
-  return vue.reactive({ regle });
-}
-
-// src/core/useRegle/useRegle.ts
-function createUseRegleComposable(customRules, options, shortcuts) {
-  const globalOptions = {
-    autoDirty: options?.autoDirty,
-    lazy: options?.lazy,
-    rewardEarly: options?.rewardEarly,
-    clearExternalErrorsOnChange: options?.clearExternalErrorsOnChange
-  };
-  function useRegle2(state, rulesFactory, options2) {
-    const scopeRules = vue.isRef(rulesFactory) ? rulesFactory : vue.computed(typeof rulesFactory === "function" ? rulesFactory : () => rulesFactory);
-    const resolvedOptions = {
-      ...globalOptions,
-      ...options2
-    };
-    const processedState = vue.isRef(state) ? state : vue.ref(state);
-    const initialState = vue.ref(
-      isObject(processedState.value) ? { ...cloneDeep(processedState.value) } : cloneDeep(processedState.value)
-    );
-    const regle = useRootStorage({
-      scopeRules,
-      state: processedState,
-      options: resolvedOptions,
-      initialState,
-      customRules,
-      shortcuts
-    });
-    return {
-      r$: regle.regle
-    };
-  }
-  return useRegle2;
-}
-var useRegle = createUseRegleComposable();
-function createInferRuleHelper() {
-  function inferRules2(state, rulesFactory) {
-    return rulesFactory;
-  }
-  return inferRules2;
-}
-var inferRules = createInferRuleHelper();
-
-// src/core/defineRegleConfig.ts
-function defineRegleConfig({
-  rules,
-  modifiers,
-  shortcuts
-}) {
-  const useRegle2 = createUseRegleComposable(rules, modifiers, shortcuts);
-  const inferRules2 = createInferRuleHelper();
-  return { useRegle: useRegle2, inferRules: inferRules2 };
-}
-function mergeRegles(regles, _scoped) {
-  const scoped = _scoped == null ? false : _scoped;
-  const $value = vue.computed({
-    get: () => {
-      if (scoped) {
-        return Object.values(regles).map((r) => r.$value);
-      } else {
-        return Object.fromEntries(Object.entries(regles).map(([key, r]) => [key, r.$value]));
-      }
-    },
-    set: (value) => {
-      if (!scoped) {
-        if (typeof value === "object") {
-          Object.entries(value).forEach(([key, newValue]) => regles[key].$value = newValue);
-        }
-      }
-    }
-  });
-  const $silentValue = vue.computed({
-    get: () => Object.fromEntries(Object.entries(regles).map(([key, r]) => [key, r.$silentValue])),
-    set: (value) => {
-      if (typeof value === "object") {
-        Object.entries(value).forEach(([key, newValue]) => regles[key].$silentValue = newValue);
-      }
-    }
-  });
-  const $dirty = vue.computed(() => {
-    const entries = Object.entries(regles);
-    return !!entries.length && entries.every(([_, regle]) => {
-      return regle?.$dirty;
-    });
-  });
-  const $anyDirty = vue.computed(() => {
-    return Object.entries(regles).some(([_, regle]) => {
-      return regle?.$anyDirty;
-    });
-  });
-  const $invalid = vue.computed(() => {
-    return Object.entries(regles).some(([_, regle]) => {
-      return regle?.$invalid;
-    });
-  });
-  const $correct = vue.computed(() => {
-    const entries = Object.entries(regles);
-    return !!entries.length && entries.every(([_, regle]) => {
-      return regle?.$correct || regle.$anyDirty && !regle.$invalid;
-    });
-  });
-  const $error = vue.computed(() => {
-    return Object.entries(regles).some(([_, regle]) => {
-      return regle?.$error;
-    });
-  });
-  const $ready = vue.computed(() => {
-    const entries = Object.entries(regles);
-    return !!entries.length && entries.every(([_, regle]) => {
-      return regle?.$ready;
-    });
-  });
-  const $pending = vue.computed(() => {
-    return Object.entries(regles).some(([_, regle]) => {
-      return regle?.$pending;
-    });
-  });
-  const $errors = vue.computed(() => {
-    if (scoped) {
-      return Object.entries(regles).map(([_, regle]) => {
-        return regle.$errors;
-      });
-    } else {
-      return Object.fromEntries(
-        Object.entries(regles).map(([key, regle]) => {
-          return [key, regle.$errors];
-        })
-      );
-    }
-  });
-  const $silentErrors = vue.computed(() => {
-    if (scoped) {
-      return Object.entries(regles).map(([_, regle]) => {
-        return regle.$silentErrors;
-      });
-    } else {
-      return Object.fromEntries(
-        Object.entries(regles).map(([key, regle]) => {
-          return [key, regle.$silentErrors];
-        })
-      );
-    }
-  });
-  const $edited = vue.computed(() => {
-    const entries = Object.entries(regles);
-    return !!entries.length && entries.every(([_, regle]) => {
-      return regle?.$edited;
-    });
-  });
-  const $anyEdited = vue.computed(() => {
-    return Object.entries(regles).some(([_, regle]) => {
-      return regle?.$anyEdited;
-    });
-  });
-  const $instances = vue.computed(() => {
-    if (scoped) {
-      return Object.values(regles);
-    } else {
-      return regles;
-    }
-  });
-  function $reset(options) {
-    Object.values(regles).forEach((regle) => {
-      regle.$reset(options);
-    });
-  }
-  function $touch() {
-    Object.values(regles).forEach((regle) => {
-      regle.$touch();
-    });
-  }
-  function $extractDirtyFields(filterNullishValues = true) {
-    return Object.values(regles).map((regle) => regle.$extractDirtyFields(filterNullishValues));
-  }
-  function $clearExternalErrors() {
-    Object.values(regles).forEach((regle) => {
-      regle.$clearExternalErrors();
-    });
-  }
-  async function $validate() {
-    try {
-      const data = $value.value;
-      const results = await Promise.allSettled(
-        Object.values(regles).map((regle) => {
-          return regle.$validate();
-        })
-      );
-      const validationResults = results.every((value) => {
-        if (value.status === "fulfilled") {
-          return value.value.valid === true;
-        } else {
-          return false;
-        }
-      });
-      return { valid: validationResults, data };
-    } catch (e) {
-      return { valid: false, data: $value.value };
-    }
-  }
-  return vue.reactive({
-    ...!scoped && {
-      $silentValue
-    },
-    $errors,
-    $silentErrors,
-    $instances,
-    $value,
-    $dirty,
-    $anyDirty,
-    $invalid,
-    $correct,
-    $error,
-    $pending,
-    $ready,
-    $edited,
-    $anyEdited,
-    $reset,
-    $touch,
-    $validate,
-    $extractDirtyFields,
-    $clearExternalErrors
-  });
-}
-function createUseCollectScope(instances) {
-  function useCollectScope2(namespace) {
-    const computedNamespace = vue.computed(() => vue.toValue(namespace));
-    setEmptyNamespace();
-    const r$ = vue.ref(collectRegles(instances.value));
-    const regle = vue.reactive({ r$ });
-    function setEmptyNamespace() {
-      if (computedNamespace.value && !instances.value[computedNamespace.value]) {
-        instances.value[computedNamespace.value] = {};
-      }
-    }
-    vue.watch(computedNamespace, setEmptyNamespace);
-    vue.watch(
-      instances,
-      (newInstances) => {
-        r$.value = collectRegles(newInstances);
-      },
-      { deep: true }
-    );
-    function collectRegles(r$Instances) {
-      if (computedNamespace.value) {
-        const namespaceInstances = r$Instances[computedNamespace.value] ?? {};
-        return mergeRegles(namespaceInstances, true);
-      } else {
-        return mergeRegles(r$Instances["~~global"] ?? {}, true);
-      }
-    }
-    return { r$: regle.r$ };
-  }
-  return { useCollectScope: useCollectScope2 };
-}
-function createUseScopedRegleComposable(instances, customUseRegle) {
-  const scopedUseRegle = customUseRegle ?? useRegle;
-  const useScopedRegle2 = (state, rulesFactory, options) => {
-    const { namespace, ...restOptions } = options ?? {};
-    const computedNamespace = vue.computed(() => vue.toValue(namespace));
-    const $id = vue.ref(`${Object.keys(instances.value).length + 1}-${randomId()}`);
-    const instanceName = vue.computed(() => {
-      return `instance-${$id.value}`;
-    });
-    const { r$ } = scopedUseRegle(state, rulesFactory, restOptions);
-    register();
-    tryOnScopeDispose(dispose);
-    vue.watch(computedNamespace, (newName, oldName) => {
-      dispose(oldName);
-      register();
-    });
-    if (vue.getCurrentInstance()) {
-      vue.onMounted(() => {
-        const currentInstance = vue.getCurrentInstance();
-        if (typeof window !== "undefined" && currentInstance?.proxy?.$el?.parentElement) {
-          if (document.documentElement && !document.documentElement.contains(currentInstance?.proxy?.$el?.parentElement)) {
-            dispose();
-          }
-        }
-      });
-    }
-    function dispose(oldName) {
-      const nameToClean = oldName ?? computedNamespace.value;
-      if (nameToClean) {
-        if (instances.value[nameToClean]) {
-          delete instances.value[nameToClean][instanceName.value];
-        }
-      } else if (instances.value["~~global"][instanceName.value]) {
-        delete instances.value["~~global"][instanceName.value];
-      }
-    }
-    function register() {
-      if (computedNamespace.value) {
-        if (!instances.value[computedNamespace.value]) {
-          instances.value[computedNamespace.value] = {};
-        }
-        instances.value[computedNamespace.value][instanceName.value] = r$;
-      } else {
-        if (!instances.value["~~global"]) {
-          instances.value["~~global"] = {};
-        }
-        instances.value["~~global"][instanceName.value] = r$;
-      }
-    }
-    return { r$, dispose, register };
-  };
-  return { useScopedRegle: useScopedRegle2 };
-}
-
-// src/core/createScopedUseRegle/createScopedUseRegle.ts
-function createScopedUseRegle(options) {
-  const useInstances = options?.customStore ? () => {
-    if (options.customStore) {
-      if (!options.customStore?.value["~~global"]) {
-        options.customStore.value["~~global"] = {};
-      } else if (options.customStore?.value) {
-        options.customStore.value = { "~~global": {} };
-      }
-    }
-    return options.customStore;
-  } : createGlobalState(() => {
-    const $inst = vue.ref({ "~~global": {} });
-    return $inst;
-  });
-  const instances = useInstances();
-  const { useScopedRegle: useScopedRegle2 } = createUseScopedRegleComposable(instances, options?.customUseRegle);
-  const { useCollectScope: useCollectScope2 } = createUseCollectScope(instances);
-  return {
-    useScopedRegle: useScopedRegle2,
-    useCollectScope: useCollectScope2
-  };
-}
-var { useCollectScope, useScopedRegle } = createScopedUseRegle();
-function createVariant(root, disciminantKey, variants) {
-  const watchableRoot = vue.computed(() => vue.toValue(root)[disciminantKey]);
-  const computedRules = vue.computed(() => {
-    const selectedVariant = variants.find((variant) => {
-      if (variant[disciminantKey] && "literal" in variant[disciminantKey]) {
-        const literalRule = variant[disciminantKey]["literal"];
-        if (isRuleDef(literalRule)) {
-          return vue.unref(literalRule._params?.[0]) === watchableRoot.value;
-        }
-      }
-    });
-    if (selectedVariant) {
-      return selectedVariant;
-    } else {
-      const anyDiscriminantRules = variants.find(
-        (variant) => isObject(variant[disciminantKey]) && !Object.keys(variant[disciminantKey]).some((key) => key === "literal")
-      );
-      if (anyDiscriminantRules) {
-        return anyDiscriminantRules;
-      } else {
-        return {};
-      }
-    }
-  });
-  return computedRules;
-}
-function discriminateVariant(root, discriminantKey, discriminantValue) {
-  return isObject(root[discriminantKey]) && "$value" in root[discriminantKey] && root[discriminantKey]?.$value === discriminantValue;
-}
-function inferVariantRef(root, discriminantKey, discriminantValue) {
-  let returnedRef;
-  if (discriminateVariant(root, discriminantKey, discriminantValue)) {
-    returnedRef = vue.toRef(root, discriminantKey);
-  }
-  return returnedRef;
-}
-
-exports.InternalRuleType = InternalRuleType;
-exports.createRule = createRule;
-exports.createScopedUseRegle = createScopedUseRegle;
-exports.createVariant = createVariant;
-exports.defineRegleConfig = defineRegleConfig;
-exports.discriminateVariant = discriminateVariant;
-exports.flatErrors = flatErrors;
-exports.inferRules = inferRules;
-exports.inferVariantRef = inferVariantRef;
-exports.mergeRegles = mergeRegles;
-exports.unwrapRuleParameters = unwrapRuleParameters;
-exports.useCollectScope = useCollectScope;
-exports.useRegle = useRegle;
-exports.useRootStorage = useRootStorage;
-exports.useScopedRegle = useScopedRegle;