@vuehookform/core 0.4.2 → 0.4.4

package/dist/vuehookform.cjs

@@ -1,1823 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let vue = require("vue");
-var pathCache = /* @__PURE__ */ new Map();
-var PATH_CACHE_MAX_SIZE = 256;
-var MAX_ARRAY_INDEX = 1e4;
-function getPathSegments(path) {
-	let segments = pathCache.get(path);
-	if (segments) return segments;
-	segments = path.split(".");
-	if (pathCache.size >= PATH_CACHE_MAX_SIZE) {
-		const firstKey = pathCache.keys().next().value;
-		if (firstKey !== void 0) pathCache.delete(firstKey);
-	}
-	pathCache.set(path, segments);
-	return segments;
-}
-function clearPathCache() {
-	pathCache.clear();
-}
-function get(obj, path) {
-	if (!path || obj === null || obj === void 0) return obj;
-	const keys = getPathSegments(path);
-	let result = obj;
-	for (const key of keys) {
-		if (result === null || result === void 0) return;
-		result = result[key];
-	}
-	return result;
-}
-function set(obj, path, value) {
-	if (!path) return;
-	const keys = getPathSegments(path).slice();
-	const UNSAFE_KEYS = [
-		"__proto__",
-		"constructor",
-		"prototype"
-	];
-	if (keys.some((k) => UNSAFE_KEYS.includes(k))) return;
-	for (const key of keys) if (/^\d+$/.test(key)) {
-		const index = parseInt(key, 10);
-		if (index > MAX_ARRAY_INDEX) {
-			if (typeof console !== "undefined" && console.warn) console.warn(`[vue-hook-form] set(): Array index ${index} exceeds maximum allowed (${MAX_ARRAY_INDEX}). Path "${path}" was not set to prevent memory exhaustion.`);
-			return;
-		}
-	}
-	const lastKey = keys.pop();
-	let current = obj;
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
-		const existing = current[key];
-		if (existing !== void 0 && existing !== null && typeof existing !== "object") try {
-			if (globalThis.process?.env?.NODE_ENV !== "production") console.warn(`[vue-hook-form] set(): Overwriting primitive value at path "${keys.slice(0, i + 1).join(".")}" with an object. Previous value: ${JSON.stringify(existing)}`);
-		} catch {}
-		if (!(key in current) || typeof current[key] !== "object" || current[key] === null) {
-			const nextKey = keys[i + 1];
-			current[key] = nextKey && /^\d+$/.test(nextKey) ? [] : {};
-		}
-		current = current[key];
-	}
-	current[lastKey] = value;
-}
-function unset(obj, path) {
-	if (!path) return;
-	const keys = getPathSegments(path).slice();
-	const lastKey = keys.pop();
-	let current = obj;
-	for (const key of keys) {
-		if (!(key in current)) return;
-		const next = current[key];
-		if (next === null || typeof next !== "object") return;
-		current = next;
-	}
-	delete current[lastKey];
-}
-var idCounter = 0;
-function generateId() {
-	const random = Math.random().toString(36).substring(2, 11);
-	return `field_${Date.now()}_${idCounter++}_${random}`;
-}
-function deepClone(obj, seen) {
-	if (obj === null || obj === void 0) return obj;
-	if (typeof obj !== "object") return obj;
-	if (obj instanceof Date) return new Date(obj.getTime());
-	if (!seen) seen = /* @__PURE__ */ new Map();
-	const existingClone = seen.get(obj);
-	if (existingClone !== void 0) return existingClone;
-	if (Array.isArray(obj)) {
-		const clonedArray = [];
-		seen.set(obj, clonedArray);
-		for (const item of obj) clonedArray.push(deepClone(item, seen));
-		return clonedArray;
-	}
-	const cloned = {};
-	seen.set(obj, cloned);
-	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) cloned[key] = deepClone(obj[key], seen);
-	return cloned;
-}
-var proc = globalThis.process;
-const __DEV__ = proc?.env?.NODE_ENV !== "production";
-var warnedMessages = /* @__PURE__ */ new Set();
-function warnOnce(message, key) {
-	if (!__DEV__) return;
-	const cacheKey = key ?? message;
-	if (warnedMessages.has(cacheKey)) return;
-	warnedMessages.add(cacheKey);
-	console.warn(`[vue-hook-form] ${message}`);
-}
-function warn(message) {
-	if (!__DEV__) return;
-	console.warn(`[vue-hook-form] ${message}`);
-}
-function validatePathSyntax(path) {
-	if (!__DEV__) return null;
-	if (!path || path.trim() === "") return "Path cannot be empty";
-	if (path.startsWith(".") || path.endsWith(".") || path.includes("..")) return `Invalid path "${path}": contains empty segments`;
-	if (path.includes("[")) return `Invalid path "${path}": use dot notation (e.g., "items.0") instead of bracket notation (e.g., "items[0]")`;
-	if (/\s/.test(path)) return `Invalid path "${path}": paths cannot contain whitespace`;
-	return null;
-}
-function traverseSchemaPath(schema, path) {
-	const segments = path.split(".");
-	let currentSchema = schema;
-	for (let i = 0; i < segments.length; i++) {
-		const segment = segments[i];
-		if (!segment) continue;
-		currentSchema = unwrapSchema(currentSchema);
-		if (isZodObject$1(currentSchema)) {
-			const shape = currentSchema.shape;
-			if (segment in shape) {
-				const nextSchema = shape[segment];
-				if (nextSchema) {
-					currentSchema = nextSchema;
-					continue;
-				}
-			}
-			return {
-				error: `Field "${segments.slice(0, i + 1).join(".")}" does not exist in schema`,
-				availableFields: Object.keys(shape),
-				segmentIndex: i
-			};
-		}
-		if (isZodArray$1(currentSchema) && /^\d+$/.test(segment)) {
-			currentSchema = currentSchema.element;
-			continue;
-		}
-		return {
-			error: `Cannot navigate path "${path}" at segment "${segment}"`,
-			segmentIndex: i
-		};
-	}
-	return { schema: currentSchema };
-}
-function validatePathAgainstSchema(schema, path) {
-	if (!__DEV__) return { valid: true };
-	try {
-		const result = traverseSchemaPath(schema, path);
-		if ("error" in result) return {
-			valid: false,
-			reason: result.error,
-			availableFields: result.availableFields
-		};
-		return { valid: true };
-	} catch {
-		return { valid: true };
-	}
-}
-function isArrayFieldInSchema(schema, path) {
-	if (!__DEV__) return null;
-	try {
-		const result = traverseSchemaPath(schema, path);
-		if ("error" in result) return null;
-		return isZodArray$1(unwrapSchema(result.schema));
-	} catch {
-		return null;
-	}
-}
-function warnInvalidPath(fnName, path, reason) {
-	if (!__DEV__) return;
-	let message = `${fnName}("${path}"): ${reason}`;
-	if (reason.includes("bracket notation")) {
-		const fixedPath = path.replace(/\[(\d+)\]/g, ".$1");
-		message += `\n  FIX: Use dot notation for array indices`;
-		message += `\n  EXAMPLE: ${fnName}("${fixedPath}")`;
-	} else if (reason.includes("empty")) {
-		message += `\n  FIX: Provide a non-empty field path`;
-		message += `\n  EXAMPLE: ${fnName}("email") or ${fnName}("user.address.city")`;
-	} else if (reason.includes("whitespace")) {
-		const fixedPath = path.replace(/\s/g, "");
-		message += `\n  FIX: Remove spaces from the field path`;
-		message += `\n  EXAMPLE: ${fnName}("${fixedPath}")`;
-	} else if (reason.includes("empty segments")) {
-		const fixedPath = path.replace(/\.{2,}/g, ".").replace(/^\./, "").replace(/\.$/, "");
-		message += `\n  FIX: Remove extra dots from the path`;
-		message += `\n  EXAMPLE: ${fnName}("${fixedPath}")`;
-	}
-	warnOnce(message, `invalid-path:${fnName}:${path}`);
-}
-function warnPathNotInSchema(fnName, path, availableFields) {
-	if (!__DEV__) return;
-	let message = `${fnName}("${path}"): Path does not exist in your Zod schema.`;
-	message += `\n  FIX: Check that the path matches your schema definition exactly (case-sensitive)`;
-	if (availableFields && availableFields.length > 0) {
-		const pathLower = path.toLowerCase();
-		const suggestions = availableFields.filter((f) => f.toLowerCase().includes(pathLower) || pathLower.includes(f.toLowerCase()));
-		if (suggestions.length > 0) message += `\n  DID YOU MEAN: ${suggestions.slice(0, 3).map((s) => `"${s}"`).join(", ")}`;
-		message += `\n  AVAILABLE: ${availableFields.slice(0, 8).join(", ")}${availableFields.length > 8 ? "..." : ""}`;
-	}
-	warnOnce(message, `path-not-in-schema:${fnName}:${path}`);
-}
-function warnFieldsOnNonArray(path) {
-	if (!__DEV__) return;
-	warnOnce(`fields("${path}"): Expected an array field, but this path does not point to an array in your schema. The fields() method is only for array fields. Use register() for non-array fields.`, `fields-non-array:${path}`);
-}
-function warnArrayOperationRejected(operation, path, reason, details) {
-	if (!__DEV__) return;
-	warn(`${operation}() on "${path}": ${{
-		maxLength: details ? `Would exceed maxLength (current: ${details.current}, max: ${details.limit})` : "Would exceed maxLength rule",
-		minLength: details ? `Would violate minLength (current: ${details.current}, min: ${details.limit})` : "Would violate minLength rule"
-	}[reason]}. Operation was silently ignored.`);
-}
-function warnArrayIndexOutOfBounds(operation, path, index, length) {
-	if (!__DEV__) return;
-	warn(`${operation}() on "${path}": Index ${index} is out of bounds (array length: ${length}). Operation was silently ignored.`);
-}
-function getDefProp$1(schema, prop) {
-	return schema.def[prop];
-}
-function getTypeName(schema) {
-	return getDefProp$1(schema, "typeName");
-}
-function isZodObject$1(schema) {
-	return getTypeName(schema) === "ZodObject";
-}
-function isZodArray$1(schema) {
-	return getTypeName(schema) === "ZodArray";
-}
-function unwrapSchema(schema) {
-	const typeName = getTypeName(schema);
-	const innerType = getDefProp$1(schema, "innerType");
-	const schemaType = getDefProp$1(schema, "schema");
-	if ((typeName === "ZodOptional" || typeName === "ZodNullable" || typeName === "ZodDefault") && innerType) return unwrapSchema(innerType);
-	if (typeName === "ZodEffects" && schemaType) return unwrapSchema(schemaType);
-	return schema;
-}
-function createFormContext(options) {
-	const formData = (0, vue.reactive)({});
-	const defaultValues = (0, vue.reactive)({});
-	const isAsyncDefaults = typeof options.defaultValues === "function";
-	const isLoading = (0, vue.ref)(isAsyncDefaults);
-	if (isAsyncDefaults) {
-		const asyncFn = options.defaultValues;
-		asyncFn().then((values) => {
-			Object.assign(defaultValues, deepClone(values));
-			Object.assign(formData, deepClone(values));
-			isLoading.value = false;
-		}).catch((error) => {
-			console.error("Failed to load async default values:", error);
-			defaultValuesError.value = error;
-			isLoading.value = false;
-			options.onDefaultValuesError?.(error);
-		});
-	} else if (options.defaultValues) {
-		Object.assign(defaultValues, deepClone(options.defaultValues));
-		Object.assign(formData, deepClone(options.defaultValues));
-	}
-	const errors = (0, vue.shallowRef)({});
-	const touchedFields = (0, vue.shallowRef)({});
-	const dirtyFields = (0, vue.shallowRef)({});
-	const isSubmitting = (0, vue.ref)(false);
-	const submitCount = (0, vue.ref)(0);
-	const defaultValuesError = (0, vue.ref)(null);
-	const isSubmitSuccessful = (0, vue.ref)(false);
-	const validatingFields = (0, vue.shallowRef)(/* @__PURE__ */ new Set());
-	const externalErrors = (0, vue.shallowRef)({});
-	const errorDelayTimers = /* @__PURE__ */ new Map();
-	const pendingErrors = /* @__PURE__ */ new Map();
-	const fieldRefs = /* @__PURE__ */ new Map();
-	const fieldOptions = /* @__PURE__ */ new Map();
-	const fieldArrays = /* @__PURE__ */ new Map();
-	const fieldHandlers = /* @__PURE__ */ new Map();
-	const debounceTimers = /* @__PURE__ */ new Map();
-	const validationRequestIds = /* @__PURE__ */ new Map();
-	const resetGeneration = (0, vue.ref)(0);
-	const validationCache = /* @__PURE__ */ new Map();
-	const schemaValidationTimers = /* @__PURE__ */ new Map();
-	const persistentErrorFields = /* @__PURE__ */ new Set();
-	const defaultValueHashes = /* @__PURE__ */ new Map();
-	const isDisabled = (0, vue.ref)(false);
-	const watchStopHandles = [];
-	if (options.disabled !== void 0) {
-		isDisabled.value = (0, vue.toValue)(options.disabled) ?? false;
-		watchStopHandles.push((0, vue.watch)(() => (0, vue.toValue)(options.disabled), (newDisabled) => {
-			isDisabled.value = newDisabled ?? false;
-		}));
-	}
-	if (options.values !== void 0) {
-		const initialValues = (0, vue.toValue)(options.values);
-		if (initialValues && !isAsyncDefaults) {
-			for (const [key, value] of Object.entries(initialValues)) if (value !== void 0) set(formData, key, value);
-		}
-		watchStopHandles.push((0, vue.watch)(() => (0, vue.toValue)(options.values), (newValues) => {
-			if (newValues) {
-				for (const [key, value] of Object.entries(newValues)) if (value !== void 0) {
-					set(formData, key, value);
-					const fieldRef = fieldRefs.get(key);
-					const opts = fieldOptions.get(key);
-					if (fieldRef?.value && !opts?.controlled) {
-						const el = fieldRef.value;
-						if (el.type === "checkbox") el.checked = value;
-						else el.value = value;
-					}
-				}
-			}
-		}, { deep: true }));
-	}
-	if (options.errors !== void 0) {
-		const initialErrors = (0, vue.toValue)(options.errors);
-		if (initialErrors) externalErrors.value = initialErrors;
-		watchStopHandles.push((0, vue.watch)(() => (0, vue.toValue)(options.errors), (newErrors) => {
-			externalErrors.value = newErrors || {};
-		}, { deep: true }));
-	}
-	return {
-		formData,
-		defaultValues,
-		errors,
-		touchedFields,
-		dirtyFields,
-		isSubmitting,
-		isLoading,
-		submitCount,
-		defaultValuesError,
-		isSubmitSuccessful,
-		validatingFields,
-		externalErrors,
-		errorDelayTimers,
-		pendingErrors,
-		fieldRefs,
-		fieldOptions,
-		fieldArrays,
-		fieldHandlers,
-		debounceTimers,
-		validationRequestIds,
-		resetGeneration,
-		isDisabled,
-		validationCache,
-		schemaValidationTimers,
-		persistentErrorFields,
-		defaultValueHashes,
-		options,
-		cleanup: () => {
-			for (const stop of watchStopHandles) stop();
-		}
-	};
-}
-var uniqueIdCounter = 0;
-var circularRefMap = /* @__PURE__ */ new WeakMap();
-function hashValue(value) {
-	if (value === null) return "null";
-	if (value === void 0) return "undefined";
-	const type = typeof value;
-	if (type === "string") return `s:${value}`;
-	if (type === "number") {
-		const num = value;
-		if (Number.isNaN(num)) return "n:NaN";
-		if (num === 0) return "n:0";
-		if (!Number.isFinite(num)) return `n:${num > 0 ? "Infinity" : "-Infinity"}`;
-		return `n:${num}`;
-	}
-	if (type === "boolean") return `b:${value}`;
-	if (type === "object") try {
-		return `o:${JSON.stringify(value)}`;
-	} catch {
-		let id = circularRefMap.get(value);
-		if (!id) {
-			id = String(++uniqueIdCounter);
-			circularRefMap.set(value, id);
-		}
-		return `o:_${id}`;
-	}
-	return `x:_${++uniqueIdCounter}`;
-}
-function getDefType(schema) {
-	return schema._def?.type;
-}
-function getDefProp(schema, prop) {
-	return schema._def?.[prop];
-}
-function isZodObject(schema) {
-	return getDefType(schema) === "object";
-}
-function isZodArray(schema) {
-	return getDefType(schema) === "array";
-}
-function hasChecks(schema) {
-	const checks = getDefProp(schema, "checks");
-	return Array.isArray(checks) && checks.length > 0;
-}
-function unwrapNonEffects(schema) {
-	const type = getDefType(schema);
-	const innerType = getDefProp(schema, "innerType");
-	if ((type === "optional" || type === "nullable" || type === "default") && innerType) return unwrapNonEffects(innerType);
-	return schema;
-}
-var analysisCache = /* @__PURE__ */ new WeakMap();
-function hasRootEffects(schema) {
-	return hasChecks(schema);
-}
-function extractSubSchema(schema, path) {
-	const segments = path.split(".");
-	let currentSchema = schema;
-	let hasEffects = false;
-	for (const segment of segments) {
-		if (!segment) return null;
-		if (hasChecks(currentSchema)) hasEffects = true;
-		const unwrapped = unwrapNonEffects(currentSchema);
-		if (hasChecks(unwrapped)) hasEffects = true;
-		if (isZodObject(unwrapped)) {
-			const shape = getDefProp(unwrapped, "shape");
-			if (!shape || !(segment in shape)) return null;
-			currentSchema = shape[segment];
-		} else if (isZodArray(unwrapped) && /^\d+$/.test(segment)) {
-			const element = getDefProp(unwrapped, "element");
-			if (!element) return null;
-			currentSchema = element;
-		} else return null;
-	}
-	const finalUnwrapped = unwrapNonEffects(currentSchema);
-	const finalChecks = getDefProp(finalUnwrapped, "checks");
-	if (finalChecks) {
-		for (const check of finalChecks) if (check && typeof check === "object" && "type" in check && check.type === "custom") {
-			hasEffects = true;
-			break;
-		}
-	}
-	return {
-		schema: finalUnwrapped,
-		hasEffects
-	};
-}
-function analyzeSchemaPath(schema, path) {
-	let cache = analysisCache.get(schema);
-	if (!cache) {
-		cache = /* @__PURE__ */ new Map();
-		analysisCache.set(schema, cache);
-	}
-	const cached = cache.get(path);
-	if (cached) return cached;
-	if (hasRootEffects(schema)) {
-		const result$1 = {
-			canPartialValidate: false,
-			reason: "root-checks"
-		};
-		cache.set(path, result$1);
-		return result$1;
-	}
-	const extracted = extractSubSchema(schema, path);
-	if (!extracted) {
-		const result$1 = {
-			canPartialValidate: false,
-			reason: "invalid-path"
-		};
-		cache.set(path, result$1);
-		return result$1;
-	}
-	if (extracted.hasEffects) {
-		const result$1 = {
-			canPartialValidate: false,
-			reason: "path-checks"
-		};
-		cache.set(path, result$1);
-		return result$1;
-	}
-	const result = {
-		canPartialValidate: true,
-		subSchema: extracted.schema
-	};
-	cache.set(path, result);
-	return result;
-}
-function markFieldTouched(touchedFields, fieldName) {
-	if (touchedFields.value[fieldName]) return;
-	touchedFields.value = {
-		...touchedFields.value,
-		[fieldName]: true
-	};
-}
-function clearFieldDirty(dirtyFields, fieldName) {
-	if (!(fieldName in dirtyFields.value)) return;
-	const newDirty = { ...dirtyFields.value };
-	delete newDirty[fieldName];
-	dirtyFields.value = newDirty;
-}
-function clearFieldTouched(touchedFields, fieldName) {
-	if (!(fieldName in touchedFields.value)) return;
-	const newTouched = { ...touchedFields.value };
-	delete newTouched[fieldName];
-	touchedFields.value = newTouched;
-}
-function clearFieldErrors(errors, fieldName) {
-	const currentErrors = errors.value;
-	const keys = Object.keys(currentErrors);
-	if (keys.length === 0) return;
-	const prefix = `${fieldName}.`;
-	const keysToDelete = [];
-	for (const key of keys) if (key === fieldName || key.startsWith(prefix)) keysToDelete.push(key);
-	if (keysToDelete.length === 0) return;
-	const newErrors = { ...currentErrors };
-	for (const key of keysToDelete) delete newErrors[key];
-	errors.value = newErrors;
-}
-function updateFieldDirtyState(dirtyFields, defaultValues, defaultValueHashes, fieldName, currentValue) {
-	let defaultHash = defaultValueHashes.get(fieldName);
-	if (defaultHash === void 0) {
-		defaultHash = hashValue(get(defaultValues, fieldName));
-		defaultValueHashes.set(fieldName, defaultHash);
-	}
-	const isDirty = hashValue(currentValue) !== defaultHash;
-	const wasDirty = dirtyFields.value[fieldName] === true;
-	if (isDirty && !wasDirty) dirtyFields.value = {
-		...dirtyFields.value,
-		[fieldName]: true
-	};
-	else if (!isDirty && wasDirty) {
-		const newDirty = { ...dirtyFields.value };
-		delete newDirty[fieldName];
-		dirtyFields.value = newDirty;
-	}
-}
-function setValidating(ctx, fieldPath, isValidating) {
-	const newSet = new Set(ctx.validatingFields.value);
-	if (isValidating) newSet.add(fieldPath);
-	else newSet.delete(fieldPath);
-	ctx.validatingFields.value = newSet;
-}
-function groupErrorsByPath(issues) {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const issue of issues) {
-		const path = issue.path.join(".");
-		const existing = grouped.get(path) || [];
-		existing.push({
-			type: issue.code,
-			message: issue.message
-		});
-		grouped.set(path, existing);
-	}
-	return grouped;
-}
-function createFieldError(errors, criteriaMode = "firstError") {
-	const firstError = errors[0];
-	if (!firstError) return "";
-	if (criteriaMode === "firstError") return firstError.message;
-	if (errors.length === 1) return firstError.message;
-	const types = {};
-	for (const err of errors) {
-		const existing = types[err.type];
-		if (existing) types[err.type] = Array.isArray(existing) ? [...existing, err.message] : [existing, err.message];
-		else types[err.type] = err.message;
-	}
-	return {
-		type: firstError.type,
-		message: firstError.message,
-		types
-	};
-}
-function createValidation(ctx) {
-	function applyNativeValidation(fieldPath, errorMessage) {
-		if (!ctx.options.shouldUseNativeValidation) return;
-		const el = ctx.fieldRefs.get(fieldPath)?.value;
-		if (el && "setCustomValidity" in el) el.setCustomValidity(errorMessage || "");
-	}
-	function clearAllNativeValidation() {
-		if (!ctx.options.shouldUseNativeValidation) return;
-		for (const [path] of ctx.fieldRefs) applyNativeValidation(path, null);
-	}
-	function scheduleErrorsBatch(errors) {
-		if ((ctx.options.delayError || 0) <= 0) {
-			const newErrors = { ...ctx.errors.value };
-			for (const [fieldPath, error] of errors) {
-				set(newErrors, fieldPath, error);
-				applyNativeValidation(fieldPath, typeof error === "string" ? error : error.message);
-			}
-			ctx.errors.value = newErrors;
-			return;
-		}
-		for (const [fieldPath, error] of errors) scheduleError(fieldPath, error);
-	}
-	function scheduleError(fieldPath, error) {
-		const delayMs = ctx.options.delayError || 0;
-		const errorMessage = typeof error === "string" ? error : error.message;
-		if (delayMs <= 0) {
-			const newErrors = { ...ctx.errors.value };
-			set(newErrors, fieldPath, error);
-			ctx.errors.value = newErrors;
-			applyNativeValidation(fieldPath, errorMessage);
-			return;
-		}
-		const existingTimer = ctx.errorDelayTimers.get(fieldPath);
-		if (existingTimer) clearTimeout(existingTimer);
-		ctx.pendingErrors.set(fieldPath, error);
-		const timer = setTimeout(() => {
-			ctx.errorDelayTimers.delete(fieldPath);
-			const pendingError = ctx.pendingErrors.get(fieldPath);
-			if (pendingError !== void 0) {
-				ctx.pendingErrors.delete(fieldPath);
-				const newErrors = { ...ctx.errors.value };
-				set(newErrors, fieldPath, pendingError);
-				ctx.errors.value = newErrors;
-				applyNativeValidation(fieldPath, errorMessage);
-			}
-		}, delayMs);
-		ctx.errorDelayTimers.set(fieldPath, timer);
-	}
-	function cancelError(fieldPath) {
-		const timer = ctx.errorDelayTimers.get(fieldPath);
-		if (timer) {
-			clearTimeout(timer);
-			ctx.errorDelayTimers.delete(fieldPath);
-		}
-		ctx.pendingErrors.delete(fieldPath);
-		applyNativeValidation(fieldPath, null);
-		if (ctx.persistentErrorFields.has(fieldPath)) return;
-		clearFieldErrors(ctx.errors, fieldPath);
-	}
-	function clearAllPendingErrors() {
-		for (const timer of ctx.errorDelayTimers.values()) clearTimeout(timer);
-		ctx.errorDelayTimers.clear();
-		ctx.pendingErrors.clear();
-	}
-	async function validateFieldPartial(fieldPath, subSchema, valueHash, cacheKey, criteriaMode, generationAtStart) {
-		const fieldValue = get(ctx.formData, fieldPath);
-		setValidating(ctx, fieldPath, true);
-		try {
-			const result = await subSchema.safeParseAsync(fieldValue);
-			if (ctx.resetGeneration.value !== generationAtStart) return true;
-			if (result.success) {
-				cancelError(fieldPath);
-				if (valueHash) ctx.validationCache.set(cacheKey, {
-					hash: valueHash,
-					isValid: true
-				});
-				return true;
-			}
-			const fieldSegments = fieldPath.split(".");
-			const fieldErrors = result.error.issues.map((issue) => {
-				const issuePath = issue.path.map(String);
-				const alreadyPrefixed = issuePath.length >= fieldSegments.length && fieldSegments.every((seg, i) => issuePath[i] === seg);
-				return {
-					...issue,
-					path: alreadyPrefixed ? issuePath : fieldSegments.concat(issuePath)
-				};
-			});
-			cancelError(fieldPath);
-			const grouped = groupErrorsByPath(fieldErrors);
-			const errorBatch = [];
-			for (const [path, errors] of grouped) errorBatch.push([path, createFieldError(errors, criteriaMode)]);
-			scheduleErrorsBatch(errorBatch);
-			if (valueHash) ctx.validationCache.set(cacheKey, {
-				hash: valueHash,
-				isValid: false
-			});
-			return false;
-		} finally {
-			setValidating(ctx, fieldPath, false);
-		}
-	}
-	async function validateFieldFull(fieldPath, valueHash, cacheKey, criteriaMode, generationAtStart) {
-		setValidating(ctx, fieldPath, true);
-		try {
-			const result = await ctx.options.schema.safeParseAsync(ctx.formData);
-			if (ctx.resetGeneration.value !== generationAtStart) return true;
-			if (result.success) {
-				cancelError(fieldPath);
-				if (valueHash) ctx.validationCache.set(cacheKey, {
-					hash: valueHash,
-					isValid: true
-				});
-				return true;
-			}
-			const fieldErrors = result.error.issues.filter((issue) => {
-				const path = issue.path.join(".");
-				return path === fieldPath || path.startsWith(`${fieldPath}.`);
-			});
-			if (fieldErrors.length === 0) {
-				cancelError(fieldPath);
-				if (valueHash) ctx.validationCache.set(cacheKey, {
-					hash: valueHash,
-					isValid: true
-				});
-				return true;
-			}
-			cancelError(fieldPath);
-			const grouped = groupErrorsByPath(fieldErrors);
-			const errorBatch = [];
-			for (const [path, errors] of grouped) errorBatch.push([path, createFieldError(errors, criteriaMode)]);
-			scheduleErrorsBatch(errorBatch);
-			if (valueHash) ctx.validationCache.set(cacheKey, {
-				hash: valueHash,
-				isValid: false
-			});
-			return false;
-		} finally {
-			setValidating(ctx, fieldPath, false);
-		}
-	}
-	async function validate(fieldPath) {
-		const generationAtStart = ctx.resetGeneration.value;
-		const criteriaMode = ctx.options.criteriaMode || "firstError";
-		let valueHash;
-		if (fieldPath) {
-			valueHash = hashValue(get(ctx.formData, fieldPath));
-			const analysis = analyzeSchemaPath(ctx.options.schema, fieldPath);
-			const usePartial = analysis.canPartialValidate && analysis.subSchema;
-			const cacheKey = `${fieldPath}:${usePartial ? "partial" : "full"}`;
-			const cached = ctx.validationCache.get(cacheKey);
-			if (cached && cached.hash === valueHash && cached.isValid) {
-				cancelError(fieldPath);
-				return true;
-			}
-			if (usePartial) return validateFieldPartial(fieldPath, analysis.subSchema, valueHash, cacheKey, criteriaMode, generationAtStart);
-			return validateFieldFull(fieldPath, valueHash, cacheKey, criteriaMode, generationAtStart);
-		}
-		const validatingKey = "_form";
-		setValidating(ctx, validatingKey, true);
-		try {
-			const result = await ctx.options.schema.safeParseAsync(ctx.formData);
-			if (ctx.resetGeneration.value !== generationAtStart) return true;
-			if (result.success) {
-				clearAllPendingErrors();
-				ctx.errors.value = {};
-				clearAllNativeValidation();
-				ctx.validationCache.clear();
-				return true;
-			}
-			clearAllPendingErrors();
-			ctx.errors.value = {};
-			const grouped = groupErrorsByPath(result.error.issues);
-			const errorBatch = [];
-			for (const [path, errors] of grouped) errorBatch.push([path, createFieldError(errors, criteriaMode)]);
-			scheduleErrorsBatch(errorBatch);
-			ctx.validationCache.clear();
-			return false;
-		} finally {
-			setValidating(ctx, validatingKey, false);
-		}
-	}
-	return {
-		validate,
-		clearAllPendingErrors
-	};
-}
-var VALID_MODES = [
-	"onSubmit",
-	"onBlur",
-	"onChange",
-	"onTouched"
-];
-function validateMode(mode, paramName) {
-	if (__DEV__ && !VALID_MODES.includes(mode)) warnOnce(`Invalid ${paramName}: "${mode}". Expected one of: ${VALID_MODES.join(", ")}`, `invalid-mode-${mode}`);
-}
-function shouldValidateOnChange(mode, isTouched, reValidateMode, hasSubmitted) {
-	if (__DEV__) {
-		validateMode(mode, "validation mode");
-		if (reValidateMode) validateMode(reValidateMode, "reValidateMode");
-	}
-	if (mode === "onChange") return true;
-	if (mode === "onTouched" && isTouched) return true;
-	if (hasSubmitted === true && reValidateMode === "onChange") return true;
-	return false;
-}
-function shouldValidateOnBlur(mode, hasSubmitted, reValidateMode) {
-	if (__DEV__) {
-		validateMode(mode, "validation mode");
-		if (reValidateMode) validateMode(reValidateMode, "reValidateMode");
-	}
-	return mode === "onBlur" || mode === "onTouched" || hasSubmitted && (reValidateMode === "onBlur" || reValidateMode === "onTouched");
-}
-var validationRequestCounter = 0;
-function createFieldRegistration(ctx, validate) {
-	function register(name, registerOptions) {
-		if (__DEV__) {
-			const syntaxError = validatePathSyntax(name);
-			if (syntaxError) warnInvalidPath("register", name, syntaxError);
-			const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
-			if (!schemaResult.valid) warnPathNotInSchema("register", name, schemaResult.availableFields);
-		}
-		let fieldRef = ctx.fieldRefs.get(name);
-		if (!fieldRef) {
-			fieldRef = (0, vue.ref)(null);
-			ctx.fieldRefs.set(name, fieldRef);
-			if (get(ctx.formData, name) === void 0) {
-				const defaultValue = get(ctx.defaultValues, name);
-				if (defaultValue !== void 0) set(ctx.formData, name, defaultValue);
-			}
-		}
-		if (registerOptions) ctx.fieldOptions.set(name, registerOptions);
-		let handlers = ctx.fieldHandlers.get(name);
-		if (!handlers) {
-			const runCustomValidation = async (fieldName, value, requestId, resetGenAtStart) => {
-				const fieldOpts = ctx.fieldOptions.get(fieldName);
-				if (!fieldOpts?.validate || fieldOpts.disabled) return;
-				const error = await fieldOpts.validate(value);
-				if (requestId !== ctx.validationRequestIds.get(fieldName)) return;
-				if (ctx.resetGeneration.value !== resetGenAtStart) return;
-				if (error) ctx.errors.value = {
-					...ctx.errors.value,
-					[fieldName]: error
-				};
-				else {
-					const newErrors = { ...ctx.errors.value };
-					delete newErrors[fieldName];
-					ctx.errors.value = newErrors;
-				}
-			};
-			const onInput = async (e) => {
-				const target = e.target;
-				let value;
-				if (target.type === "checkbox") value = target.checked;
-				else if (target.type === "number" || target.type === "range") value = target.valueAsNumber;
-				else value = target.value;
-				set(ctx.formData, name, value);
-				updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, value);
-				const fieldOpts = ctx.fieldOptions.get(name);
-				if (shouldValidateOnChange(ctx.options.mode ?? "onSubmit", ctx.touchedFields.value[name] === true, ctx.options.reValidateMode, ctx.submitCount.value > 0)) {
-					const validationDebounceMs = ctx.options.validationDebounce || 0;
-					if (validationDebounceMs > 0) {
-						const existingTimer = ctx.schemaValidationTimers.get(name);
-						if (existingTimer) clearTimeout(existingTimer);
-						const timer = setTimeout(async () => {
-							ctx.schemaValidationTimers.delete(name);
-							await validate(name);
-							if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
-								const uniqueDeps = [...new Set(fieldOpts.deps)];
-								await Promise.all(uniqueDeps.map((depField) => validate(depField)));
-							}
-						}, validationDebounceMs);
-						ctx.schemaValidationTimers.set(name, timer);
-					} else {
-						await validate(name);
-						if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
-							const uniqueDeps = [...new Set(fieldOpts.deps)];
-							await Promise.all(uniqueDeps.map((depField) => validate(depField)));
-						}
-					}
-				}
-				if (fieldOpts?.validate && !fieldOpts.disabled) {
-					const requestId = ++validationRequestCounter;
-					ctx.validationRequestIds.set(name, requestId);
-					const resetGenAtStart = ctx.resetGeneration.value;
-					const debounceMs = fieldOpts.validateDebounce || 0;
-					if (debounceMs > 0) {
-						const existingTimer = ctx.debounceTimers.get(name);
-						if (existingTimer) clearTimeout(existingTimer);
-						const timer = setTimeout(async () => {
-							ctx.debounceTimers.delete(name);
-							await runCustomValidation(name, value, requestId, resetGenAtStart);
-							if (ctx.validationRequestIds.get(name) === requestId) ctx.validationRequestIds.delete(name);
-						}, debounceMs);
-						ctx.debounceTimers.set(name, timer);
-					} else {
-						await runCustomValidation(name, value, requestId, resetGenAtStart);
-						if (ctx.validationRequestIds.get(name) === requestId) ctx.validationRequestIds.delete(name);
-					}
-				}
-			};
-			const onBlur = async (_e) => {
-				markFieldTouched(ctx.touchedFields, name);
-				if (shouldValidateOnBlur(ctx.options.mode ?? "onSubmit", ctx.submitCount.value > 0, ctx.options.reValidateMode)) {
-					await validate(name);
-					const fieldOpts = ctx.fieldOptions.get(name);
-					if (fieldOpts?.deps && fieldOpts.deps.length > 0) {
-						const uniqueDeps = [...new Set(fieldOpts.deps)];
-						await Promise.all(uniqueDeps.map((depField) => validate(depField)));
-					}
-				}
-			};
-			const refCallback = (el) => {
-				const currentFieldRef = ctx.fieldRefs.get(name);
-				if (!currentFieldRef) return;
-				const previousEl = currentFieldRef.value;
-				if (previousEl === el) return;
-				if (previousEl && el) return;
-				currentFieldRef.value = el;
-				const opts = ctx.fieldOptions.get(name);
-				if (el && !opts?.controlled && el instanceof HTMLInputElement) {
-					const value = get(ctx.formData, name);
-					if (value !== void 0) if (el.type === "checkbox") el.checked = value;
-					else el.value = value;
-				}
-				if (previousEl && !el) {
-					const timer = ctx.debounceTimers.get(name);
-					if (timer) {
-						clearTimeout(timer);
-						ctx.debounceTimers.delete(name);
-					}
-					const schemaTimer = ctx.schemaValidationTimers.get(name);
-					if (schemaTimer) {
-						clearTimeout(schemaTimer);
-						ctx.schemaValidationTimers.delete(name);
-					}
-					const errorTimer = ctx.errorDelayTimers.get(name);
-					if (errorTimer) {
-						clearTimeout(errorTimer);
-						ctx.errorDelayTimers.delete(name);
-					}
-					ctx.pendingErrors.delete(name);
-					ctx.validationRequestIds.delete(name);
-					ctx.fieldRefs.delete(name);
-					ctx.fieldOptions.delete(name);
-					ctx.fieldHandlers.delete(name);
-					if (opts?.shouldUnregister ?? ctx.options.shouldUnregister ?? false) {
-						unset(ctx.formData, name);
-						clearFieldErrors(ctx.errors, name);
-						clearFieldTouched(ctx.touchedFields, name);
-						clearFieldDirty(ctx.dirtyFields, name);
-					}
-				}
-			};
-			handlers = {
-				onInput,
-				onBlur,
-				refCallback
-			};
-			ctx.fieldHandlers.set(name, handlers);
-		}
-		return {
-			name,
-			ref: handlers.refCallback,
-			onInput: handlers.onInput,
-			onBlur: handlers.onBlur,
-			...ctx.isDisabled.value && { disabled: true },
-			...registerOptions?.controlled && { value: (0, vue.computed)({
-				get: () => get(ctx.formData, name),
-				set: (val) => {
-					set(ctx.formData, name, val);
-					updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, val);
-				}
-			}) }
-		};
-	}
-	function unregister(name, options) {
-		const opts = options || {};
-		if (!opts.keepValue) unset(ctx.formData, name);
-		if (!opts.keepError) clearFieldErrors(ctx.errors, name);
-		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, name);
-		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, name);
-		ctx.fieldRefs.delete(name);
-		ctx.fieldOptions.delete(name);
-		ctx.fieldHandlers.delete(name);
-		const timer = ctx.debounceTimers.get(name);
-		if (timer) {
-			clearTimeout(timer);
-			ctx.debounceTimers.delete(name);
-		}
-		const schemaTimer = ctx.schemaValidationTimers.get(name);
-		if (schemaTimer) {
-			clearTimeout(schemaTimer);
-			ctx.schemaValidationTimers.delete(name);
-		}
-		ctx.validationRequestIds.delete(name);
-		ctx.validationCache.delete(`${name}:partial`);
-		ctx.validationCache.delete(`${name}:full`);
-	}
-	return {
-		register,
-		unregister
-	};
-}
-function createFieldArrayManager(ctx, validate, setFocus) {
-	function fields(name, options) {
-		if (__DEV__) {
-			const syntaxError = validatePathSyntax(name);
-			if (syntaxError) warnInvalidPath("fields", name, syntaxError);
-			const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
-			if (!schemaResult.valid) warnPathNotInSchema("fields", name, schemaResult.availableFields);
-			if (isArrayFieldInSchema(ctx.options.schema, name) === false) warnFieldsOnNonArray(name);
-		}
-		let fieldArray = ctx.fieldArrays.get(name);
-		if (!fieldArray) {
-			const existingValues = get(ctx.formData, name) || [];
-			fieldArray = {
-				items: (0, vue.ref)([]),
-				values: existingValues,
-				indexCache: /* @__PURE__ */ new Map(),
-				rules: options?.rules
-			};
-			ctx.fieldArrays.set(name, fieldArray);
-			if (!get(ctx.formData, name)) set(ctx.formData, name, []);
-		} else if (options?.rules) fieldArray.rules = options.rules;
-		const fa = fieldArray;
-		const indexCache = fa.indexCache;
-		const rebuildIndexCache = () => {
-			indexCache.clear();
-			fa.items.value.forEach((item, idx) => {
-				indexCache.set(item.key, idx);
-			});
-		};
-		const appendToCache = (startIndex) => {
-			const items = fa.items.value;
-			for (let i = startIndex; i < items.length; i++) {
-				const item = items[i];
-				if (item) indexCache.set(item.key, i);
-			}
-		};
-		const updateCacheAfterInsert = (insertIndex, _insertCount) => {
-			const items = fa.items.value;
-			for (let i = insertIndex; i < items.length; i++) {
-				const item = items[i];
-				if (item) indexCache.set(item.key, i);
-			}
-		};
-		const swapInCache = (indexA, indexB) => {
-			const items = fa.items.value;
-			const itemA = items[indexA];
-			const itemB = items[indexB];
-			if (itemA) indexCache.set(itemA.key, indexA);
-			if (itemB) indexCache.set(itemB.key, indexB);
-		};
-		const updateCacheAfterRemove = (removedKey, startIndex) => {
-			indexCache.delete(removedKey);
-			const items = fa.items.value;
-			for (let i = startIndex; i < items.length; i++) {
-				const item = items[i];
-				if (item) indexCache.set(item.key, i);
-			}
-		};
-		const createItem = (key) => ({
-			key,
-			get index() {
-				return indexCache.get(key) ?? -1;
-			},
-			remove() {
-				const currentIndex = indexCache.get(key) ?? -1;
-				if (currentIndex !== -1) removeAt(currentIndex);
-			}
-		});
-		if (fa.items.value.length === 0 && fa.values.length > 0) {
-			fa.items.value = fa.values.map(() => createItem(generateId()));
-			rebuildIndexCache();
-		}
-		const handleFocus = async (baseIndex, addedCount, focusOptions) => {
-			if (!focusOptions?.shouldFocus) return;
-			await (0, vue.nextTick)();
-			const focusItemOffset = focusOptions?.focusIndex ?? 0;
-			let fieldPath = `${name}.${baseIndex + Math.min(focusItemOffset, addedCount - 1)}`;
-			if (focusOptions?.focusName) fieldPath = `${fieldPath}.${focusOptions.focusName}`;
-			setFocus(fieldPath);
-		};
-		const normalizeToArray = (value) => {
-			return Array.isArray(value) ? value : [value];
-		};
-		const clearValidationCache = () => {
-			for (const key of ctx.validationCache.keys()) {
-				const colonIndex = key.lastIndexOf(":");
-				const fieldPath = colonIndex > 0 ? key.slice(0, colonIndex) : key;
-				if (fieldPath === name || fieldPath.startsWith(`${name}.`)) ctx.validationCache.delete(key);
-			}
-		};
-		const validateIfNeeded = () => {
-			const isTouched = ctx.touchedFields.value[name] === true;
-			const hasSubmitted = ctx.submitCount.value > 0;
-			if (shouldValidateOnChange(ctx.options.mode ?? "onSubmit", isTouched, ctx.options.reValidateMode, hasSubmitted)) validate(name);
-		};
-		const ensureSync = () => {
-			const currentValues = get(ctx.formData, name) || [];
-			if (fa.items.value.length !== currentValues.length) {
-				if (__DEV__) console.warn(`[vue-hook-form] Field array out of sync with formData. Rebuilding items array (items: ${fa.items.value.length}, formData: ${currentValues.length})`);
-				fa.items.value = currentValues.map(() => createItem(generateId()));
-				rebuildIndexCache();
-			}
-			return currentValues;
-		};
-		const append = (value, focusOptions) => {
-			clearValidationCache();
-			const values = normalizeToArray(value);
-			if (values.length === 0) return true;
-			const currentValues = ensureSync();
-			const insertIndex = currentValues.length;
-			const rules = fa.rules;
-			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
-				if (__DEV__) warnArrayOperationRejected("append", name, "maxLength", {
-					current: currentValues.length,
-					limit: rules.maxLength.value
-				});
-				return false;
-			}
-			const newValues = [...currentValues, ...values];
-			set(ctx.formData, name, newValues);
-			const newItems = values.map(() => createItem(generateId()));
-			fa.items.value = [...fa.items.value, ...newItems];
-			appendToCache(insertIndex);
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			handleFocus(insertIndex, values.length, focusOptions);
-			return true;
-		};
-		const prepend = (value, focusOptions) => {
-			clearValidationCache();
-			const values = normalizeToArray(value);
-			if (values.length === 0) return true;
-			const currentValues = ensureSync();
-			const rules = fa.rules;
-			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
-				if (__DEV__) warnArrayOperationRejected("prepend", name, "maxLength", {
-					current: currentValues.length,
-					limit: rules.maxLength.value
-				});
-				return false;
-			}
-			const newValues = [...values, ...currentValues];
-			set(ctx.formData, name, newValues);
-			const newItems = values.map(() => createItem(generateId()));
-			fa.items.value = [...newItems, ...fa.items.value];
-			updateCacheAfterInsert(0, values.length);
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			handleFocus(0, values.length, focusOptions);
-			return true;
-		};
-		const update = (index, value) => {
-			clearValidationCache();
-			const currentValues = ensureSync();
-			if (index < 0 || index >= currentValues.length) {
-				if (__DEV__) warnArrayIndexOutOfBounds("update", name, index, currentValues.length);
-				return false;
-			}
-			const newValues = [...currentValues];
-			newValues[index] = value;
-			set(ctx.formData, name, newValues);
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			return true;
-		};
-		const removeAt = (index) => {
-			clearValidationCache();
-			const currentValues = ensureSync();
-			if (index < 0 || index >= currentValues.length) {
-				if (__DEV__) warnArrayIndexOutOfBounds("remove", name, index, currentValues.length);
-				return false;
-			}
-			const rules = fa.rules;
-			if (rules?.minLength && currentValues.length - 1 < rules.minLength.value) {
-				if (__DEV__) warnArrayOperationRejected("remove", name, "minLength", {
-					current: currentValues.length,
-					limit: rules.minLength.value
-				});
-				return false;
-			}
-			const newValues = currentValues.filter((_, i) => i !== index);
-			set(ctx.formData, name, newValues);
-			const keyToRemove = fa.items.value[index]?.key;
-			fa.items.value = fa.items.value.filter((item) => item.key !== keyToRemove);
-			if (keyToRemove) updateCacheAfterRemove(keyToRemove, index);
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			return true;
-		};
-		const insert = (index, value, focusOptions) => {
-			clearValidationCache();
-			const values = normalizeToArray(value);
-			if (values.length === 0) return true;
-			const currentValues = ensureSync();
-			const rules = fa.rules;
-			if (rules?.maxLength && currentValues.length + values.length > rules.maxLength.value) {
-				if (__DEV__) warnArrayOperationRejected("insert", name, "maxLength", {
-					current: currentValues.length,
-					limit: rules.maxLength.value
-				});
-				return false;
-			}
-			if (index < 0 || index > currentValues.length) {
-				if (__DEV__) warnArrayIndexOutOfBounds("insert", name, index, currentValues.length);
-				return false;
-			}
-			const newValues = [
-				...currentValues.slice(0, index),
-				...values,
-				...currentValues.slice(index)
-			];
-			set(ctx.formData, name, newValues);
-			const newItems = values.map(() => createItem(generateId()));
-			fa.items.value = [
-				...fa.items.value.slice(0, index),
-				...newItems,
-				...fa.items.value.slice(index)
-			];
-			updateCacheAfterInsert(index, values.length);
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			handleFocus(index, values.length, focusOptions);
-			return true;
-		};
-		const swap = (indexA, indexB) => {
-			clearValidationCache();
-			const currentValues = ensureSync();
-			if (indexA < 0 || indexB < 0 || indexA >= currentValues.length || indexB >= currentValues.length) {
-				if (__DEV__) warnArrayIndexOutOfBounds("swap", name, indexA < 0 || indexA >= currentValues.length ? indexA : indexB, currentValues.length);
-				return false;
-			}
-			const newValues = [...currentValues];
-			[newValues[indexA], newValues[indexB]] = [newValues[indexB], newValues[indexA]];
-			set(ctx.formData, name, newValues);
-			const newItems = [...fa.items.value];
-			const itemA = newItems[indexA];
-			const itemB = newItems[indexB];
-			if (itemA && itemB) {
-				newItems[indexA] = itemB;
-				newItems[indexB] = itemA;
-				fa.items.value = newItems;
-				swapInCache(indexA, indexB);
-			}
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			return true;
-		};
-		const move = (from, to) => {
-			clearValidationCache();
-			const currentValues = ensureSync();
-			if (from < 0 || from >= currentValues.length || to < 0 || to >= currentValues.length) {
-				if (__DEV__) warnArrayIndexOutOfBounds("move", name, from < 0 || from >= currentValues.length ? from : to, currentValues.length);
-				return false;
-			}
-			const newValues = [...currentValues];
-			const [removed] = newValues.splice(from, 1);
-			if (removed !== void 0) {
-				newValues.splice(to, 0, removed);
-				set(ctx.formData, name, newValues);
-			}
-			const newItems = [...fa.items.value];
-			const [removedItem] = newItems.splice(from, 1);
-			if (removedItem) {
-				newItems.splice(to, 0, removedItem);
-				fa.items.value = newItems;
-				const minIdx = Math.min(from, to);
-				const maxIdx = Math.max(from, to);
-				const items = fa.items.value;
-				for (let i = minIdx; i <= maxIdx; i++) {
-					const item = items[i];
-					if (item) indexCache.set(item.key, i);
-				}
-			}
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			return true;
-		};
-		const replace = (newValues) => {
-			clearValidationCache();
-			if (!Array.isArray(newValues)) return false;
-			set(ctx.formData, name, newValues);
-			fa.items.value = newValues.map(() => createItem(generateId()));
-			rebuildIndexCache();
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			return true;
-		};
-		const removeAll = () => {
-			clearValidationCache();
-			const rules = fa.rules;
-			if (rules?.minLength && rules.minLength.value > 0) {
-				if (__DEV__) warnArrayOperationRejected("removeAll", name, "minLength", {
-					current: fa.items.value.length,
-					limit: rules.minLength.value
-				});
-				return false;
-			}
-			set(ctx.formData, name, []);
-			fa.items.value = [];
-			indexCache.clear();
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			return true;
-		};
-		const removeMany = (indices) => {
-			clearValidationCache();
-			const currentValues = ensureSync();
-			const validIndices = indices.filter((i) => i >= 0 && i < currentValues.length);
-			if (validIndices.length === 0) return true;
-			const rules = fa.rules;
-			const remainingCount = currentValues.length - validIndices.length;
-			if (rules?.minLength && remainingCount < rules.minLength.value) {
-				if (__DEV__) warnArrayOperationRejected("removeMany", name, "minLength", {
-					current: currentValues.length,
-					limit: rules.minLength.value
-				});
-				return false;
-			}
-			const sortedIndices = [...new Set(validIndices)].sort((a, b) => b - a);
-			const indicesToRemove = new Set(sortedIndices);
-			const keysToRemove = fa.items.value.filter((_, i) => indicesToRemove.has(i)).map((item) => item.key);
-			const newValues = currentValues.filter((_, i) => !indicesToRemove.has(i));
-			set(ctx.formData, name, newValues);
-			fa.items.value = fa.items.value.filter((_, i) => !indicesToRemove.has(i));
-			for (const key of keysToRemove) indexCache.delete(key);
-			fa.items.value.forEach((item, idx) => {
-				indexCache.set(item.key, idx);
-			});
-			updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, get(ctx.formData, name));
-			validateIfNeeded();
-			return true;
-		};
-		return {
-			value: fa.items.value,
-			append,
-			prepend,
-			remove: removeAt,
-			removeAll,
-			removeMany,
-			insert,
-			swap,
-			move,
-			update,
-			replace
-		};
-	}
-	return { fields };
-}
-function syncUncontrolledInputs(fieldRefs, fieldOptions, formData) {
-	for (const [name, fieldRef] of Array.from(fieldRefs.entries())) {
-		const el = fieldRef.value;
-		if (el) {
-			if (!fieldOptions.get(name)?.controlled) {
-				let value;
-				if (el.type === "checkbox") value = el.checked;
-				else if (el.type === "number" || el.type === "range") value = el.valueAsNumber;
-				else value = el.value;
-				set(formData, name, value);
-			}
-		}
-	}
-}
-function updateDomElement(el, value) {
-	if (el.type === "checkbox") el.checked = value;
-	else el.value = value;
-}
-function useForm(options) {
-	const ctx = createFormContext(options);
-	let isSubmissionLocked = false;
-	(0, vue.onUnmounted)(() => {
-		ctx.cleanup();
-	});
-	const { validate, clearAllPendingErrors } = createValidation(ctx);
-	const { register, unregister } = createFieldRegistration(ctx, validate);
-	function setFocus(name, focusOptions) {
-		if (__DEV__) {
-			const syntaxError = validatePathSyntax(name);
-			if (syntaxError) warnInvalidPath("setFocus", name, syntaxError);
-			else {
-				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
-				if (!schemaResult.valid) warnPathNotInSchema("setFocus", name, schemaResult.availableFields);
-			}
-		}
-		const fieldRef = ctx.fieldRefs.get(name);
-		if (!fieldRef?.value) return;
-		const el = fieldRef.value;
-		if (typeof el.focus === "function") {
-			el.focus();
-			if (focusOptions?.shouldSelect && el instanceof HTMLInputElement && typeof el.select === "function") el.select();
-		}
-	}
-	const setFocusWrapper = (name) => setFocus(name);
-	const { fields } = createFieldArrayManager(ctx, validate, setFocusWrapper);
-	let lastSyncTime = 0;
-	const SYNC_DEBOUNCE_MS = 16;
-	function syncWithDebounce() {
-		const now = typeof performance !== "undefined" ? performance.now() : Date.now();
-		if (now - lastSyncTime < SYNC_DEBOUNCE_MS) return;
-		syncUncontrolledInputs(ctx.fieldRefs, ctx.fieldOptions, ctx.formData);
-		lastSyncTime = now;
-	}
-	let lastErrors = ctx.errors.value;
-	let lastExternalErrors = ctx.externalErrors.value;
-	let cachedMergedErrors = null;
-	function getMergedErrors() {
-		if (cachedMergedErrors !== null && lastErrors === ctx.errors.value && lastExternalErrors === ctx.externalErrors.value) return cachedMergedErrors;
-		lastErrors = ctx.errors.value;
-		lastExternalErrors = ctx.externalErrors.value;
-		cachedMergedErrors = {
-			...ctx.errors.value,
-			...ctx.externalErrors.value
-		};
-		return cachedMergedErrors;
-	}
-	const isDirtyComputed = (0, vue.computed)(() => Object.keys(ctx.dirtyFields.value).length > 0);
-	const errorsComputed = (0, vue.computed)(() => getMergedErrors());
-	const isValidComputed = (0, vue.computed)(() => {
-		if (!(ctx.submitCount.value > 0 || Object.keys(ctx.touchedFields.value).length > 0)) return false;
-		return Object.keys(errorsComputed.value).length === 0;
-	});
-	const isReadyComputed = (0, vue.computed)(() => !ctx.isLoading.value);
-	const isValidatingComputed = (0, vue.computed)(() => ctx.validatingFields.value.size > 0);
-	const isSubmittedComputed = (0, vue.computed)(() => ctx.submitCount.value > 0);
-	const formStateInternal = (0, vue.reactive)({
-		get errors() {
-			return errorsComputed.value;
-		},
-		get isDirty() {
-			return isDirtyComputed.value;
-		},
-		get dirtyFields() {
-			return ctx.dirtyFields.value;
-		},
-		get isValid() {
-			return isValidComputed.value;
-		},
-		get isSubmitting() {
-			return ctx.isSubmitting.value;
-		},
-		get isLoading() {
-			return ctx.isLoading.value;
-		},
-		get isReady() {
-			return isReadyComputed.value;
-		},
-		get isValidating() {
-			return isValidatingComputed.value;
-		},
-		get validatingFields() {
-			return ctx.validatingFields.value;
-		},
-		get touchedFields() {
-			return ctx.touchedFields.value;
-		},
-		get submitCount() {
-			return ctx.submitCount.value;
-		},
-		get defaultValuesError() {
-			return ctx.defaultValuesError.value;
-		},
-		get isSubmitted() {
-			return isSubmittedComputed.value;
-		},
-		get isSubmitSuccessful() {
-			return ctx.isSubmitSuccessful.value;
-		},
-		get disabled() {
-			return ctx.isDisabled.value;
-		}
-	});
-	const formState = (0, vue.computed)(() => formStateInternal);
-	function handleSubmit(onValid, onInvalid) {
-		return async (e) => {
-			e.preventDefault();
-			if (ctx.isDisabled.value) return;
-			if (isSubmissionLocked) return;
-			isSubmissionLocked = true;
-			ctx.isSubmitting.value = true;
-			ctx.submitCount.value++;
-			ctx.isSubmitSuccessful.value = false;
-			try {
-				syncWithDebounce();
-				if (await validate()) {
-					await onValid(ctx.formData);
-					ctx.isSubmitSuccessful.value = true;
-				} else {
-					onInvalid?.(formState.value.errors);
-					if (options.shouldFocusError !== false) {
-						const firstErrorField = Object.keys(formState.value.errors)[0];
-						if (firstErrorField) setFocus(firstErrorField);
-					}
-				}
-			} finally {
-				ctx.isSubmitting.value = false;
-				isSubmissionLocked = false;
-			}
-		};
-	}
-	function setValue(name, value, setValueOptions) {
-		if (__DEV__) {
-			const syntaxError = validatePathSyntax(name);
-			if (syntaxError) warnInvalidPath("setValue", name, syntaxError);
-			else {
-				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
-				if (!schemaResult.valid) warnPathNotInSchema("setValue", name, schemaResult.availableFields);
-			}
-		}
-		set(ctx.formData, name, value);
-		if (setValueOptions?.shouldDirty === false) clearFieldDirty(ctx.dirtyFields, name);
-		else updateFieldDirtyState(ctx.dirtyFields, ctx.defaultValues, ctx.defaultValueHashes, name, value);
-		if (setValueOptions?.shouldTouch) markFieldTouched(ctx.touchedFields, name);
-		if (!ctx.fieldOptions.get(name)?.controlled) {
-			const fieldRef = ctx.fieldRefs.get(name);
-			if (fieldRef?.value) updateDomElement(fieldRef.value, value);
-		}
-		if (setValueOptions?.shouldValidate) validate(name);
-	}
-	function reset(values, resetOptions) {
-		const opts = resetOptions || {};
-		ctx.validationCache.clear();
-		ctx.resetGeneration.value++;
-		clearAllPendingErrors();
-		ctx.validatingFields.value = /* @__PURE__ */ new Set();
-		for (const timer of ctx.schemaValidationTimers.values()) clearTimeout(timer);
-		ctx.schemaValidationTimers.clear();
-		for (const timer of ctx.debounceTimers.values()) clearTimeout(timer);
-		ctx.debounceTimers.clear();
-		ctx.validationRequestIds.clear();
-		if (!opts.keepDefaultValues && values) {
-			Object.assign(ctx.defaultValues, values);
-			ctx.defaultValueHashes.clear();
-		}
-		Object.keys(ctx.formData).forEach((key) => delete ctx.formData[key]);
-		const newValues = deepClone(values || ctx.defaultValues);
-		Object.assign(ctx.formData, newValues);
-		if (!opts.keepErrors) {
-			ctx.errors.value = {};
-			ctx.persistentErrorFields.clear();
-		}
-		if (!opts.keepTouched) ctx.touchedFields.value = {};
-		if (!opts.keepDirty) ctx.dirtyFields.value = {};
-		if (!opts.keepSubmitCount) ctx.submitCount.value = 0;
-		if (!opts.keepIsSubmitting) ctx.isSubmitting.value = false;
-		if (!opts.keepIsSubmitSuccessful) ctx.isSubmitSuccessful.value = false;
-		ctx.fieldArrays.clear();
-		for (const [name, fieldRef] of Array.from(ctx.fieldRefs.entries())) {
-			const el = fieldRef.value;
-			if (el) {
-				const value = get(newValues, name);
-				if (value !== void 0) if (el.type === "checkbox") el.checked = value;
-				else el.value = value;
-			}
-		}
-	}
-	function resetField(name, resetFieldOptions) {
-		if (__DEV__) {
-			const syntaxError = validatePathSyntax(name);
-			if (syntaxError) warnInvalidPath("resetField", name, syntaxError);
-			else {
-				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
-				if (!schemaResult.valid) warnPathNotInSchema("resetField", name, schemaResult.availableFields);
-			}
-		}
-		const opts = resetFieldOptions || {};
-		ctx.resetGeneration.value++;
-		ctx.validationCache.delete(`${name}:partial`);
-		ctx.validationCache.delete(`${name}:full`);
-		const errorTimer = ctx.errorDelayTimers.get(name);
-		if (errorTimer) {
-			clearTimeout(errorTimer);
-			ctx.errorDelayTimers.delete(name);
-		}
-		ctx.pendingErrors.delete(name);
-		let defaultValue = opts.defaultValue;
-		if (defaultValue === void 0) defaultValue = get(ctx.defaultValues, name);
-		else {
-			set(ctx.defaultValues, name, defaultValue);
-			ctx.defaultValueHashes.set(name, hashValue(defaultValue));
-		}
-		const clonedValue = defaultValue !== void 0 ? deepClone(defaultValue) : void 0;
-		set(ctx.formData, name, clonedValue);
-		if (!opts.keepError) clearFieldErrors(ctx.errors, name);
-		if (!opts.keepDirty) clearFieldDirty(ctx.dirtyFields, name);
-		if (!opts.keepTouched) clearFieldTouched(ctx.touchedFields, name);
-		if (!ctx.fieldOptions.get(name)?.controlled) {
-			const fieldRef = ctx.fieldRefs.get(name);
-			if (fieldRef?.value) updateDomElement(fieldRef.value, clonedValue ?? (fieldRef.value.type === "checkbox" ? false : ""));
-		}
-	}
-	function watch$1(name) {
-		if (__DEV__ && name) {
-			const names = Array.isArray(name) ? name : [name];
-			for (const n of names) {
-				const syntaxError = validatePathSyntax(n);
-				if (syntaxError) warnInvalidPath("watch", n, syntaxError);
-				else {
-					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
-					if (!schemaResult.valid) warnPathNotInSchema("watch", n, schemaResult.availableFields);
-				}
-			}
-		}
-		return (0, vue.computed)(() => {
-			if (!name) return ctx.formData;
-			if (Array.isArray(name)) {
-				const result = {};
-				for (const n of name) result[n] = get(ctx.formData, n);
-				return result;
-			}
-			return get(ctx.formData, name);
-		});
-	}
-	function clearErrors(name) {
-		if (__DEV__ && name && !String(name).startsWith("root")) {
-			const names = Array.isArray(name) ? name : [name];
-			for (const n of names) {
-				if (String(n).startsWith("root")) continue;
-				const syntaxError = validatePathSyntax(n);
-				if (syntaxError) warnInvalidPath("clearErrors", n, syntaxError);
-				else {
-					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
-					if (!schemaResult.valid) warnPathNotInSchema("clearErrors", n, schemaResult.availableFields);
-				}
-			}
-		}
-		if (name === void 0) {
-			ctx.errors.value = {};
-			ctx.externalErrors.value = {};
-			ctx.persistentErrorFields.clear();
-			return;
-		}
-		const fieldsToClean = Array.isArray(name) ? name : [name];
-		for (const field of fieldsToClean) {
-			clearFieldErrors(ctx.errors, field);
-			clearFieldErrors(ctx.externalErrors, field);
-			ctx.persistentErrorFields.delete(field);
-		}
-	}
-	function setError(name, error) {
-		const newErrors = { ...ctx.errors.value };
-		set(newErrors, name, error.type ? {
-			type: error.type,
-			message: error.message
-		} : error.message);
-		ctx.errors.value = newErrors;
-		if (error.persistent) ctx.persistentErrorFields.add(name);
-	}
-	function setErrors(errors, options$1) {
-		const newErrors = options$1?.shouldReplace ? {} : { ...ctx.errors.value };
-		for (const [name, error] of Object.entries(errors)) {
-			if (error === void 0) continue;
-			set(newErrors, name, typeof error === "string" ? error : error.type ? {
-				type: error.type,
-				message: error.message
-			} : error.message);
-		}
-		ctx.errors.value = newErrors;
-	}
-	function hasErrors(fieldPath) {
-		const mergedErrors = getMergedErrors();
-		if (fieldPath === void 0) return Object.keys(mergedErrors).length > 0;
-		const error = get(mergedErrors, fieldPath);
-		return error !== void 0 && error !== null;
-	}
-	function getErrors(fieldPath) {
-		const mergedErrors = getMergedErrors();
-		if (fieldPath === void 0) return mergedErrors;
-		return get(mergedErrors, fieldPath);
-	}
-	function getValues(nameOrNames) {
-		if (__DEV__ && nameOrNames) {
-			const names = Array.isArray(nameOrNames) ? nameOrNames : [nameOrNames];
-			for (const n of names) {
-				const syntaxError = validatePathSyntax(n);
-				if (syntaxError) warnInvalidPath("getValues", n, syntaxError);
-				else {
-					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
-					if (!schemaResult.valid) warnPathNotInSchema("getValues", n, schemaResult.availableFields);
-				}
-			}
-		}
-		syncWithDebounce();
-		if (nameOrNames === void 0) return { ...ctx.formData };
-		if (Array.isArray(nameOrNames)) {
-			const result = {};
-			for (const fieldName of nameOrNames) result[fieldName] = get(ctx.formData, fieldName);
-			return result;
-		}
-		return get(ctx.formData, nameOrNames);
-	}
-	function getFieldState(name) {
-		if (__DEV__) {
-			const syntaxError = validatePathSyntax(name);
-			if (syntaxError) warnInvalidPath("getFieldState", name, syntaxError);
-			else {
-				const schemaResult = validatePathAgainstSchema(ctx.options.schema, name);
-				if (!schemaResult.valid) warnPathNotInSchema("getFieldState", name, schemaResult.availableFields);
-			}
-		}
-		const error = get(ctx.errors.value, name);
-		return {
-			isDirty: ctx.dirtyFields.value[name] === true,
-			isTouched: ctx.touchedFields.value[name] === true,
-			invalid: error !== void 0 && error !== null,
-			error
-		};
-	}
-	async function trigger(name, options$1) {
-		if (__DEV__ && name) {
-			const names = Array.isArray(name) ? name : [name];
-			for (const n of names) {
-				const syntaxError = validatePathSyntax(n);
-				if (syntaxError) warnInvalidPath("trigger", n, syntaxError);
-				else {
-					const schemaResult = validatePathAgainstSchema(ctx.options.schema, n);
-					if (!schemaResult.valid) warnPathNotInSchema("trigger", n, schemaResult.availableFields);
-				}
-			}
-		}
-		if (options$1?.markAsSubmitted) ctx.submitCount.value++;
-		if (name === void 0) return await validate();
-		if (Array.isArray(name)) {
-			let allValid = true;
-			for (const fieldName of name) if (!await validate(fieldName)) allValid = false;
-			return allValid;
-		}
-		return await validate(name);
-	}
-	return {
-		register,
-		unregister,
-		handleSubmit,
-		formState,
-		fields,
-		setValue,
-		reset,
-		resetField,
-		watch: watch$1,
-		validate,
-		clearErrors,
-		setError,
-		setErrors,
-		hasErrors,
-		getErrors,
-		getValues,
-		getFieldState,
-		trigger,
-		setFocus,
-		options: {
-			mode: ctx.options.mode ?? "onSubmit",
-			reValidateMode: ctx.options.reValidateMode
-		}
-	};
-}
-const FormContextKey = Symbol("FormContext");
-function provideForm(methods) {
-	(0, vue.provide)(FormContextKey, methods);
-}
-function useFormContext() {
-	const context = (0, vue.inject)(FormContextKey);
-	if (!context) throw new Error("useFormContext must be used within a component tree where provideForm() has been called. Make sure to call provideForm(useForm({ schema })) in a parent component.");
-	return context;
-}
-function useWatch(options = {}) {
-	const { control, name, defaultValue } = options;
-	const form = control ?? useFormContext();
-	return (0, vue.computed)(() => {
-		if (name === void 0) return form.getValues();
-		if (Array.isArray(name)) {
-			const result = {};
-			for (const fieldName of name) result[fieldName] = get(form.getValues(), fieldName) ?? defaultValue;
-			return result;
-		}
-		return get(form.getValues(), name) ?? defaultValue;
-	});
-}
-function useController(options) {
-	const { name, control, defaultValue } = options;
-	const form = control ?? useFormContext();
-	const elementRef = (0, vue.ref)(null);
-	if (defaultValue !== void 0 && form.getValues(name) === void 0) form.setValue(name, defaultValue);
-	const value = (0, vue.computed)({
-		get: () => {
-			return form.getValues(name) ?? defaultValue;
-		},
-		set: (newValue) => {
-			form.setValue(name, newValue);
-		}
-	});
-	const onChange = (newValue) => {
-		const isTouched = form.formState.value.touchedFields[name] === true;
-		const hasSubmitted = form.formState.value.submitCount > 0;
-		const mode = form.options.mode ?? "onSubmit";
-		const reValidateMode = form.options.reValidateMode;
-		const shouldValidate = shouldValidateOnChange(mode, isTouched, reValidateMode, hasSubmitted);
-		form.setValue(name, newValue, { shouldValidate });
-	};
-	const onBlur = () => {
-		const hasSubmitted = form.formState.value.submitCount > 0;
-		const mode = form.options.mode ?? "onSubmit";
-		const reValidateMode = form.options.reValidateMode;
-		const shouldValidate = shouldValidateOnBlur(mode, hasSubmitted, reValidateMode);
-		const currentValue = form.getValues(name);
-		form.setValue(name, currentValue, {
-			shouldTouch: true,
-			shouldValidate,
-			shouldDirty: false
-		});
-	};
-	const refCallback = (el) => {
-		elementRef.value = el;
-	};
-	const fieldState = (0, vue.computed)(() => {
-		return form.getFieldState(name);
-	});
-	return {
-		field: {
-			value,
-			name,
-			onChange,
-			onBlur,
-			ref: refCallback
-		},
-		fieldState
-	};
-}
-function useFormState(options = {}) {
-	const { control, name } = options;
-	const form = control ?? useFormContext();
-	return (0, vue.computed)(() => {
-		const fullState = form.formState.value;
-		if (name === void 0) return { ...fullState };
-		if (Array.isArray(name)) {
-			const result = {};
-			for (const key of name) result[key] = fullState[key];
-			return result;
-		}
-		return { [name]: fullState[name] };
-	});
-}
-function isFieldError(error) {
-	return typeof error === "object" && error !== null && "type" in error && "message" in error && typeof error.type === "string" && typeof error.message === "string";
-}
-exports.FormContextKey = FormContextKey;
-exports.clearPathCache = clearPathCache;
-exports.generateId = generateId;
-exports.get = get;
-exports.isFieldError = isFieldError;
-exports.provideForm = provideForm;
-exports.set = set;
-exports.unset = unset;
-exports.useController = useController;
-exports.useForm = useForm;
-exports.useFormContext = useFormContext;
-exports.useFormState = useFormState;
-exports.useWatch = useWatch;