@warlock.js/seal 5.15.0 → 5.17.0

package/cjs/string-6m5Y83pJ.cjs

@@ -0,0 +1,943 @@
+const require_required_methods = require('./required-methods-GwIEE6hP.cjs');
+let _mongez_reinforcements = require("@mongez/reinforcements");
+
+//#region ../seal/src/mutators/string-mutators.ts
+/** Convert string to lowercase */
+const lowercaseMutator = async (value) => {
+	return value?.toString().toLowerCase();
+};
+/** Convert string to uppercase */
+const uppercaseMutator = async (value) => {
+	return value?.toString().toUpperCase();
+};
+/** Capitalize only the first letter of the string */
+const capitalizeMutator = async (value) => {
+	const str = value?.toString();
+	return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+/** Capitalize the first letter of each word (Title Case) */
+const titleCaseMutator = async (value) => {
+	return (0, _mongez_reinforcements.capitalize)(value?.toString());
+};
+/** Convert value to string */
+const stringifyMutator = async (value) => {
+	if (!value && value !== 0) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+};
+/** Trim whitespace */
+const trimMutator = async (value, context) => {
+	return (0, _mongez_reinforcements.trim)(value?.toString(), context?.options?.needle ?? " ");
+};
+/**
+* Strip HTML tags with a naive `<...>` regex.
+*
+* This is a **tag stripper, not an XSS sanitizer**: it is not a parser, so
+* malformed/nested markup, attribute payloads, or content re-introduced
+* later in a pipeline can defeat it. Do not rely on this alone to make
+* untrusted rich text safe to render — use a real parser-based sanitizer
+* (e.g. DOMPurify / sanitize-html) for that.
+*/
+const stripTagsMutator = async (value) => {
+	return value?.toString().replace(/<[^>]*>?/gm, "");
+};
+/**
+* @deprecated Renamed to {@link stripTagsMutator} — the old name implied
+* XSS safety this tag-stripping regex does not provide. Kept as an alias
+* for backward compatibility; switch to `stripTagsMutator`.
+*/
+const safeHtmlMutator = stripTagsMutator;
+/** HTML escape */
+const htmlEscapeMutator = async (value) => {
+	return value?.toString().replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+};
+/** Remove special characters */
+const removeSpecialCharactersMutator = async (value) => {
+	return value?.toString().replace(/[^a-zA-Z0-9]/g, "");
+};
+/** URL decode */
+const urlDecodeMutator = async (value) => {
+	return decodeURIComponent(value);
+};
+/** URL encode */
+const urlEncodeMutator = async (value) => {
+	return encodeURIComponent(value);
+};
+/** Convert to camelCase */
+const camelCaseMutator = async (value) => {
+	return (0, _mongez_reinforcements.toCamelCase)(value?.toString());
+};
+/** Convert to PascalCase */
+const pascalCaseMutator = async (value) => {
+	return (0, _mongez_reinforcements.toStudlyCase)(value?.toString());
+};
+/** Convert to snake_case */
+const snakeCaseMutator = async (value) => {
+	return (0, _mongez_reinforcements.toSnakeCase)(value?.toString());
+};
+/** Convert to kebab-case */
+const kebabCaseMutator = async (value) => {
+	return (0, _mongez_reinforcements.toKebabCase)(value?.toString());
+};
+/** Convert to URL-friendly slug */
+const slugMutator = async (value) => {
+	return value?.toString().toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/--+/g, "-").replace(/^-+|-+$/g, "");
+};
+/** Trim from the left/start */
+const ltrimMutator = async (value, context) => {
+	return (0, _mongez_reinforcements.ltrim)(value?.toString(), context?.options?.needle ?? " ");
+};
+/** Trim from the right/end */
+const rtrimMutator = async (value, context) => {
+	return (0, _mongez_reinforcements.rtrim)(value?.toString(), context?.options?.needle ?? " ");
+};
+/** Base64 encode */
+const base64EncodeMutator = async (value) => {
+	return Buffer.from(value?.toString()).toString("base64");
+};
+/** Base64 decode */
+const base64DecodeMutator = async (value) => {
+	return Buffer.from(value?.toString(), "base64").toString("utf-8");
+};
+/** Replace substring or pattern */
+const replaceMutator = async (value, context) => {
+	const { search, replace } = context?.options;
+	if (!search) return value?.toString();
+	return value?.toString().replace(search, replace ?? "");
+};
+/** Replace all occurrences of substring or pattern */
+const replaceAllMutator = async (value, context) => {
+	const { search, replace } = context?.options;
+	if (!search) return value?.toString();
+	const searchValue = typeof search === "string" ? new RegExp(search, "g") : search;
+	return value?.toString().replace(searchValue, replace ?? "");
+};
+/** Append/suffix text to the end */
+const appendMutator = async (value, context) => {
+	const suffix = context?.options?.suffix ?? "";
+	return value?.toString() + suffix;
+};
+/** Prepend/prefix text to the beginning */
+const prependMutator = async (value, context) => {
+	return (context?.options?.prefix ?? "") + value?.toString();
+};
+/** Reverse the string */
+const reverseMutator = async (value) => {
+	return value?.toString().split("").reverse().join("");
+};
+/** Truncate to a maximum length */
+const truncateMutator = async (value, context) => {
+	const str = value?.toString();
+	return (0, _mongez_reinforcements.readMoreChars)(str, context?.options?.maxLength ?? 100, context?.options?.suffix ?? "...");
+};
+/** Trim multiple whitespace into single space */
+const trimMultipleWhitespaceMutator = async (value) => {
+	return value?.toString().replace(/\s+/g, " ");
+};
+/** Pad string from the start to reach target length */
+const padStartMutator = async (value, context) => {
+	const length = context?.options?.length ?? 0;
+	const char = context?.options?.char ?? " ";
+	return value?.toString().padStart(length, char);
+};
+/** Pad string from the end to reach target length */
+const padEndMutator = async (value, context) => {
+	const length = context?.options?.length ?? 0;
+	const char = context?.options?.char ?? " ";
+	return value?.toString().padEnd(length, char);
+};
+/** Repeat string N times */
+const repeatMutator = async (value, context) => {
+	const count = context?.options?.count ?? 1;
+	return value?.toString()?.repeat(count);
+};
+/** Mask part of string */
+const maskMutator = async (value, context) => {
+	const str = value?.toString();
+	const maskChar = context?.options?.char ?? "*";
+	const start = context?.options?.start ?? 0;
+	const end = context?.options?.end ?? str?.length;
+	const visibleStart = str?.substring(0, start);
+	const visibleEnd = str?.substring(end);
+	const maskedLength = end - start;
+	return visibleStart + maskChar.repeat(maskedLength) + visibleEnd;
+};
+/** Unescape HTML entities */
+const unescapeHtmlMutator = async (value) => {
+	return value?.toString().replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&#039;/g, "'");
+};
+/** Keep only alphabetic characters */
+const alphaOnlyMutator = async (value) => {
+	return value.toString().replace(/[^a-zA-Z]/g, "");
+};
+/** Keep only alphanumeric characters */
+const alphanumericOnlyMutator = async (value) => {
+	return value.toString().replace(/[^a-zA-Z0-9]/g, "");
+};
+/** Remove all numeric characters */
+const removeNumbersMutator = async (value) => {
+	return value.toString().replace(/[0-9]/g, "");
+};
+
+//#endregion
+//#region ../seal/src/validators/primitive-validator.ts
+/**
+* Abstract base validator for primitive-typed fields (string, number, boolean).
+*
+* Provides value-membership rules that are meaningful for any single primitive value
+* but not for complex structures (object, array).
+*
+* Do NOT expose this on the `v` factory — it is an inheritance-only base class.
+*
+* Hierarchy:
+*   BaseValidator
+*     └── PrimitiveValidator    ← enum, in, oneOf, allowsOnly, forbids, notIn
+*           ├── StringValidator
+*           ├── NumberValidator
+*           │     └── FloatValidator
+*           ├── BooleanValidator
+*           └── ScalarValidator  (extends PrimitiveValidator, adds asNumber/asString/accepted/declined)
+*
+* @example
+* class MyValidator extends PrimitiveValidator {
+*   // inherits: in(), forbids(), enum(), oneOf(), allowsOnly(), notIn()
+* }
+*/
+var PrimitiveValidator = class extends require_required_methods.BaseValidator {
+	/**
+	* Value must be one of the enum's values
+	*
+	* @example
+	* v.string().enum(Direction) // Direction is a TS enum
+	*/
+	enum(values, errorMessage) {
+		return this.addRule(require_required_methods.enumRule, errorMessage, { enum: Object.values(values) });
+	}
+	/**
+	* Value must be one of the given values
+	*
+	* @example
+	* v.string().in(["admin", "user", "guest"])
+	* v.number().in([1, 2, 3])
+	*/
+	in(values, errorMessage) {
+		return this.addRule(require_required_methods.inRule, errorMessage, { values });
+	}
+	/**
+	* Alias for `in()`
+	*
+	* @example
+	* v.string().oneOf(["active", "inactive"])
+	*/
+	oneOf(values, errorMessage) {
+		return this.in(values, errorMessage);
+	}
+	/**
+	* Value must be one of the allowed values (stricter variant)
+	*
+	* @example
+	* v.string().allowsOnly(["yes", "no"])
+	*/
+	allowsOnly(values, errorMessage) {
+		return this.addRule(require_required_methods.allowedValuesRule, errorMessage, { allowedValues: values });
+	}
+	/**
+	* Value must NOT be one of the given values
+	*
+	* @example
+	* v.string().forbids(["banned", "blacklisted"])
+	* v.number().forbids([0, -1])
+	*/
+	forbids(values, errorMessage) {
+		return this.addRule(require_required_methods.notAllowedValuesRule, errorMessage, { notAllowedValues: values });
+	}
+	/**
+	* Alias for `forbids()`
+	*
+	* @example
+	* v.string().notIn(["OK", "NOT OK"])
+	*/
+	notIn(values, errorMessage) {
+		return this.forbids(values, errorMessage);
+	}
+};
+
+//#endregion
+//#region ../seal/src/validators/string-validator.ts
+/**
+* String validator class
+*/
+var StringValidator = class extends PrimitiveValidator {
+	constructor(errorMessage) {
+		super();
+		this.addMutableRule(require_required_methods.stringRule, errorMessage);
+	}
+	/**
+	* Check if value is a string type
+	*/
+	matchesType(value) {
+		return typeof value === "string";
+	}
+	/**
+	* Stringify the value if not a string
+	*/
+	toString() {
+		return this.addMutator(stringifyMutator);
+	}
+	/** Convert string to uppercase */
+	uppercase() {
+		return this.addMutator(uppercaseMutator);
+	}
+	/** Convert string to lowercase */
+	lowercase() {
+		return this.addMutator(lowercaseMutator);
+	}
+	/** Capitalize only the first letter of the string */
+	capitalize() {
+		return this.addMutator(capitalizeMutator);
+	}
+	/** Capitalize the first letter of each word (Title Case) */
+	titleCase() {
+		return this.addMutator(titleCaseMutator);
+	}
+	/** Convert to camelCase */
+	camelCase() {
+		return this.addMutator(camelCaseMutator);
+	}
+	/** Convert to PascalCase */
+	pascalCase() {
+		return this.addMutator(pascalCaseMutator);
+	}
+	/** Convert to snake_case */
+	snakeCase() {
+		return this.addMutator(snakeCaseMutator);
+	}
+	/** Convert to kebab-case */
+	kebabCase() {
+		return this.addMutator(kebabCaseMutator);
+	}
+	/**
+	* Trim the given needle from the string
+	* If no needle is provided, the default is a single space
+	*/
+	trim(needle) {
+		return this.addMutator(trimMutator, { needle });
+	}
+	/** Trim from the left/start */
+	ltrim(needle) {
+		return this.addMutator(ltrimMutator, { needle });
+	}
+	/** Trim from the right/end */
+	rtrim(needle) {
+		return this.addMutator(rtrimMutator, { needle });
+	}
+	/** Trim multiple whitespace into single space */
+	trimMultipleWhitespace() {
+		return this.addMutator(trimMultipleWhitespaceMutator);
+	}
+	/** Pad string from the start to reach target length */
+	padStart(length, char = " ") {
+		return this.addMutator(padStartMutator, {
+			length,
+			char
+		});
+	}
+	/** Pad string from the end to reach target length */
+	padEnd(length, char = " ") {
+		return this.addMutator(padEndMutator, {
+			length,
+			char
+		});
+	}
+	/**
+	* Strip HTML tags with a naive `<...>` regex.
+	*
+	* This is a **tag stripper, not an XSS sanitizer**: it is not a parser,
+	* so malformed/nested markup or content re-introduced later in a
+	* pipeline can defeat it. Do not rely on this alone to make untrusted
+	* rich text safe to render — use a real parser-based sanitizer (e.g.
+	* DOMPurify / sanitize-html) for that.
+	*/
+	stripTags() {
+		return this.addMutator(stripTagsMutator);
+	}
+	/**
+	* @deprecated Renamed to {@link StringValidator.stripTags} — the old
+	* name implied XSS safety this tag-stripping regex does not provide.
+	* Kept as an alias for backward compatibility; switch to `.stripTags()`.
+	*/
+	safeHtml() {
+		return this.stripTags();
+	}
+	/** HTML escape special characters */
+	htmlEscape() {
+		return this.addMutator(htmlEscapeMutator);
+	}
+	/** Unescape HTML entities */
+	unescapeHtml() {
+		return this.addMutator(unescapeHtmlMutator);
+	}
+	/**
+	* Remove special characters
+	* This will remove all characters that are not alphanumeric or whitespace
+	*/
+	removeSpecialCharacters() {
+		return this.addMutator(removeSpecialCharactersMutator);
+	}
+	/** Convert to only alphabetic characters */
+	toAlpha() {
+		return this.addMutator(alphaOnlyMutator);
+	}
+	/** Convert to only alphanumeric characters */
+	toAlphanumeric() {
+		return this.addMutator(alphanumericOnlyMutator);
+	}
+	/** Remove all numeric characters */
+	removeNumbers() {
+		return this.addMutator(removeNumbersMutator);
+	}
+	/** URL decode */
+	urlDecode() {
+		return this.addMutator(urlDecodeMutator);
+	}
+	/** URL encode */
+	urlEncode() {
+		return this.addMutator(urlEncodeMutator);
+	}
+	/** Convert to URL-friendly slug */
+	slug() {
+		return this.addMutator(slugMutator);
+	}
+	/** Base64 encode */
+	base64Encode() {
+		return this.addMutator(base64EncodeMutator);
+	}
+	/** Base64 decode */
+	base64Decode() {
+		return this.addMutator(base64DecodeMutator);
+	}
+	/** Replace substring or pattern */
+	replace(search, replace) {
+		return this.addMutator(replaceMutator, {
+			search,
+			replace
+		});
+	}
+	/** Replace all occurrences of substring or pattern */
+	replaceAll(search, replace) {
+		return this.addMutator(replaceAllMutator, {
+			search,
+			replace
+		});
+	}
+	/** Append/suffix text to the end */
+	append(suffix) {
+		return this.addMutator(appendMutator, { suffix });
+	}
+	/** Prepend/prefix text to the beginning */
+	prepend(prefix) {
+		return this.addMutator(prependMutator, { prefix });
+	}
+	/** Reverse the string */
+	reverse() {
+		return this.addMutator(reverseMutator);
+	}
+	/** Truncate to a maximum length */
+	truncate(maxLength, suffix = "...") {
+		return this.addMutator(truncateMutator, {
+			maxLength,
+			suffix
+		});
+	}
+	/** Repeat string N times */
+	repeat(count) {
+		return this.addMutator(repeatMutator, { count });
+	}
+	/** Mask part of string */
+	mask(start, end, char = "*") {
+		return this.addMutator(maskMutator, {
+			start,
+			end,
+			char
+		});
+	}
+	/** Value must be a valid email */
+	email(errorMessage) {
+		return this.addRule(require_required_methods.emailRule, errorMessage);
+	}
+	/** Value must be a valid URL */
+	url(errorMessage) {
+		return this.addRule(require_required_methods.urlRule, errorMessage);
+	}
+	/** Value can not have whitespace */
+	withoutWhitespace(errorMessage) {
+		return this.addRule(require_required_methods.withoutWhitespaceRule, errorMessage);
+	}
+	/** Value must match the given pattern */
+	pattern(pattern, errorMessage) {
+		return this.addRule(require_required_methods.patternRule, errorMessage, { pattern });
+	}
+	/**
+	* Value must be a strong password
+	* Requirements:
+	* - At least 8 characters
+	* - At least 1 uppercase letter
+	* - At least 1 lowercase letter
+	* - At least 1 number
+	* - At least 1 special character
+	*/
+	strongPassword(minLength, errorMessage) {
+		return this.addRule(require_required_methods.strongPasswordRule, errorMessage, { minLength });
+	}
+	/** Value must be exactly the given number of words */
+	words(words, errorMessage) {
+		return this.addRule(require_required_methods.wordsRule, errorMessage, { words });
+	}
+	/** Value must be at least the given number of words */
+	minWords(words, errorMessage) {
+		return this.addRule(require_required_methods.minWordsRule, errorMessage, { minWords: words });
+	}
+	/** Value must be at most the given number of words */
+	maxWords(words, errorMessage) {
+		return this.addRule(require_required_methods.maxWordsRule, errorMessage, { maxWords: words });
+	}
+	/** Value length must be greater than the given length */
+	minLength(length, errorMessage) {
+		return this.addRule(require_required_methods.minLengthRule, errorMessage, { minLength: length });
+	}
+	/** @alias minLength */
+	min(min, errorMessage) {
+		return this.minLength(min, errorMessage);
+	}
+	/** Value length must be less than the given length */
+	maxLength(length, errorMessage) {
+		return this.addRule(require_required_methods.maxLengthRule, errorMessage, { maxLength: length });
+	}
+	/** @alias maxLength */
+	max(max, errorMessage) {
+		return this.maxLength(max, errorMessage);
+	}
+	/** Value must be of the given length */
+	length(length, errorMessage) {
+		return this.addRule(require_required_methods.lengthRule, errorMessage, { length });
+	}
+	/**
+	* String length must be between min and max (inclusive)
+	*
+	* @param min - Minimum length (inclusive)
+	* @param max - Maximum length (inclusive)
+	*
+	* @example
+	* ```ts
+	* v.string().between(5, 10)  // Length: 5 to 10 characters
+	* v.string().lengthBetween(8, 20)  // Same using alias
+	* ```
+	*
+	* @category Validation Rule
+	*/
+	lengthBetween(min, max, errorMessage) {
+		return this.addRule(require_required_methods.betweenLengthRule, errorMessage, {
+			minLength: min,
+			maxLength: max
+		});
+	}
+	/** Allow only alphabetic characters */
+	alpha(errorMessage) {
+		return this.addRule(require_required_methods.alphaRule, errorMessage);
+	}
+	/** Allow only alphanumeric characters */
+	alphanumeric(errorMessage) {
+		return this.addRule(require_required_methods.alphaNumericRule, errorMessage);
+	}
+	/** Allow only numeric characters */
+	numeric(errorMessage) {
+		return this.addRule(require_required_methods.isNumericRule, errorMessage);
+	}
+	/** Value must starts with the given string */
+	startsWith(value, errorMessage) {
+		return this.addRule(require_required_methods.startsWithRule, errorMessage, { value });
+	}
+	/** Value must ends with the given string */
+	endsWith(value, errorMessage) {
+		return this.addRule(require_required_methods.endsWithRule, errorMessage, { value });
+	}
+	/** Value must contain the given string */
+	contains(value, errorMessage) {
+		return this.addRule(require_required_methods.containsRule, errorMessage, { value });
+	}
+	/** Value must not contain the given string */
+	notContains(value, errorMessage) {
+		return this.addRule(require_required_methods.notContainsRule, errorMessage, { value });
+	}
+	/** Value must be a valid IP address */
+	ip(errorMessage) {
+		return this.addRule(require_required_methods.ipRule, errorMessage);
+	}
+	/** Value must be a valid IPv4 address */
+	ip4(errorMessage) {
+		return this.addRule(require_required_methods.ip4Rule, errorMessage);
+	}
+	/** Value must be a valid IPv6 address */
+	ip6(errorMessage) {
+		return this.addRule(require_required_methods.ip6Rule, errorMessage);
+	}
+	/** Check if the string matches a credit card number */
+	creditCard(errorMessage) {
+		return this.addRule(require_required_methods.isCreditCardRule, errorMessage);
+	}
+	/** Determine if the value is a valid color */
+	color(errorMessage) {
+		return this.addRule(require_required_methods.colorRule, errorMessage);
+	}
+	/** Determine if the value is a valid hex color */
+	hexColor(errorMessage) {
+		return this.addRule(require_required_methods.hexColorRule, errorMessage);
+	}
+	/** Determine if the value is a valid HSL color */
+	hslColor(errorMessage) {
+		return this.addRule(require_required_methods.hslColorRule, errorMessage);
+	}
+	/** Determine if the value is a valid RGB color */
+	rgbColor(errorMessage) {
+		return this.addRule(require_required_methods.rgbColorRule, errorMessage);
+	}
+	/** Determine if the value is a valid RGBA color */
+	rgbaColor(errorMessage) {
+		return this.addRule(require_required_methods.rgbaColorRule, errorMessage);
+	}
+	/** Determine if the value is a valid light color */
+	lightColor(errorMessage) {
+		return this.addRule(require_required_methods.lightColorRule, errorMessage);
+	}
+	/** Determine if the value is a valid dark color */
+	darkColor(errorMessage) {
+		return this.addRule(require_required_methods.darkColorRule, errorMessage);
+	}
+	/**
+	* Value must be a valid UUID. Optionally restrict to a specific version.
+	*
+	* @example
+	* v.string().uuid()    // any RFC 4122 UUID
+	* v.string().uuid(4)   // only v4 (random)
+	* v.string().uuid(7)   // only v7 (timestamp-ordered)
+	*/
+	uuid(version, errorMessage) {
+		return this.addRule(require_required_methods.uuidRule, errorMessage, { version });
+	}
+	/**
+	* Value must be a valid CUID. Defaults to CUID2; pass `{ version: 1 }` for legacy.
+	*
+	* @example
+	* v.string().cuid()                   // CUID2
+	* v.string().cuid({ version: 1 })     // legacy CUID1
+	*/
+	cuid(options) {
+		const { errorMessage, version } = options ?? {};
+		return this.addRule(require_required_methods.cuidRule, errorMessage, { version });
+	}
+	/** Value must be a valid ULID (26 chars, Crockford base32). */
+	ulid(errorMessage) {
+		return this.addRule(require_required_methods.ulidRule, errorMessage);
+	}
+	/**
+	* Value must be a valid nanoid string. Default length is 21.
+	*
+	* @example
+	* v.string().nanoid()       // 21 chars (default)
+	* v.string().nanoid(10)     // 10 chars
+	*/
+	nanoid(length, errorMessage) {
+		return this.addRule(require_required_methods.nanoidRule, errorMessage, { length });
+	}
+	/**
+	* @inheritdoc
+	*
+	* Maps String-specific rule options to JSON Schema keywords.
+	* Non-representable rules (cross-field, refine, color rules, etc.) are silently omitted.
+	*
+	* @example
+	* ```ts
+	* v.string().min(2).max(100).email().toJsonSchema("draft-2020-12")
+	* // → { type: "string", minLength: 2, maxLength: 100, format: "email" }
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		const schema = { type: "string" };
+		const minOpts = require_required_methods.getRuleOptions(this.rules, "minLength");
+		if (minOpts?.minLength !== void 0) schema.minLength = minOpts.minLength;
+		const maxOpts = require_required_methods.getRuleOptions(this.rules, "maxLength");
+		if (maxOpts?.maxLength !== void 0) schema.maxLength = maxOpts.maxLength;
+		const betweenOpts = require_required_methods.getRuleOptions(this.rules, "betweenLength");
+		if (betweenOpts) {
+			if (betweenOpts.minLength !== void 0) schema.minLength = betweenOpts.minLength;
+			if (betweenOpts.maxLength !== void 0) schema.maxLength = betweenOpts.maxLength;
+		}
+		const lengthOpts = require_required_methods.getRuleOptions(this.rules, "length");
+		if (lengthOpts?.length !== void 0) {
+			schema.minLength = lengthOpts.length;
+			schema.maxLength = lengthOpts.length;
+		}
+		const patternOpts = require_required_methods.getRuleOptions(this.rules, "pattern");
+		if (patternOpts?.pattern instanceof RegExp) schema.pattern = patternOpts.pattern.source;
+		if (require_required_methods.getRuleOptions(this.rules, "email") !== void 0 || this.rules.some((r) => r.name === "email")) schema.format = "email";
+		else if (this.rules.some((r) => r.name === "url")) schema.format = "uri";
+		else if (this.rules.some((r) => r.name === "ip")) schema.format = "ipv4";
+		else if (this.rules.some((r) => r.name === "ip4")) schema.format = "ipv4";
+		else if (this.rules.some((r) => r.name === "ip6")) schema.format = "ipv6";
+		else if (this.rules.some((r) => r.name === "uuid")) schema.format = "uuid";
+		else if (this.rules.some((r) => r.name === "hexColor")) schema.format = "color";
+		if (!schema.format) {
+			const cuidOpts = require_required_methods.getRuleOptions(this.rules, "cuid");
+			if (cuidOpts) schema.pattern = cuidOpts.version === 1 ? "^c[a-z0-9]{24,}$" : "^[a-z][a-z0-9]{23}$";
+			if (this.rules.some((r) => r.name === "ulid")) schema.pattern = "^[0-9A-HJKMNP-TV-Z]{26}$";
+			const nanoidOpts = require_required_methods.getRuleOptions(this.rules, "nanoid");
+			if (nanoidOpts) schema.pattern = `^[A-Za-z0-9_-]{${nanoidOpts.length ?? 21}}$`;
+		}
+		const inOpts = require_required_methods.getRuleOptions(this.rules, "in");
+		if (inOpts?.values && Array.isArray(inOpts.values)) schema.enum = inOpts.values;
+		if (this.isNullable) require_required_methods.applyNullable(schema, target);
+		return schema;
+	}
+};
+
+//#endregion
+//#region ../seal/src/string.ts
+/** Create a string schema without importing the complete `v` factory. */
+const string = (errorMessage) => new StringValidator(errorMessage);
+
+//#endregion
+Object.defineProperty(exports, 'PrimitiveValidator', {
+  enumerable: true,
+  get: function () {
+    return PrimitiveValidator;
+  }
+});
+Object.defineProperty(exports, 'StringValidator', {
+  enumerable: true,
+  get: function () {
+    return StringValidator;
+  }
+});
+Object.defineProperty(exports, 'alphaOnlyMutator', {
+  enumerable: true,
+  get: function () {
+    return alphaOnlyMutator;
+  }
+});
+Object.defineProperty(exports, 'alphanumericOnlyMutator', {
+  enumerable: true,
+  get: function () {
+    return alphanumericOnlyMutator;
+  }
+});
+Object.defineProperty(exports, 'appendMutator', {
+  enumerable: true,
+  get: function () {
+    return appendMutator;
+  }
+});
+Object.defineProperty(exports, 'base64DecodeMutator', {
+  enumerable: true,
+  get: function () {
+    return base64DecodeMutator;
+  }
+});
+Object.defineProperty(exports, 'base64EncodeMutator', {
+  enumerable: true,
+  get: function () {
+    return base64EncodeMutator;
+  }
+});
+Object.defineProperty(exports, 'camelCaseMutator', {
+  enumerable: true,
+  get: function () {
+    return camelCaseMutator;
+  }
+});
+Object.defineProperty(exports, 'capitalizeMutator', {
+  enumerable: true,
+  get: function () {
+    return capitalizeMutator;
+  }
+});
+Object.defineProperty(exports, 'htmlEscapeMutator', {
+  enumerable: true,
+  get: function () {
+    return htmlEscapeMutator;
+  }
+});
+Object.defineProperty(exports, 'kebabCaseMutator', {
+  enumerable: true,
+  get: function () {
+    return kebabCaseMutator;
+  }
+});
+Object.defineProperty(exports, 'lowercaseMutator', {
+  enumerable: true,
+  get: function () {
+    return lowercaseMutator;
+  }
+});
+Object.defineProperty(exports, 'ltrimMutator', {
+  enumerable: true,
+  get: function () {
+    return ltrimMutator;
+  }
+});
+Object.defineProperty(exports, 'maskMutator', {
+  enumerable: true,
+  get: function () {
+    return maskMutator;
+  }
+});
+Object.defineProperty(exports, 'padEndMutator', {
+  enumerable: true,
+  get: function () {
+    return padEndMutator;
+  }
+});
+Object.defineProperty(exports, 'padStartMutator', {
+  enumerable: true,
+  get: function () {
+    return padStartMutator;
+  }
+});
+Object.defineProperty(exports, 'pascalCaseMutator', {
+  enumerable: true,
+  get: function () {
+    return pascalCaseMutator;
+  }
+});
+Object.defineProperty(exports, 'prependMutator', {
+  enumerable: true,
+  get: function () {
+    return prependMutator;
+  }
+});
+Object.defineProperty(exports, 'removeNumbersMutator', {
+  enumerable: true,
+  get: function () {
+    return removeNumbersMutator;
+  }
+});
+Object.defineProperty(exports, 'removeSpecialCharactersMutator', {
+  enumerable: true,
+  get: function () {
+    return removeSpecialCharactersMutator;
+  }
+});
+Object.defineProperty(exports, 'repeatMutator', {
+  enumerable: true,
+  get: function () {
+    return repeatMutator;
+  }
+});
+Object.defineProperty(exports, 'replaceAllMutator', {
+  enumerable: true,
+  get: function () {
+    return replaceAllMutator;
+  }
+});
+Object.defineProperty(exports, 'replaceMutator', {
+  enumerable: true,
+  get: function () {
+    return replaceMutator;
+  }
+});
+Object.defineProperty(exports, 'reverseMutator', {
+  enumerable: true,
+  get: function () {
+    return reverseMutator;
+  }
+});
+Object.defineProperty(exports, 'rtrimMutator', {
+  enumerable: true,
+  get: function () {
+    return rtrimMutator;
+  }
+});
+Object.defineProperty(exports, 'safeHtmlMutator', {
+  enumerable: true,
+  get: function () {
+    return safeHtmlMutator;
+  }
+});
+Object.defineProperty(exports, 'slugMutator', {
+  enumerable: true,
+  get: function () {
+    return slugMutator;
+  }
+});
+Object.defineProperty(exports, 'snakeCaseMutator', {
+  enumerable: true,
+  get: function () {
+    return snakeCaseMutator;
+  }
+});
+Object.defineProperty(exports, 'string', {
+  enumerable: true,
+  get: function () {
+    return string;
+  }
+});
+Object.defineProperty(exports, 'stringifyMutator', {
+  enumerable: true,
+  get: function () {
+    return stringifyMutator;
+  }
+});
+Object.defineProperty(exports, 'stripTagsMutator', {
+  enumerable: true,
+  get: function () {
+    return stripTagsMutator;
+  }
+});
+Object.defineProperty(exports, 'titleCaseMutator', {
+  enumerable: true,
+  get: function () {
+    return titleCaseMutator;
+  }
+});
+Object.defineProperty(exports, 'trimMultipleWhitespaceMutator', {
+  enumerable: true,
+  get: function () {
+    return trimMultipleWhitespaceMutator;
+  }
+});
+Object.defineProperty(exports, 'trimMutator', {
+  enumerable: true,
+  get: function () {
+    return trimMutator;
+  }
+});
+Object.defineProperty(exports, 'truncateMutator', {
+  enumerable: true,
+  get: function () {
+    return truncateMutator;
+  }
+});
+Object.defineProperty(exports, 'unescapeHtmlMutator', {
+  enumerable: true,
+  get: function () {
+    return unescapeHtmlMutator;
+  }
+});
+Object.defineProperty(exports, 'uppercaseMutator', {
+  enumerable: true,
+  get: function () {
+    return uppercaseMutator;
+  }
+});
+Object.defineProperty(exports, 'urlDecodeMutator', {
+  enumerable: true,
+  get: function () {
+    return urlDecodeMutator;
+  }
+});
+Object.defineProperty(exports, 'urlEncodeMutator', {
+  enumerable: true,
+  get: function () {
+    return urlEncodeMutator;
+  }
+});
+//# sourceMappingURL=string-6m5Y83pJ.cjs.map