@sanity/validation 3.14.3 → 6.12.0-next.112

package/lib/validateDocument-Cq33kUmN.js

@@ -0,0 +1,1127 @@
+import { isArrayOfBlocksSchemaType, isKeyedObject, isReference, isSlug, isTypedObject } from "@sanity/types";
+import { createClientConcurrencyLimiter } from "@sanity/util/client";
+import { ConcurrencyLimiter } from "@sanity/util/concurrency-limiter";
+import flatten from "lodash-es/flatten.js";
+import isEqual from "lodash-es/isEqual.js";
+import { Observable, Subject, bufferTime, concat, defer, filter, finalize, firstValueFrom, from, lastValueFrom, map, merge, mergeMap, of, share, switchMap } from "rxjs";
+import { catchError, map as map$1, mergeAll, mergeMap as mergeMap$1, switchMap as switchMap$1, toArray } from "rxjs/operators";
+import { createInstance } from "i18next";
+import { Rule as Rule$1 } from "@sanity/schema";
+import get from "lodash-es/get.js";
+import isPlainObject from "lodash-es/isPlainObject.js";
+import * as legacyDateFormat from "@sanity/util/legacyDateFormat";
+import { getPublishedId } from "@sanity/id-utils";
+import memoize from "lodash-es/memoize.js";
+/** Machine-readable codes emitted by built-in document validation. @beta */
+const validationMarkerCodes = {
+	arrayDuplicateItem: "array.duplicate-item",
+	arrayExactLength: "array.exact-length",
+	arrayMaximumLength: "array.maximum-length",
+	arrayMinimumLength: "array.minimum-length",
+	assetRequired: "asset.required",
+	custom: "custom",
+	dateInvalidFormat: "date.invalid-format",
+	dateMaximum: "date.maximum",
+	dateMinimum: "date.minimum",
+	documentUnknownType: "document.unknown-type",
+	mediaCustom: "media.custom",
+	mediaInvalidReference: "media.invalid-reference",
+	mediaNotFound: "media.not-found",
+	numberGreaterThan: "number.greater-than",
+	numberInteger: "number.integer",
+	numberLessThan: "number.less-than",
+	numberMaximum: "number.maximum",
+	numberMinimum: "number.minimum",
+	numberPrecision: "number.precision",
+	objectUnknownField: "object.unknown-field",
+	referenceInvalid: "reference.invalid",
+	referenceNotPublished: "reference.not-published",
+	ruleAllFailed: "rule.all-failed",
+	ruleEitherFailed: "rule.either-failed",
+	slugInvalidType: "slug.invalid-type",
+	slugMissingCurrent: "slug.missing-current",
+	slugNotUnique: "slug.not-unique",
+	stringEmail: "string.email",
+	stringExactLength: "string.exact-length",
+	stringLowercase: "string.lowercase",
+	stringMaximumLength: "string.maximum-length",
+	stringMinimumLength: "string.minimum-length",
+	stringRegexMatch: "string.regex-match",
+	stringRegexMismatch: "string.regex-mismatch",
+	stringUppercase: "string.uppercase",
+	stringUrlCredentialsNotAllowed: "string.url.credentials-not-allowed",
+	stringUrlInvalid: "string.url.invalid",
+	stringUrlNotAbsolute: "string.url.not-absolute",
+	stringUrlNotRelative: "string.url.not-relative",
+	stringUrlSchemeNotAllowed: "string.url.scheme-not-allowed",
+	validationException: "validation.exception",
+	validationFailed: "validation.failed",
+	valueNotAllowed: "value.not-allowed",
+	valueRequired: "value.required",
+	valueTypeMismatch: "value.type-mismatch"
+}, validationLocaleStrings = {
+	"array.exact-length": "Must have exactly {{wantedLength}} items",
+	"array.exact-length_blocks": "Must have exactly {{wantedLength}} blocks",
+	"array.item-duplicate": "Can't be a duplicate",
+	"array.maximum-length": "Must have at most {{maxLength}} items",
+	"array.maximum-length_blocks": "Must have at most {{maxLength}} blocks",
+	"array.minimum-length": "Must have at least {{minLength}} items",
+	"array.minimum-length_blocks": "Must have at least {{minLength}} blocks",
+	"date.invalid-format": "Must be a valid ISO-8601 formatted date string",
+	"date.maximum": "Must be at or before {{maxDate}}",
+	"date.minimum": "Must be at or after {{minDate}}",
+	"generic.incorrect-type": "Expected type \"{{expectedType}}\", got \"{{actualType}}\"",
+	"generic.not-allowed": "Value did not match any allowed values",
+	"generic.not-allowed_hint": "Value \"{{hint}}\" did not match any allowed values",
+	"generic.required": "Required",
+	"number.greater-than": "Must be greater than {{threshold}}",
+	"number.less-than": "Must be less than {{threshold}}",
+	"number.maximum": "Must be lower than or equal to {{maxNumber}}",
+	"number.maximum-precision": "Max precision is {{limit}}",
+	"number.minimum": "Must be greater than or equal to {{minNumber}}",
+	"number.non-integer": "Must be an integer",
+	"object.asset-required": "Asset is required",
+	"object.asset-required_file": "File is required",
+	"object.asset-required_image": "Image is required",
+	"object.media-not-found": "The asset could not be found in the Media Library",
+	"object.not-media-library-asset": "Must be a reference to a Media Library asset",
+	"object.not-reference": "Must be a reference to a document",
+	"object.reference-not-published": "Referenced document must be published",
+	"slug.missing-current": "Slug must have a value",
+	"slug.not-object": "Slug must be an object",
+	"slug.not-unique": "Slug is already in use",
+	"string.email": "Must be a valid email address",
+	"string.exact-length": "Must be exactly {{wantedLength}} characters long",
+	"string.lowercase": "Must be all lowercase characters",
+	"string.maximum-length": "Must be at most {{maxLength}} characters long",
+	"string.minimum-length": "Must be at least {{minLength}} characters long",
+	"string.regex-does-not-match": "Does not match \"{{name}}\"-pattern",
+	"string.regex-match": "Should not match \"{{name}}\"-pattern",
+	"string.uppercase": "Must be all uppercase characters",
+	"string.url.disallowed-scheme": "Does not match allowed protocols/schemes",
+	"string.url.includes-credentials": "Username/password not allowed",
+	"string.url.invalid": "Not a valid URL",
+	"string.url.not-absolute": "Relative URLs are not allowed",
+	"string.url.not-relative": "Only relative URLs are allowed"
+};
+let fallbackLocaleSource;
+function getFallbackLocaleSource() {
+	if (fallbackLocaleSource) return fallbackLocaleSource;
+	let i18n = createInstance({
+		defaultNS: "validation",
+		fallbackLng: "en-US",
+		initAsync: !1,
+		interpolation: { escapeValue: !1 },
+		lng: "en-US",
+		ns: ["validation"],
+		resources: { "en-US": { validation: validationLocaleStrings } },
+		supportedLngs: ["en-US"]
+	});
+	return i18n.init(), fallbackLocaleSource = {
+		currentLocale: { id: "en-US" },
+		loadNamespaces: (namespaces) => i18n.loadNamespaces(namespaces),
+		t: i18n.t
+	}, fallbackLocaleSource;
+}
+function resolveConditionalProperty(property, context) {
+	let { currentUser, document, parent, value, path } = context;
+	return typeof property == "boolean" || property === void 0 ? !!property : property({
+		document,
+		parent,
+		value,
+		currentUser,
+		path
+	}) === !0;
+}
+function createBatchedGetDocumentExists(client) {
+	let id$ = new Subject(), limiter = new ConcurrencyLimiter(1), existence$ = id$.pipe(bufferTime(250, null, 100), map((ids) => Array.from(new Set(ids))), mergeMap((ids) => from(limiter.ready()).pipe(switchMap(() => client.observable.request({
+		url: client.getDataUrl("doc", ids.join(",")),
+		query: { excludeContent: "true" },
+		tag: "documents-availability"
+	}).pipe(map((availability) => ({
+		availability,
+		ids
+	})))), finalize(limiter.release))), mergeMap(({ availability, ids }) => ids.map((id) => {
+		let omittedIds = availability.omitted.reduce((acc, next) => (acc[next.id] = next.reason, acc), {});
+		return omittedIds[id] && omittedIds[id] === "existence" ? {
+			id,
+			exists: !1
+		} : {
+			id,
+			exists: !0
+		};
+	})), share());
+	return async function getDocumentExists(options) {
+		let result = firstValueFrom(existence$.pipe(filter(({ id }) => id === options.id)));
+		id$.next(options.id);
+		let { exists } = await result;
+		return exists;
+	};
+}
+function pathToString(path = []) {
+	return path.reduce((target, segment, i) => {
+		let segmentType = typeof segment;
+		if (segmentType === "number") return `${target}[${segment}]`;
+		if (segmentType === "string") return `${target}${i === 0 ? "" : "."}${segment}`;
+		if (isKeyedObject(segment)) return `${target}[_key=="${segment._key}"]`;
+		throw Error(`Unsupported path segment "${segment}"`);
+	}, "");
+}
+function convertToValidationMarker(validatorResult, level, context, fallback = { code: validationMarkerCodes.validationFailed }) {
+	if (!context) throw Error("missing context");
+	if (validatorResult === !0) return [];
+	if (Array.isArray(validatorResult)) return validatorResult.flatMap((child) => convertToValidationMarker(child, level, context, fallback));
+	if (typeof validatorResult == "string") return convertToValidationMarker({ message: validatorResult }, level, context, fallback);
+	if (typeof validatorResult.message != "string") throw Error(`${pathToString(context.path)}: Validator must return 'true' if valid or an error message as a string on errors`);
+	let { message, __internal_metadata } = validatorResult, code = validatorResult.code || fallback.code, details = validatorResult.details || fallback.details, normalizedPaths = [];
+	validatorResult.path && normalizedPaths.push(validatorResult.path);
+	for (let path of validatorResult.paths || []) normalizedPaths.push(path);
+	return normalizedPaths.length ? normalizedPaths.map((path) => ({
+		code,
+		...details && { details },
+		path: (context.path || []).concat(path),
+		level: level || "error",
+		item: { message },
+		message,
+		__internal_metadata
+	})) : [{
+		code,
+		...details && { details },
+		level: level || "error",
+		item: { message },
+		message,
+		path: context.path || [],
+		__internal_metadata
+	}];
+}
+/**
+* Extracts the correct localized validation message based on given locale source
+*
+* @param message - Localized messages to extract string from
+* @param i18n - Locale source, holding the current locale
+* @returns The localized string, or a fallback "Unknown error" if not found
+* @internal
+*/
+function localizeMessage(message, i18n) {
+	let { currentLocale } = i18n, locale = currentLocale.id;
+	if (message[locale]) return message[locale];
+	if (locale.includes("-")) {
+		let language = locale.split("-", 1)[0];
+		if (message[language]) return message[language];
+	}
+	return message["en-US"] || message["en-GB"] || message.en || "Unknown validation error (not localized)";
+}
+/**
+* Check if passed message/result is a localized message object
+*
+* @param message - Message to check
+* @returns True if message is a localized message object, false otherwise
+* @internal
+*/
+function isLocalizedMessages(message) {
+	return message !== !0 && message !== void 0 && typeof message != "string" && isPlainObject(message) && !("message" in message);
+}
+/**
+* Modified version of fast-deep-equal (https://github.com/epoberezkin/fast-deep-equal)
+* MIT-licensed, copyright (c) 2017 Evgeny Poberezkin
+**/
+function deepEqualsIgnoreKey(a, b) {
+	if (a === b) return !0;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length != b.length) return !1;
+		for (let i = 0; i < a.length; i++) if (!deepEqualsIgnoreKey(a[i], b[i])) return !1;
+		return !0;
+	}
+	if (Array.isArray(a) != Array.isArray(b)) return !1;
+	if (a && b && typeof a == "object" && typeof b == "object") {
+		let keys = Object.keys(a);
+		if (keys.length !== Object.keys(b).length) return !1;
+		if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+		if (a instanceof Date != b instanceof Date) return !1;
+		if (a instanceof RegExp && b instanceof RegExp) return a.toString() == b.toString();
+		if (a instanceof RegExp != b instanceof RegExp) return !1;
+		for (let i = 0; i < keys.length; i++) if (keys[i] !== "_key" && !Object.prototype.hasOwnProperty.call(b, keys[i])) return !1;
+		for (let i = 0; i < keys.length; i++) {
+			let key = keys[i];
+			if (key !== "_key" && !deepEqualsIgnoreKey(a[key], b[key])) return !1;
+		}
+		return !0;
+	}
+	return !1;
+}
+const _toString = {}.toString, builtIns = [
+	Object,
+	Function,
+	Array,
+	String,
+	Boolean,
+	Number,
+	Date,
+	RegExp,
+	Error
+];
+function isBuiltIn(_constructor) {
+	for (let i = 0; i < builtIns.length; i++) if (builtIns[i] === _constructor) return !0;
+	return !1;
+}
+function typeString(obj) {
+	let stringType = _toString.call(obj).slice(8, -1);
+	if (obj == null) return stringType.toLowerCase();
+	let constructorType = obj.constructor;
+	return constructorType && !isBuiltIn(constructorType) ? constructorType.name : stringType;
+}
+const SLOW_VALIDATOR_TIMEOUT = 5e3, formatValidationErrors = (options) => {
+	let message = options.message || (options.results.length === 1 ? options.results[0]?.message : options.i18n.t("{{messages, list}}", {
+		messages: options.results.map((err) => err.message || err.item?.message),
+		formatParams: { messages: {
+			style: "long",
+			type: options.operation
+		} }
+	}));
+	return {
+		code: options.operation === "conjunction" ? validationMarkerCodes.ruleAllFailed : validationMarkerCodes.ruleEitherFailed,
+		details: { causes: options.results.map(({ code, details, item, message: causeMessage, path }) => ({
+			code: code || validationMarkerCodes.validationFailed,
+			details,
+			message: causeMessage || item?.message,
+			path
+		})) },
+		message: message || "Validation failed"
+	};
+}, genericValidators = {
+	type: (expectedType, value, message, { i18n }) => {
+		let actualType = typeString(value);
+		return actualType !== expectedType && actualType !== "undefined" ? {
+			code: validationMarkerCodes.valueTypeMismatch,
+			details: {
+				actualType,
+				expectedType
+			},
+			message: message || i18n.t("validation:generic.incorrect-type", {
+				actualType,
+				expectedType
+			})
+		} : !0;
+	},
+	presence: (expected, value, message, { i18n }) => value === void 0 && expected === "required" ? {
+		code: validationMarkerCodes.valueRequired,
+		message: message || i18n.t("validation:generic.required")
+	} : !0,
+	all: async (children, value, message, context) => {
+		let results = (await Promise.all(children.map((child) => child.validate(value, context)))).flat();
+		return results.length === 0 || formatValidationErrors({
+			message,
+			results,
+			operation: "conjunction",
+			i18n: context.i18n
+		});
+	},
+	either: async (children, value, message, context) => {
+		let resolved = await Promise.all(children.map((child) => child.validate(value, context))), results = resolved.flat();
+		return resolved.find((result) => !result.length) ? !0 : formatValidationErrors({
+			message,
+			results,
+			operation: "disjunction",
+			i18n: context.i18n
+		});
+	},
+	valid: (allowedValues, actual, message, { i18n }) => {
+		let valueType = typeof actual;
+		if (valueType === "undefined") return !0;
+		let value = (valueType === "number" || valueType === "string") && `${actual}`, strValue = value && value.length > 30 ? `${value.slice(0, 30)}…` : value;
+		return allowedValues.some((expected) => deepEqualsIgnoreKey(expected, actual)) ? !0 : {
+			code: validationMarkerCodes.valueNotAllowed,
+			details: { allowedValuesCount: allowedValues.length },
+			message: message || i18n.t("validation:generic.not-allowed", value ? {
+				context: "hint",
+				replace: { hint: strValue }
+			} : {})
+		};
+	},
+	custom: async (fn, value, message, context) => {
+		let slowTimer = setTimeout(() => {
+			context.environment === "studio" && console.warn(`Custom validator at ${pathToString(context.path)} has taken more than ${SLOW_VALIDATOR_TIMEOUT}ms to respond`);
+		}, SLOW_VALIDATOR_TIMEOUT), result;
+		try {
+			result = await fn(value, context);
+		} finally {
+			clearTimeout(slowTimer);
+		}
+		return isLocalizedMessages(result) ? localizeMessage(result, context.i18n) : typeof result == "string" && message || result;
+	}
+}, arrayValidators = {
+	...genericValidators,
+	min: (minLength, value, message, { i18n, type }) => {
+		if (!value || value.length >= minLength) return !0;
+		let context = isArrayOfBlocksSchemaType(type) ? "blocks" : void 0;
+		return {
+			code: validationMarkerCodes.arrayMinimumLength,
+			details: {
+				actualLength: value.length,
+				minimumLength: minLength
+			},
+			message: message || i18n.t("validation:array.minimum-length", {
+				minLength,
+				context
+			})
+		};
+	},
+	max: (maxLength, value, message, { i18n, type }) => {
+		if (!value || value.length <= maxLength) return !0;
+		let context = isArrayOfBlocksSchemaType(type) ? "blocks" : void 0;
+		return {
+			code: validationMarkerCodes.arrayMaximumLength,
+			details: {
+				actualLength: value.length,
+				maximumLength: maxLength
+			},
+			message: message || i18n.t("validation:array.maximum-length", {
+				maxLength,
+				context
+			})
+		};
+	},
+	length: (wantedLength, value, message, { i18n, type }) => {
+		if (!value || value.length === wantedLength) return !0;
+		let context = isArrayOfBlocksSchemaType(type) ? "blocks" : void 0;
+		return {
+			code: validationMarkerCodes.arrayExactLength,
+			details: {
+				actualLength: value.length,
+				expectedLength: wantedLength
+			},
+			message: message || i18n.t("validation:array.exact-length", {
+				wantedLength,
+				context
+			})
+		};
+	},
+	presence: (flag, value, message, { i18n }) => flag === "required" && !value ? {
+		code: validationMarkerCodes.valueRequired,
+		message: message || i18n.t("validation:generic.required", { context: "array" })
+	} : !0,
+	valid: (allowedValues, values, message, { i18n }) => {
+		if (values === void 0) return !0;
+		let paths = [];
+		for (let i = 0; i < values.length; i++) {
+			let value = values[i];
+			if (allowedValues.some((expected) => deepEqualsIgnoreKey(expected, value))) continue;
+			let pathSegment = value && value._key ? { _key: value._key } : i;
+			paths.push([pathSegment]);
+		}
+		let sharedMessage = message || i18n.t("validation:generic.not-allowed");
+		return paths.map((path) => ({
+			code: validationMarkerCodes.valueNotAllowed,
+			details: { allowedValuesCount: allowedValues.length },
+			message: sharedMessage,
+			path
+		}));
+	},
+	unique: (_unused, value, message, { i18n }) => {
+		let dupeIndices = [];
+		if (!value) return !0;
+		for (let x = 0; x < value.length; x++) for (let y = x + 1; y < value.length; y++) {
+			let itemA = value[x], itemB = value[y];
+			deepEqualsIgnoreKey(itemA, itemB) && (dupeIndices.indexOf(x) === -1 && dupeIndices.push(x), dupeIndices.indexOf(y) === -1 && dupeIndices.push(y));
+		}
+		let paths = dupeIndices.map((idx) => {
+			let item = value[idx];
+			return [item && item._key ? { _key: item._key } : idx];
+		}), sharedMessage = message || i18n.t("validation:array.item-duplicate");
+		return paths.map((path) => ({
+			code: validationMarkerCodes.arrayDuplicateItem,
+			message: sharedMessage,
+			path
+		}));
+	}
+}, booleanValidators = {
+	...genericValidators,
+	presence: (flag, value, message, { i18n }) => flag === "required" && typeof value != "boolean" ? {
+		code: validationMarkerCodes.valueRequired,
+		message: message || i18n.t("validation:generic.required", { context: "boolean" })
+	} : !0
+};
+function isRecord$1(obj) {
+	return typeof obj == "object" && !!obj && !Array.isArray(obj);
+}
+const isoDate = /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/, getFormattedDate = (type = "", value, options) => {
+	let dateFormat = options?.dateFormat || legacyDateFormat.DEFAULT_DATE_FORMAT, timeFormat = options?.timeFormat || legacyDateFormat.DEFAULT_TIME_FORMAT;
+	return legacyDateFormat.format(value, type === "date" ? dateFormat : `${dateFormat} ${timeFormat}`, { useUTC: type === "date" });
+};
+function parseDate(date, throwOnError = !1) {
+	if (!date) return null;
+	if (date === "now") return /* @__PURE__ */ new Date();
+	let parsed = new Date(date), isInvalid = isNaN(parsed.getTime());
+	if (isInvalid && throwOnError) throw Error(`Unable to parse "${date}" to a date`);
+	return isInvalid ? null : parsed;
+}
+const dateValidators = {
+	...genericValidators,
+	type: (_unused, value, message, { i18n }) => value === void 0 || isoDate.test(`${value}`) ? !0 : {
+		code: validationMarkerCodes.dateInvalidFormat,
+		details: { actualValue: value },
+		message: message || i18n.t("validation:date.invalid-format")
+	},
+	min: (minDate, value, message, { type, i18n }) => {
+		let dateVal = parseDate(value), minDateVal = parseDate(minDate, !0);
+		if (!dateVal || !value || dateVal >= minDateVal) return !0;
+		if (!type) throw Error("`type` was not provided in validation context.");
+		let dateTimeOptions = isRecord$1(type.options) ? type.options : {};
+		return {
+			code: validationMarkerCodes.dateMinimum,
+			details: {
+				actualValue: value,
+				minimum: minDate
+			},
+			message: message || i18n.t("validation:date.minimum", {
+				minDate: getFormattedDate(type.name, minDateVal, dateTimeOptions),
+				providedMinDate: minDate
+			})
+		};
+	},
+	max: (maxDate, value, message, { type, i18n }) => {
+		let dateVal = parseDate(value), maxDateVal = parseDate(maxDate, !0);
+		if (!dateVal || !value || dateVal <= maxDateVal) return !0;
+		if (!type) throw Error("`type` was not provided in validation context.");
+		let dateTimeOptions = isRecord$1(type.options) ? type.options : {};
+		return {
+			code: validationMarkerCodes.dateMaximum,
+			details: {
+				actualValue: value,
+				maximum: maxDate
+			},
+			message: message || i18n.t("validation:date.maximum", {
+				maxDate: getFormattedDate(type.name, maxDateVal, dateTimeOptions),
+				providedMaxDate: maxDate
+			})
+		};
+	}
+}, precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/, numberValidators = {
+	...genericValidators,
+	integer: (_unused, value, message, { i18n }) => Number.isInteger(value) ? !0 : {
+		code: validationMarkerCodes.numberInteger,
+		details: { actualValue: value },
+		message: message || i18n.t("validation:number.non-integer")
+	},
+	precision: (limit, value, message, { i18n }) => {
+		if (value === void 0) return !0;
+		let places = value.toString().match(precisionRx), decimals = Math.max((places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0), 0);
+		return decimals > limit ? {
+			code: validationMarkerCodes.numberPrecision,
+			details: {
+				actualPrecision: decimals,
+				maximumPrecision: limit
+			},
+			message: message || i18n.t("validation:number.maximum-precision", { limit })
+		} : !0;
+	},
+	min: (minNumber, value, message, { i18n }) => value >= minNumber || {
+		code: validationMarkerCodes.numberMinimum,
+		details: {
+			actualValue: value,
+			minimum: minNumber
+		},
+		message: message || i18n.t("validation:number.minimum", { minNumber })
+	},
+	max: (maxNumber, value, message, { i18n }) => value <= maxNumber || {
+		code: validationMarkerCodes.numberMaximum,
+		details: {
+			actualValue: value,
+			maximum: maxNumber
+		},
+		message: message || i18n.t("validation:number.maximum", { maxNumber })
+	},
+	greaterThan: (threshold, value, message, { i18n }) => value > threshold || {
+		code: validationMarkerCodes.numberGreaterThan,
+		details: {
+			actualValue: value,
+			threshold
+		},
+		message: message || i18n.t("validation:number.greater-than", { threshold })
+	},
+	lessThan: (threshold, value, message, { i18n }) => value < threshold || {
+		code: validationMarkerCodes.numberLessThan,
+		details: {
+			actualValue: value,
+			threshold
+		},
+		message: message || i18n.t("validation:number.less-than", { threshold })
+	}
+}, metaKeys = [
+	"_key",
+	"_type",
+	"_weak"
+], objectValidators = {
+	...genericValidators,
+	presence: (expected, value, message, { i18n }) => {
+		if (expected !== "required") return !0;
+		let keys = value && Object.keys(value).filter((key) => !metaKeys.includes(key));
+		return value === void 0 || keys && keys.length === 0 ? {
+			code: validationMarkerCodes.valueRequired,
+			message: message || i18n.t("validation:generic.required", { context: "object" })
+		} : !0;
+	},
+	reference: async (_unused, value, message, context) => {
+		if (!value) return !0;
+		let { type, document, getDocumentExists, i18n } = context;
+		if (!isReference(value)) return {
+			code: validationMarkerCodes.referenceInvalid,
+			details: { actualType: typeString(value) },
+			message: message || i18n.t("validation:object.not-reference")
+		};
+		if (!type) throw Error("`type` was not provided in validation context");
+		if ("weak" in type && type.weak) return !0;
+		if (!getDocumentExists) throw Error("`getDocumentExists` was not provided in validation context");
+		let documentId = document?._id;
+		return documentId && value._ref == getPublishedId(documentId) || await getDocumentExists({ id: value._ref }) ? !0 : {
+			code: validationMarkerCodes.referenceNotPublished,
+			details: { referenceId: value._ref },
+			message: i18n.t("validation:object.reference-not-published", { documentId: value._ref })
+		};
+	},
+	assetRequired: (flag, value, message, { i18n }) => !value || !value.asset || !value.asset._ref ? {
+		__internal_metadata: { name: "assetRequired" },
+		code: validationMarkerCodes.assetRequired,
+		details: { assetType: flag.assetType },
+		message: message || i18n.t("validation:object.asset-required", { context: flag.assetType || "" })
+	} : !0,
+	media: async (fn, value, message, context) => {
+		let slowTimer = setTimeout(() => {
+			context.environment === "studio" && console.warn(`Media validator at ${pathToString(context.path)} has taken more than ${SLOW_VALIDATOR_TIMEOUT}ms to respond`);
+		}, SLOW_VALIDATOR_TIMEOUT);
+		if (!value) return !0;
+		if (!value || !value.media || !value.media._ref) return {
+			code: validationMarkerCodes.mediaInvalidReference,
+			message: context.i18n.t("validation:object.not-media-library-asset")
+		};
+		let result = !0;
+		try {
+			let [type, libraryId, documentId] = value.media._ref.split(":", 3), resourceConfig = { resource: {
+				type,
+				id: libraryId
+			} }, asset = await context.getClient({ apiVersion: "2025-02-19" }).withConfig(resourceConfig).fetch("*[_id == $id] { ..., 'currentVersion': @.currentVersion-> { ... }  }[0]", { id: documentId });
+			if (!asset) return console.warn(`${context.i18n.t("validation:object.media-not-found")}\nAsset ID: ${value.media._ref}`), {
+				code: validationMarkerCodes.mediaNotFound,
+				details: { referenceId: value.media._ref },
+				message: context.i18n.t("validation:object.media-not-found")
+			};
+			result = await fn({
+				media: { asset },
+				value
+			}, context);
+		} catch (err) {
+			throw Error(`Media validator at ${pathToString(context.path)} failed with an error: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		} finally {
+			clearTimeout(slowTimer);
+		}
+		let validationErrorMetadata = { __internal_metadata: { name: "media" } };
+		return result === !0 || Array.isArray(result) ? result : [result].map((res) => typeof res == "string" ? {
+			...validationErrorMetadata,
+			message: message || res
+		} : isLocalizedMessages(res) ? {
+			...validationErrorMetadata,
+			message: message || localizeMessage(res, context.i18n)
+		} : {
+			...validationErrorMetadata,
+			...res,
+			message: message || res.message
+		});
+	}
+}, DUMMY_ORIGIN = "http://sanity", isRelativeUrl = (url) => /^\.*\//.test(url), emailRegex = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/, typeValidators = {
+	Boolean: booleanValidators,
+	Number: numberValidators,
+	String: {
+		...genericValidators,
+		min: (minLength, value, message, { i18n }) => !value || value.length >= minLength || {
+			code: validationMarkerCodes.stringMinimumLength,
+			details: {
+				actualLength: value.length,
+				minimumLength: minLength
+			},
+			message: message || i18n.t("validation:string.minimum-length", { minLength })
+		},
+		max: (maxLength, value, message, { i18n }) => !value || value.length <= maxLength || {
+			code: validationMarkerCodes.stringMaximumLength,
+			details: {
+				actualLength: value.length,
+				maximumLength: maxLength
+			},
+			message: message || i18n.t("validation:string.maximum-length", { maxLength })
+		},
+		length: (wantedLength, value, message, { i18n }) => {
+			let strValue = value || "";
+			return strValue.length === wantedLength || {
+				code: validationMarkerCodes.stringExactLength,
+				details: {
+					actualLength: strValue.length,
+					expectedLength: wantedLength
+				},
+				message: message || i18n.t("validation:string.exact-length", { wantedLength })
+			};
+		},
+		uri: (constraints, value, message, { i18n }) => {
+			let strValue = value || "";
+			if (!strValue) return !0;
+			let { options } = constraints, { allowCredentials, relativeOnly } = options, allowRelative = options.allowRelative || relativeOnly, url;
+			try {
+				url = allowRelative ? new URL(strValue, DUMMY_ORIGIN) : new URL(strValue);
+			} catch {
+				return {
+					code: validationMarkerCodes.stringUrlInvalid,
+					message: message || i18n.t("validation:string.url.invalid")
+				};
+			}
+			if (relativeOnly && url.origin !== DUMMY_ORIGIN) return {
+				code: validationMarkerCodes.stringUrlNotRelative,
+				message: message || i18n.t("validation:string.url.not-relative")
+			};
+			if (!allowRelative && url.origin === DUMMY_ORIGIN && isRelativeUrl(strValue)) return {
+				code: validationMarkerCodes.stringUrlNotAbsolute,
+				message: message || i18n.t("validation:string.url.not-absolute")
+			};
+			if (!allowCredentials && (url.username || url.password)) return {
+				code: validationMarkerCodes.stringUrlCredentialsNotAllowed,
+				message: message || i18n.t("validation:string.url.includes-credentials")
+			};
+			let urlScheme = url.protocol.replace(/:$/, "");
+			return isRelativeUrl(strValue) || options.scheme.some((scheme) => scheme.test(urlScheme)) ? !0 : {
+				code: validationMarkerCodes.stringUrlSchemeNotAllowed,
+				details: { scheme: urlScheme },
+				message: message || i18n.t("validation:string.url.disallowed-scheme", { scheme: urlScheme })
+			};
+		},
+		stringCasing: (casing, value, message, { i18n }) => {
+			let strValue = value || "";
+			return casing === "uppercase" && strValue !== strValue.toLocaleUpperCase() ? {
+				code: validationMarkerCodes.stringUppercase,
+				message: message || i18n.t("validation:string.uppercase")
+			} : casing === "lowercase" && strValue !== strValue.toLocaleLowerCase() ? {
+				code: validationMarkerCodes.stringLowercase,
+				message: message || i18n.t("validation:string.lowercase")
+			} : !0;
+		},
+		presence: (flag, value, message, { i18n }) => flag === "required" && !value ? {
+			code: validationMarkerCodes.valueRequired,
+			message: message || i18n.t("validation:generic.required", { context: "string" })
+		} : !0,
+		regex: (options, value, message, { i18n }) => {
+			let { pattern, name, invert } = options, regName = name || `${pattern.toString()}`, strValue = value || "";
+			pattern.lastIndex = 0;
+			let matches = pattern.test(strValue);
+			return !invert && !matches || invert && matches ? {
+				code: invert ? validationMarkerCodes.stringRegexMatch : validationMarkerCodes.stringRegexMismatch,
+				details: {
+					invert,
+					name: regName,
+					pattern: pattern.source
+				},
+				message: message || (invert ? i18n.t("validation:string.regex-match", { name: regName }) : i18n.t("validation:string.regex-does-not-match", { name: regName }))
+			} : !0;
+		},
+		email: (_unused, value, message, { i18n }) => {
+			let strValue = `${value || ""}`.trim();
+			return !strValue || emailRegex.test(strValue) ? !0 : {
+				code: validationMarkerCodes.stringEmail,
+				message: message || i18n.t("validation:string.email")
+			};
+		}
+	},
+	Array: arrayValidators,
+	Object: objectValidators,
+	Date: dateValidators
+}, isFieldRef = (constraint) => typeof constraint != "object" || !constraint ? !1 : constraint.type === Rule$2.FIELD_REF, EMPTY_ARRAY = [], fallbackCodeForRule = (flag) => flag === "custom" ? validationMarkerCodes.custom : flag === "media" ? validationMarkerCodes.mediaCustom : flag === "all" ? validationMarkerCodes.ruleAllFailed : flag === "either" ? validationMarkerCodes.ruleEitherFailed : validationMarkerCodes.validationFailed, Rule$2 = class Rule extends Rule$1 {
+	static array = (def) => new Rule(def).type("Array");
+	static object = (def) => new Rule(def).type("Object");
+	static string = (def) => new Rule(def).type("String");
+	static number = (def) => new Rule(def).type("Number");
+	static boolean = (def) => new Rule(def).type("Boolean");
+	static dateTime = (def) => new Rule(def).type("Date");
+	clone() {
+		let rule = new Rule();
+		return rule._type = this._type, rule._message = this._message, rule._required = this._required, rule._rules = [...this._rules], rule._level = this._level, rule._fieldRules = this._fieldRules, rule._typeDef = this._typeDef, rule;
+	}
+	async validate(value, { __internal = {}, ...context }) {
+		let { customValidationConcurrencyLimiter } = __internal, valueIsEmpty = value == null;
+		if (valueIsEmpty && this._required === "optional") return EMPTY_ARRAY;
+		let rules = this._required === void 0 && valueIsEmpty ? this._rules.filter((curr) => curr.flag === "custom") : this._rules, validators = this._type && typeValidators[this._type] || genericValidators;
+		return (await Promise.all(rules.map(async (curr) => {
+			if (curr.flag === void 0) throw Error("Invalid rule, did not contain \"flag\"-property");
+			let validator = validators[curr.flag];
+			if (!validator) {
+				let forType = this._type ? `type "${this._type}"` : "rule without declared type";
+				throw Error(`Validator for flag "${curr.flag}" not found for ${forType}`);
+			}
+			let specConstraint = "constraint" in curr ? curr.constraint : null;
+			if (isFieldRef(specConstraint) && (specConstraint = get(context.parent, specConstraint.path)), curr.flag === "custom" && customValidationConcurrencyLimiter && !specConstraint?.bypassConcurrencyLimit) {
+				let customValidator = specConstraint;
+				specConstraint = async (...args) => {
+					await customValidationConcurrencyLimiter.ready();
+					try {
+						return await customValidator(...args);
+					} finally {
+						customValidationConcurrencyLimiter.release();
+					}
+				};
+			}
+			let message = isLocalizedMessages(this._message) ? localizeMessage(this._message, context.i18n) : this._message;
+			try {
+				return convertToValidationMarker(await validator(specConstraint, value, message, context), this._level, context, { code: fallbackCodeForRule(curr.flag) });
+			} catch (err) {
+				let errorMessage = `${pathToString(context.path)}: Exception occurred while validating value: ${err.message}`;
+				return convertToValidationMarker({
+					code: validationMarkerCodes.validationException,
+					message: errorMessage
+				}, "error", context);
+			}
+		}))).flat();
+	}
+}, memoizedWarnOnArraySlug = memoize(warnOnArraySlug);
+function serializePath(path) {
+	return path.reduce((target, part, i) => {
+		let isIndex = typeof part == "number", isKey = isKeyedObject(part);
+		return `${target}${isIndex || isKey ? "[]" : `${i === 0 ? "" : "."}${part}`}`;
+	}, "");
+}
+const defaultIsUnique = (slug, context) => {
+	let { getClient, document, path, type } = context, schemaOptions = type?.options;
+	if (!document) throw Error("`document` was not provided in validation context.");
+	if (!path) throw Error("`path` was not provided in validation context.");
+	let disableArrayWarning = schemaOptions?.disableArrayWarning || !1, docType = document._type, atPath = serializePath(path.concat("current"));
+	!disableArrayWarning && atPath.includes("[]") && context.environment === "studio" && memoizedWarnOnArraySlug(serializePath(path));
+	let constraints = [
+		"_type == $docType",
+		"!sanity::versionOf($published)",
+		`${atPath} == $slug`
+	].join(" && ");
+	return getClient({ apiVersion: "2025-02-19" }).withConfig({ perspective: "raw" }).fetch(`!defined(*[${constraints}][0]._id)`, {
+		docType,
+		published: getPublishedId(document._id),
+		slug
+	}, { tag: "validation.slug-is-unique" });
+};
+function warnOnArraySlug(serializedPath) {
+	console.warn([
+		`Slug field at path ${serializedPath} is within an array and cannot be automatically checked for uniqueness`,
+		"If you need to check for uniqueness, provide your own \"isUnique\" method",
+		"To disable this message, set `disableArrayWarning: true` on the slug `options` field"
+	].join("\n"));
+}
+/**
+* Validates slugs values by querying for uniqueness from the client.
+*
+* This is a custom rule implementation (e.g. `Rule.custom(slugValidator)`)
+* that's populated in `inferFromSchemaType` when the type name is `slug`
+*/
+const slugValidator = async (value, context) => {
+	if (!value) return !0;
+	let { i18n } = context;
+	if (typeof value != "object" || Array.isArray(value)) return {
+		code: validationMarkerCodes.slugInvalidType,
+		details: { actualType: typeString(value) },
+		message: i18n.t("validation:slug.not-object")
+	};
+	if (!isSlug(value) || value.current.trim().length === 0) return {
+		code: validationMarkerCodes.slugMissingCurrent,
+		message: i18n.t("validation:slug.missing-current")
+	};
+	let isUnique = context?.type?.options?.isUnique || defaultIsUnique, slugContext = {
+		...context,
+		parent: context.parent,
+		type: context.type,
+		defaultIsUnique
+	};
+	return await isUnique(value.current, slugContext) ? !0 : {
+		code: validationMarkerCodes.slugNotUnique,
+		details: { slug: value.current },
+		message: i18n.t("validation:slug.not-unique", { slug: value.current })
+	};
+}, ruleConstraintTypes = {
+	array: !0,
+	boolean: !0,
+	date: !0,
+	number: !0,
+	object: !0,
+	string: !0
+}, isRuleConstraint = (typeString) => typeString in ruleConstraintTypes;
+function getTypeChain(type, visited = /* @__PURE__ */ new Set()) {
+	return !type || visited.has(type) ? [] : (visited.add(type), [...type.type ? getTypeChain(type.type, visited) : [], type]);
+}
+function baseRuleReducer(inputRule, type) {
+	let baseRule = inputRule;
+	isRuleConstraint(type.jsonType) && (baseRule = baseRule.type(type.jsonType));
+	let typeOptionsList = type?.options && typeof type.options == "object" && "list" in type.options && type.options.list;
+	return Array.isArray(typeOptionsList) && (baseRule = baseRule.valid(typeOptionsList.map((option) => extractValueFromListOption(option, type)))), type.name === "datetime" || type.name === "date" ? baseRule.type("Date") : type.name === "url" ? baseRule.uri() : type.name === "slug" ? baseRule.custom(slugValidator, { bypassConcurrencyLimit: !0 }) : type.name === "reference" ? baseRule.reference() : type.name === "email" ? baseRule.email() : baseRule;
+}
+function hasValueField(typeDef) {
+	return typeDef ? !("fields" in typeDef) && typeDef.type ? hasValueField(typeDef.type) : !("fields" in typeDef) || !Array.isArray(typeDef.fields) ? !1 : typeDef.fields.some((field) => field.name === "value") : !1;
+}
+function extractValueFromListOption(option, typeDef) {
+	return typeDef.jsonType === "object" && hasValueField(typeDef) || option.value === void 0 ? option : option.value;
+}
+const isUriSpec = (spec) => spec.flag === "uri";
+function omitLeakedDefaultUri(rules, typeDef) {
+	if (!getTypeChain(typeDef).some((type) => type.name === "url")) return rules;
+	let defaultUri = new Rule$2(typeDef).uri()._rules.find(isUriSpec)?.constraint, isDefaultUri = (spec) => isUriSpec(spec) && isEqual(spec.constraint, defaultUri), isCustomUri = (spec) => isUriSpec(spec) && !isEqual(spec.constraint, defaultUri);
+	return rules.some((rule) => rule._rules.some(isCustomUri)) ? rules.map((rule) => {
+		if (!rule._rules.some(isDefaultUri)) return rule;
+		let cleaned = rule.clone();
+		return cleaned._rules = rule._rules.filter((spec) => !isDefaultUri(spec)), cleaned;
+	}) : rules;
+}
+function normalizeValidationRules(typeDef, context) {
+	if (!typeDef) return [];
+	let validation = typeDef.validation;
+	if (Array.isArray(validation)) return omitLeakedDefaultUri(validation.flatMap((i) => normalizeValidationRules({
+		...typeDef,
+		validation: i
+	}, context)), typeDef);
+	let baseRule = Object.values(getTypeChain(typeDef).reduce((acc, type) => (acc[type.name] = type, acc), {})).reduce(baseRuleReducer, new Rule$2(typeDef));
+	return validation && typeof validation == "object" ? [validation] : validation && typeof validation == "function" ? normalizeValidationRules({
+		...typeDef,
+		validation: validation(baseRule, context)
+	}, context) : [baseRule];
+}
+/**
+* Simple requestIdleCallback polyfill
+* Can be removed when all browsers support requestIdleCallback: https://caniuse.com/requestidlecallback
+* @param callback -
+* @param options -
+*/
+const requestIdleCallbackShim = function requestIdleCallbackShim(callback, _options) {
+	let start = Date.now();
+	return globalThis.setTimeout(() => {
+		callback({
+			didTimeout: !1,
+			timeRemaining() {
+				return Math.max(0, Date.now() - start);
+			}
+		});
+	}, 0);
+}, cancelIdleCallbackShim = function cancelIdleCallbackShim(handle) {
+	return globalThis.clearTimeout(handle);
+}, win = typeof window > "u" ? void 0 : window, requestIdleCallback = win?.requestIdleCallback || requestIdleCallbackShim, cancelIdleCallback = win?.cancelIdleCallback || cancelIdleCallbackShim, unknownFieldsValidator = (type) => (value) => {
+	if (typeof value != "object" || !value) return !0;
+	let fieldNames = new Set(type.fields?.map((field) => field.name));
+	return Object.keys(value).filter((key) => !key.startsWith("_")).filter((key) => !fieldNames.has(key)).map((unknownField) => ({
+		code: validationMarkerCodes.objectUnknownField,
+		details: {
+			fieldName: unknownField,
+			typeName: type.name
+		},
+		message: `Field '${unknownField}' does not exist on type '${type.name}'`,
+		path: [unknownField]
+	}));
+}, DEFAULT_VALIDATION_CLIENT_OPTIONS = { apiVersion: "2025-02-19" }, isRecord = (maybeRecord) => typeof maybeRecord == "object" && !!maybeRecord && !Array.isArray(maybeRecord);
+/**
+* Recursively extracts all `_fieldRules` from a rule and its nested constraints.
+* This handles cases where `Rule.fields()` is used inside `Rule.all()` or `Rule.either()`.
+*/
+function extractFieldRulesFromRule(rule) {
+	let results = [];
+	rule._fieldRules && results.push(rule._fieldRules);
+	for (let ruleSpec of rule._rules) if (ruleSpec.flag === "all" || ruleSpec.flag === "either") {
+		let childRules = ruleSpec.constraint;
+		if (Array.isArray(childRules)) for (let childRule of childRules) results.push(...extractFieldRulesFromRule(childRule));
+	}
+	return results;
+}
+/**
+* @internal
+*/
+function resolveTypeForArrayItem(item, candidates) {
+	if (candidates.length === 1) return candidates[0];
+	let itemType = isTypedObject(item) && item._type, primitive = item == null || !itemType && typeString(item).toLowerCase();
+	return primitive && primitive !== "object" ? candidates.find((candidate) => candidate.jsonType === primitive) : candidates.find((candidate) => candidate.type?.name === itemType) || candidates.find((candidate) => candidate.name === itemType) || candidates.find((candidate) => candidate.name === "object" && primitive === "object");
+}
+/**
+* Validates a document against the schema in a resolved Studio workspace or source.
+*
+* @beta
+* @deprecated Prefer {@link validateDocument} with `{document, schema, client}` for new code.
+*/
+function validateDocumentWithWorkspace({ document, workspace, getClient = workspace.getClient, getDocumentExists, environment = "studio", maxCustomValidationConcurrency, maxFetchConcurrency, currentUser }) {
+	return validateDocumentInternal({
+		currentUser,
+		document,
+		environment,
+		getClient,
+		getDocumentExists,
+		i18n: workspace.i18n,
+		maxCustomValidationConcurrency,
+		maxFetchConcurrency,
+		schema: workspace.schema
+	});
+}
+function validateDocument(options) {
+	if ("workspace" in options) return validateDocumentWithWorkspace(options);
+	let { client, document, schema, ...internalOptions } = options;
+	return validateDocumentInternal({
+		...internalOptions,
+		document,
+		environment: "cli",
+		getClient: ({ apiVersion }) => client.withConfig({ apiVersion }),
+		i18n: getFallbackLocaleSource(),
+		schema
+	});
+}
+/** @internal */
+function validateDocumentInternal({ document, schema, getClient, getDocumentExists, i18n = getFallbackLocaleSource(), environment, maxCustomValidationConcurrency, maxFetchConcurrency, currentUser }) {
+	let limitConcurrency = createClientConcurrencyLimiter(maxFetchConcurrency ?? 25), getConcurrencyLimitedClient = (clientOptions) => limitConcurrency(getClient(clientOptions));
+	return lastValueFrom(validateDocumentObservable({
+		document,
+		getClient: getConcurrencyLimitedClient,
+		i18n,
+		schema,
+		getDocumentExists: getDocumentExists || createBatchedGetDocumentExists(getClient(DEFAULT_VALIDATION_CLIENT_OPTIONS)),
+		environment,
+		maxCustomValidationConcurrency,
+		currentUser
+	}));
+}
+const customValidationConcurrencyLimiters = /* @__PURE__ */ new WeakMap();
+/**
+* Validates a document against the given schema, returning an Observable
+* @internal
+*/
+function validateDocumentObservable({ document, getClient, i18n = getFallbackLocaleSource(), schema, getDocumentExists, environment, maxCustomValidationConcurrency, currentUser }) {
+	if (typeof document?._type != "string") throw Error("Tried to validate a value without a '_type'");
+	let documentType = schema.get(document._type);
+	if (!documentType) return environment === "studio" ? (console.warn("Schema type for object type \"%s\" not found, skipping validation", document._type), of([])) : of([{
+		code: validationMarkerCodes.documentUnknownType,
+		details: { documentType: document._type },
+		level: "warning",
+		message: `Could not find schema type for type '${document._type}', skipping validation`,
+		path: []
+	}]);
+	let customValidationConcurrencyLimiter = customValidationConcurrencyLimiters.get(schema);
+	customValidationConcurrencyLimiter || (customValidationConcurrencyLimiter = new ConcurrencyLimiter(maxCustomValidationConcurrency ?? 5), customValidationConcurrencyLimiters.set(schema, customValidationConcurrencyLimiter));
+	let validationOptions = {
+		getClient,
+		schema,
+		parent: void 0,
+		value: document,
+		path: [],
+		document,
+		type: documentType,
+		i18n,
+		getDocumentExists,
+		environment,
+		customValidationConcurrencyLimiter,
+		currentUser
+	};
+	return from(i18n.loadNamespaces(["validation"])).pipe(switchMap$1(() => validateItemObservable(validationOptions)), map$1((markers) => markers.map(toDocumentValidationMarker)), catchError((err) => {
+		console.error(err);
+		let message = err?.message || "Unknown error", errorMarker = {
+			code: validationMarkerCodes.validationException,
+			level: "error",
+			message,
+			item: { message },
+			path: []
+		};
+		return of([errorMarker]);
+	}));
+}
+function validateItem(opts) {
+	return lastValueFrom(validateItemObservable(opts));
+}
+function validateItemObservable({ value, type, path = [], parent, customValidationConcurrencyLimiter, environment, ...restOfContext }) {
+	let ancestorHidden = restOfContext.hidden === !0, resolveHiddenForType = (schemaType, schemaValue, schemaParent, schemaPath, ancestorHiddenValue) => schemaType ? ancestorHiddenValue || resolveConditionalProperty(schemaType.hidden, {
+		...restOfContext,
+		parent: schemaParent,
+		value: schemaValue,
+		path: schemaPath || [],
+		currentUser: restOfContext.currentUser ?? null
+	}) : ancestorHiddenValue, hidden = resolveHiddenForType(type, value, parent, path, ancestorHidden), addUnknownFieldsValidator = (rule) => type?.jsonType === "object" && getTypeChain(type).find((t) => [
+		"object",
+		"document",
+		"file",
+		"image"
+	].includes(t.name)) && environment !== "studio" ? rule.custom(unknownFieldsValidator(type), { bypassConcurrencyLimit: !0 }).warning() : rule, rules = normalizeValidationRules(type, {
+		...restOfContext,
+		hidden,
+		environment,
+		parent,
+		path,
+		type
+	}), selfChecks = rules.map(addUnknownFieldsValidator).map((rule) => defer(() => rule.validate(value, {
+		...restOfContext,
+		environment,
+		hidden,
+		parent,
+		path,
+		type,
+		__internal: { customValidationConcurrencyLimiter }
+	}))), nestedChecks = [], selfIsRequired = rules.some((rule) => rule.isRequired());
+	if (type?.jsonType === "object" && (value || value == null && selfIsRequired)) {
+		let fieldTypes = type.fields.reduce((acc, field) => (acc[field.name] = field.type, acc), {});
+		nestedChecks = nestedChecks.concat(rules.flatMap((rule) => extractFieldRulesFromRule(rule)).flatMap((fieldResults) => Object.entries(fieldResults)).flatMap(([name, validation]) => {
+			let fieldType = fieldTypes[name];
+			return normalizeValidationRules({
+				...fieldType,
+				validation
+			}).map(addUnknownFieldsValidator).map((subRule) => {
+				let nestedValue = isRecord(value) ? value[name] : void 0, nestedHidden = resolveHiddenForType(fieldType, nestedValue, value, path.concat(name), hidden);
+				return defer(() => subRule.validate(nestedValue, {
+					...restOfContext,
+					parent: value,
+					path: path.concat(name),
+					type: fieldType,
+					environment,
+					hidden: nestedHidden,
+					__internal: { customValidationConcurrencyLimiter }
+				}));
+			});
+		})), nestedChecks = nestedChecks.concat(type.fields.map((field) => validateItemObservable({
+			...restOfContext,
+			hidden,
+			parent: value,
+			value: isRecord(value) ? value[field.name] : void 0,
+			path: path.concat(field.name),
+			type: field.type,
+			environment,
+			customValidationConcurrencyLimiter
+		})));
+	}
+	return type?.jsonType === "array" && Array.isArray(value) && (nestedChecks = nestedChecks.concat(value.map((item, index) => validateItemObservable({
+		...restOfContext,
+		hidden,
+		parent: value,
+		value: item,
+		path: path.concat(isKeyedObject(item) ? { _key: item._key } : index),
+		type: resolveTypeForArrayItem(item, type.of),
+		environment,
+		customValidationConcurrencyLimiter
+	})))), defer(() => merge([...selfChecks, ...nestedChecks])).pipe(mergeMap$1((validateNode) => concat(idle(), validateNode), 40), mergeAll(), toArray(), map$1(flatten), map$1((results) => rules.some((rule) => extractFieldRulesFromRule(rule).length > 0) ? deduplicateMarkers(results) : results));
+}
+function deduplicateMarkers(markers) {
+	let buckets = /* @__PURE__ */ new Map();
+	return markers.filter((marker) => {
+		let key = JSON.stringify([
+			marker.level,
+			marker.code,
+			marker.message,
+			marker.path
+		]), bucket = buckets.get(key);
+		return bucket ? !bucket.some((existing) => isEqual(existing, marker)) && (bucket.push(marker), !0) : (buckets.set(key, [marker]), !0);
+	});
+}
+function hasValidationMarkerCode(marker) {
+	return typeof marker.code == "string";
+}
+function toDocumentValidationMarker(marker) {
+	return hasValidationMarkerCode(marker) ? marker : {
+		...marker,
+		code: validationMarkerCodes.validationFailed
+	};
+}
+function idle(timeout) {
+	return new Observable((observer) => {
+		let handle = requestIdleCallback(() => {
+			observer.complete();
+		}, timeout ? { timeout } : void 0);
+		return () => cancelIdleCallback(handle);
+	});
+}
+export { validateDocumentWithWorkspace as a, normalizeValidationRules as c, convertToValidationMarker as d, pathToString as f, validationMarkerCodes as h, validateDocumentObservable as i, Rule$2 as l, validationLocaleStrings as m, validateDocument as n, validateItem as o, getFallbackLocaleSource as p, validateDocumentInternal as r, getTypeChain as s, resolveTypeForArrayItem as t, typeString as u };
+
+//# sourceMappingURL=validateDocument-Cq33kUmN.js.map