@warlock.js/seal 4.0.174 → 4.1.2

package/esm/rules/array/array-rules.d.mts

@@ -0,0 +1,16 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/array/array-rules.d.ts
+/**
+ * Unique array rule - array must contain unique values
+ */
+declare const uniqueArrayRule: SchemaRule;
+/**
+ * Sorted array rule - array must be sorted
+ */
+declare const sortedArrayRule: SchemaRule<{
+  direction?: "asc" | "desc";
+}>;
+//#endregion
+export { sortedArrayRule, uniqueArrayRule };
+//# sourceMappingURL=array-rules.d.mts.map

package/esm/rules/array/array-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/array/array-rules.ts"],"mappings":";;;;;AAMA;cAAa,eAAA,EAAiB,UAa7B;;;AAAA;cAKY,eAAA,EAAiB,UAAU;EACtC,SAAS;AAAA"}

package/esm/rules/array/array-rules.mjs

@@ -0,0 +1,41 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/array/array-rules.ts
+/**
+* Unique array rule - array must contain unique values
+*/
+const uniqueArrayRule = {
+	name: "uniqueArray",
+	description: "The array must contain unique values",
+	defaultErrorMessage: "The :input must contain unique values",
+	async validate(value, context) {
+		if (new Set(value).size === value.length) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Sorted array rule - array must be sorted
+*/
+const sortedArrayRule = {
+	name: "sortedArray",
+	description: "The array must be sorted",
+	defaultErrorMessage: "The :input must be sorted",
+	async validate(value, context) {
+		if (!Array.isArray(value) || value.length <= 1) return VALID_RULE;
+		const direction = this.context.options.direction ?? "asc";
+		this.context.translatableParams.direction = direction;
+		for (let i = 0; i < value.length - 1; i++) {
+			const current = value[i];
+			const next = value[i + 1];
+			if (direction === "asc") {
+				if (current > next) return invalidRule(this, context);
+			} else if (current < next) return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { sortedArrayRule, uniqueArrayRule };
+//# sourceMappingURL=array-rules.mjs.map

package/esm/rules/array/array-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/array/array-rules.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Unique array rule - array must contain unique values\r\n */\r\nexport const uniqueArrayRule: SchemaRule = {\r\n  name: \"uniqueArray\",\r\n  description: \"The array must contain unique values\",\r\n  defaultErrorMessage: \"The :input must contain unique values\",\r\n  async validate(value: any, context) {\r\n    const uniqueValues = new Set(value);\r\n\r\n    if (uniqueValues.size === value.length) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Sorted array rule - array must be sorted\r\n */\r\nexport const sortedArrayRule: SchemaRule<{\r\n  direction?: \"asc\" | \"desc\";\r\n}> = {\r\n  name: \"sortedArray\",\r\n  description: \"The array must be sorted\",\r\n  defaultErrorMessage: \"The :input must be sorted\",\r\n  async validate(value: any[], context) {\r\n    if (!Array.isArray(value) || value.length <= 1) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    const direction = this.context.options.direction ?? \"asc\";\r\n    this.context.translatableParams.direction = direction;\r\n\r\n    for (let i = 0; i < value.length - 1; i++) {\r\n      const current = value[i];\r\n      const next = value[i + 1];\r\n\r\n      if (direction === \"asc\") {\r\n        if (current > next) {\r\n          return invalidRule(this, context);\r\n        }\r\n      } else {\r\n        if (current < next) {\r\n          return invalidRule(this, context);\r\n        }\r\n      }\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,kBAA8B;CACzC,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAGlC,IAAI,IAFqB,IAAI,KAEd,EAAE,SAAS,MAAM,QAC9B,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,kBAER;CACH,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAc,SAAS;EACpC,IAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,UAAU,GAC3C,OAAO;EAGT,MAAM,YAAY,KAAK,QAAQ,QAAQ,aAAa;EACpD,KAAK,QAAQ,mBAAmB,YAAY;EAE5C,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;GACzC,MAAM,UAAU,MAAM;GACtB,MAAM,OAAO,MAAM,IAAI;GAEvB,IAAI,cAAc,OAChB;QAAI,UAAU,MACZ,OAAO,YAAY,MAAM,OAAO;GAClC,OAEA,IAAI,UAAU,MACZ,OAAO,YAAY,MAAM,OAAO;EAGtC;EAEA,OAAO;CACT;AACF"}

package/esm/rules/array/index.mjs

@@ -0,0 +1,3 @@
+import { sortedArrayRule, uniqueArrayRule } from "./array-rules.mjs";
+
+export {  };

package/esm/rules/color/color-rules.d.mts

@@ -0,0 +1,34 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/color/color-rules.d.ts
+/**
+ * Generic color rule - validates any color format
+ */
+declare const colorRule: SchemaRule;
+/**
+ * Hex color rule
+ */
+declare const hexColorRule: SchemaRule;
+/**
+ * RGB color rule
+ */
+declare const rgbColorRule: SchemaRule;
+/**
+ * RGBA color rule
+ */
+declare const rgbaColorRule: SchemaRule;
+/**
+ * HSL color rule
+ */
+declare const hslColorRule: SchemaRule;
+/**
+ * Light color rule
+ */
+declare const lightColorRule: SchemaRule;
+/**
+ * Dark color rule
+ */
+declare const darkColorRule: SchemaRule;
+//#endregion
+export { colorRule, darkColorRule, hexColorRule, hslColorRule, lightColorRule, rgbColorRule, rgbaColorRule };
+//# sourceMappingURL=color-rules.d.mts.map

package/esm/rules/color/color-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/color/color-rules.ts"],"mappings":";;;;;AAgBA;cAAa,SAAA,EAAW,UAgBvB;;;AAAA;cAKY,YAAA,EAAc,UAS1B;;;;cAKY,YAAA,EAAc,UAS1B;AATD;;;AAAA,cAca,aAAA,EAAe,UAS3B;AAdA;AAKD;;AALC,cAmBY,YAAA,EAAc,UAS1B;;AAdA;AAKD;cAca,cAAA,EAAgB,UAoB5B;;;AAzBA;cA8BY,aAAA,EAAe,UAoB3B"}

package/esm/rules/color/color-rules.mjs

@@ -0,0 +1,104 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/color/color-rules.ts
+/**
+* Color validation regex patterns
+*/
+const colorValidationRegex = {
+	hex: /^#([0-9a-f]{3}){1,2}$/i,
+	rgb: /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
+	rgba: /^rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*(0?\.\d+|1)\)$/,
+	hsl: /^hsl\((\d{1,3}),\s*(\d{1,3})%?,\s*(\d{1,3})%?\)$/
+};
+/**
+* Generic color rule - validates any color format
+*/
+const colorRule = {
+	name: "color",
+	defaultErrorMessage: "The :input must be a valid color",
+	async validate(value, context) {
+		if (colorValidationRegex.hex.test(value) || colorValidationRegex.rgb.test(value) || colorValidationRegex.rgba.test(value) || colorValidationRegex.hsl.test(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Hex color rule
+*/
+const hexColorRule = {
+	name: "hexColor",
+	defaultErrorMessage: "The :input must be a valid hex color",
+	async validate(value, context) {
+		if (colorValidationRegex.hex.test(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* RGB color rule
+*/
+const rgbColorRule = {
+	name: "rgbColor",
+	defaultErrorMessage: "The :input must be a valid RGB color",
+	async validate(value, context) {
+		if (colorValidationRegex.rgb.test(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* RGBA color rule
+*/
+const rgbaColorRule = {
+	name: "rgbaColor",
+	defaultErrorMessage: "The :input must be a valid RGBA color",
+	async validate(value, context) {
+		if (colorValidationRegex.rgba.test(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* HSL color rule
+*/
+const hslColorRule = {
+	name: "hslColor",
+	defaultErrorMessage: "The :input must be a valid HSL color",
+	async validate(value, context) {
+		if (colorValidationRegex.hsl.test(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Light color rule
+*/
+const lightColorRule = {
+	name: "lightColor",
+	defaultErrorMessage: "The :input must be a light color",
+	async validate(value, context) {
+		if (!colorValidationRegex.hex.test(value)) return invalidRule(this, context);
+		const hex = value.replace("#", "");
+		const r = parseInt(hex.substring(0, 2), 16);
+		const g = parseInt(hex.substring(2, 4), 16);
+		const b = parseInt(hex.substring(4, 6), 16);
+		if ((r * 299 + g * 587 + b * 114) / 1e3 > 155) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Dark color rule
+*/
+const darkColorRule = {
+	name: "darkColor",
+	defaultErrorMessage: "The :input must be a dark color",
+	async validate(value, context) {
+		if (!colorValidationRegex.hex.test(value)) return invalidRule(this, context);
+		const hex = value.replace("#", "");
+		const r = parseInt(hex.substring(0, 2), 16);
+		const g = parseInt(hex.substring(2, 4), 16);
+		const b = parseInt(hex.substring(4, 6), 16);
+		if ((r * 299 + g * 587 + b * 114) / 1e3 <= 155) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { colorRule, darkColorRule, hexColorRule, hslColorRule, lightColorRule, rgbColorRule, rgbaColorRule };
+//# sourceMappingURL=color-rules.mjs.map

package/esm/rules/color/color-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/color/color-rules.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Color validation regex patterns\r\n */\r\nconst colorValidationRegex = {\r\n  hex: /^#([0-9a-f]{3}){1,2}$/i,\r\n  rgb: /^rgb\\((\\d{1,3}),\\s*(\\d{1,3}),\\s*(\\d{1,3})\\)$/,\r\n  rgba: /^rgba\\((\\d{1,3}),\\s*(\\d{1,3}),\\s*(\\d{1,3}),\\s*(0?\\.\\d+|1)\\)$/,\r\n  hsl: /^hsl\\((\\d{1,3}),\\s*(\\d{1,3})%?,\\s*(\\d{1,3})%?\\)$/,\r\n};\r\n\r\n/**\r\n * Generic color rule - validates any color format\r\n */\r\nexport const colorRule: SchemaRule = {\r\n  name: \"color\",\r\n  defaultErrorMessage: \"The :input must be a valid color\",\r\n  async validate(value: any, context) {\r\n    const isValidColor =\r\n      colorValidationRegex.hex.test(value) ||\r\n      colorValidationRegex.rgb.test(value) ||\r\n      colorValidationRegex.rgba.test(value) ||\r\n      colorValidationRegex.hsl.test(value);\r\n\r\n    if (isValidColor) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Hex color rule\r\n */\r\nexport const hexColorRule: SchemaRule = {\r\n  name: \"hexColor\",\r\n  defaultErrorMessage: \"The :input must be a valid hex color\",\r\n  async validate(value: any, context) {\r\n    if (colorValidationRegex.hex.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * RGB color rule\r\n */\r\nexport const rgbColorRule: SchemaRule = {\r\n  name: \"rgbColor\",\r\n  defaultErrorMessage: \"The :input must be a valid RGB color\",\r\n  async validate(value: any, context) {\r\n    if (colorValidationRegex.rgb.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * RGBA color rule\r\n */\r\nexport const rgbaColorRule: SchemaRule = {\r\n  name: \"rgbaColor\",\r\n  defaultErrorMessage: \"The :input must be a valid RGBA color\",\r\n  async validate(value: any, context) {\r\n    if (colorValidationRegex.rgba.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * HSL color rule\r\n */\r\nexport const hslColorRule: SchemaRule = {\r\n  name: \"hslColor\",\r\n  defaultErrorMessage: \"The :input must be a valid HSL color\",\r\n  async validate(value: any, context) {\r\n    if (colorValidationRegex.hsl.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Light color rule\r\n */\r\nexport const lightColorRule: SchemaRule = {\r\n  name: \"lightColor\",\r\n  defaultErrorMessage: \"The :input must be a light color\",\r\n  async validate(value: any, context) {\r\n    if (!colorValidationRegex.hex.test(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    const hex = value.replace(\"#\", \"\");\r\n    const r = parseInt(hex.substring(0, 2), 16);\r\n    const g = parseInt(hex.substring(2, 4), 16);\r\n    const b = parseInt(hex.substring(4, 6), 16);\r\n    const brightness = (r * 299 + g * 587 + b * 114) / 1000;\r\n\r\n    if (brightness > 155) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Dark color rule\r\n */\r\nexport const darkColorRule: SchemaRule = {\r\n  name: \"darkColor\",\r\n  defaultErrorMessage: \"The :input must be a dark color\",\r\n  async validate(value: any, context) {\r\n    if (!colorValidationRegex.hex.test(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    const hex = value.replace(\"#\", \"\");\r\n    const r = parseInt(hex.substring(0, 2), 16);\r\n    const g = parseInt(hex.substring(2, 4), 16);\r\n    const b = parseInt(hex.substring(4, 6), 16);\r\n    const brightness = (r * 299 + g * 587 + b * 114) / 1000;\r\n\r\n    if (brightness <= 155) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAM,uBAAuB;CAC3B,KAAK;CACL,KAAK;CACL,MAAM;CACN,KAAK;AACP;;;;AAKA,MAAa,YAAwB;CACnC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAOlC,IALE,qBAAqB,IAAI,KAAK,KAAK,KACnC,qBAAqB,IAAI,KAAK,KAAK,KACnC,qBAAqB,KAAK,KAAK,KAAK,KACpC,qBAAqB,IAAI,KAAK,KAAK,GAGnC,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,qBAAqB,IAAI,KAAK,KAAK,GACrC,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,qBAAqB,IAAI,KAAK,KAAK,GACrC,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,gBAA4B;CACvC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,qBAAqB,KAAK,KAAK,KAAK,GACtC,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,qBAAqB,IAAI,KAAK,KAAK,GACrC,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,iBAA6B;CACxC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,qBAAqB,IAAI,KAAK,KAAK,GACtC,OAAO,YAAY,MAAM,OAAO;EAGlC,MAAM,MAAM,MAAM,QAAQ,KAAK,EAAE;EACjC,MAAM,IAAI,SAAS,IAAI,UAAU,GAAG,CAAC,GAAG,EAAE;EAC1C,MAAM,IAAI,SAAS,IAAI,UAAU,GAAG,CAAC,GAAG,EAAE;EAC1C,MAAM,IAAI,SAAS,IAAI,UAAU,GAAG,CAAC,GAAG,EAAE;EAG1C,KAFoB,IAAI,MAAM,IAAI,MAAM,IAAI,OAAO,MAElC,KACf,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,gBAA4B;CACvC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,qBAAqB,IAAI,KAAK,KAAK,GACtC,OAAO,YAAY,MAAM,OAAO;EAGlC,MAAM,MAAM,MAAM,QAAQ,KAAK,EAAE;EACjC,MAAM,IAAI,SAAS,IAAI,UAAU,GAAG,CAAC,GAAG,EAAE;EAC1C,MAAM,IAAI,SAAS,IAAI,UAAU,GAAG,CAAC,GAAG,EAAE;EAC1C,MAAM,IAAI,SAAS,IAAI,UAAU,GAAG,CAAC,GAAG,EAAE;EAG1C,KAFoB,IAAI,MAAM,IAAI,MAAM,IAAI,OAAO,OAEjC,KAChB,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/color/index.mjs

@@ -0,0 +1,3 @@
+import { colorRule, darkColorRule, hexColorRule, hslColorRule, lightColorRule, rgbColorRule, rgbaColorRule } from "./color-rules.mjs";
+
+export {  };

package/esm/rules/common/enum.d.mts

@@ -0,0 +1,30 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/enum.d.ts
+/**
+ * Enum rule - value must be one of the enum values
+ */
+declare const enumRule: SchemaRule<{
+  enum: any;
+}>;
+/**
+ * In rule - value must be in the given array
+ */
+declare const inRule: SchemaRule<{
+  values: any[];
+}>;
+/**
+ * Allowed values rule - value must be one of allowed values
+ */
+declare const allowedValuesRule: SchemaRule<{
+  allowedValues: any[];
+}>;
+/**
+ * Not allowed values rule - value must not be in forbidden list
+ */
+declare const notAllowedValuesRule: SchemaRule<{
+  notAllowedValues: any[];
+}>;
+//#endregion
+export { allowedValuesRule, enumRule, inRule, notAllowedValuesRule };
+//# sourceMappingURL=enum.d.mts.map

package/esm/rules/common/enum.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/enum.ts"],"mappings":";;;;;AAMA;cAAa,QAAA,EAAU,UAAU;EAAG,IAAI;AAAA;AAAA;AAwBxC;;AAxBwC,cAwB3B,MAAA,EAAQ,UAAU;EAAG,MAAM;AAAA;AAsBxC;;;AAAA,cAAa,iBAAA,EAAmB,UAAU;EAAG,aAAa;AAAA;;;;cAsB7C,oBAAA,EAAsB,UAAU;EAAG,gBAAgB;AAAA"}

package/esm/rules/common/enum.mjs

@@ -0,0 +1,77 @@
+import { VALID_RULE, invalidRule, resolveTranslation } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/enum.ts
+/**
+* Enum rule - value must be one of the enum values
+*/
+const enumRule = {
+	name: "enum",
+	defaultErrorMessage: "The :input must be one of the following values: :enum",
+	async validate(value, context) {
+		const enumValues = this.context.options.enum;
+		if (enumValues.includes(value)) return VALID_RULE;
+		this.context.translationParams.enum = enumValues.map((v) => resolveTranslation({
+			key: String(v),
+			rawValue: String(v),
+			rule: this,
+			context
+		})).join(", ");
+		return invalidRule(this, context);
+	}
+};
+/**
+* In rule - value must be in the given array
+*/
+const inRule = {
+	name: "in",
+	defaultErrorMessage: "The :input must be one of the following values: :values",
+	async validate(value, context) {
+		if (this.context.options.values.includes(value)) return VALID_RULE;
+		this.context.translationParams.values = this.context.options.values.map((v) => resolveTranslation({
+			key: String(v),
+			rawValue: String(v),
+			rule: this,
+			context
+		})).join(", ");
+		return invalidRule(this, context);
+	}
+};
+/**
+* Allowed values rule - value must be one of allowed values
+*/
+const allowedValuesRule = {
+	name: "allowedValues",
+	defaultErrorMessage: "The :input must be one of the allowed values",
+	async validate(value, context) {
+		if (this.context.options.allowedValues.includes(value)) return VALID_RULE;
+		this.context.translationParams.allowedValues = this.context.options.allowedValues.map((v) => resolveTranslation({
+			key: String(v),
+			rawValue: String(v),
+			rule: this,
+			context
+		})).join(", ");
+		return invalidRule(this, context);
+	}
+};
+/**
+* Not allowed values rule - value must not be in forbidden list
+*/
+const notAllowedValuesRule = {
+	name: "notAllowedValues",
+	defaultErrorMessage: "The :input contains a forbidden value",
+	async validate(value, context) {
+		if (!this.context.options.notAllowedValues.includes(value)) return VALID_RULE;
+		this.context.translationParams.notAllowedValues = this.context.options.notAllowedValues.map((v) => resolveTranslation({
+			key: String(v),
+			rawValue: String(v),
+			rule: this,
+			context
+		})).join(", ");
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { allowedValuesRule, enumRule, inRule, notAllowedValuesRule };
+//# sourceMappingURL=enum.mjs.map

package/esm/rules/common/enum.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/enum.ts"],"sourcesContent":["import { invalidRule, resolveTranslation, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Enum rule - value must be one of the enum values\r\n */\r\nexport const enumRule: SchemaRule<{ enum: any }> = {\r\n  name: \"enum\",\r\n  defaultErrorMessage: \"The :input must be one of the following values: :enum\",\r\n  async validate(value: any, context) {\r\n    const enumValues = this.context.options.enum;\r\n\r\n    if (enumValues.includes(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    // Translate each enum value individually, then join into a display string\r\n    this.context.translationParams.enum = enumValues\r\n      .map((v: any) =>\r\n        resolveTranslation({ key: String(v), rawValue: String(v), rule: this, context }),\r\n      )\r\n      .join(\", \");\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * In rule - value must be in the given array\r\n */\r\nexport const inRule: SchemaRule<{ values: any[] }> = {\r\n  name: \"in\",\r\n  defaultErrorMessage: \"The :input must be one of the following values: :values\",\r\n  async validate(value: any, context) {\r\n    if (this.context.options.values.includes(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    // Translate each value individually, then join\r\n    this.context.translationParams.values = this.context.options.values\r\n      .map((v: any) =>\r\n        resolveTranslation({ key: String(v), rawValue: String(v), rule: this, context }),\r\n      )\r\n      .join(\", \");\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Allowed values rule - value must be one of allowed values\r\n */\r\nexport const allowedValuesRule: SchemaRule<{ allowedValues: any[] }> = {\r\n  name: \"allowedValues\",\r\n  defaultErrorMessage: \"The :input must be one of the allowed values\",\r\n  async validate(value: any, context) {\r\n    if (this.context.options.allowedValues.includes(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    // Translate each value individually, then join\r\n    this.context.translationParams.allowedValues = this.context.options.allowedValues\r\n      .map((v: any) =>\r\n        resolveTranslation({ key: String(v), rawValue: String(v), rule: this, context }),\r\n      )\r\n      .join(\", \");\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Not allowed values rule - value must not be in forbidden list\r\n */\r\nexport const notAllowedValuesRule: SchemaRule<{ notAllowedValues: any[] }> = {\r\n  name: \"notAllowedValues\",\r\n  defaultErrorMessage: \"The :input contains a forbidden value\",\r\n  async validate(value: any, context) {\r\n    if (!this.context.options.notAllowedValues.includes(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    // Translate each value individually, then join\r\n    this.context.translationParams.notAllowedValues = this.context.options.notAllowedValues\r\n      .map((v: any) =>\r\n        resolveTranslation({ key: String(v), rawValue: String(v), rule: this, context }),\r\n      )\r\n      .join(\", \");\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,WAAsC;CACjD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,KAAK,QAAQ,QAAQ;EAExC,IAAI,WAAW,SAAS,KAAK,GAC3B,OAAO;EAIT,KAAK,QAAQ,kBAAkB,OAAO,WACnC,KAAK,MACJ,mBAAmB;GAAE,KAAK,OAAO,CAAC;GAAG,UAAU,OAAO,CAAC;GAAG,MAAM;GAAM;EAAQ,CAAC,CACjF,EACC,KAAK,IAAI;EAEZ,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,SAAwC;CACnD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,QAAQ,QAAQ,OAAO,SAAS,KAAK,GAC5C,OAAO;EAIT,KAAK,QAAQ,kBAAkB,SAAS,KAAK,QAAQ,QAAQ,OAC1D,KAAK,MACJ,mBAAmB;GAAE,KAAK,OAAO,CAAC;GAAG,UAAU,OAAO,CAAC;GAAG,MAAM;GAAM;EAAQ,CAAC,CACjF,EACC,KAAK,IAAI;EAEZ,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,oBAA0D;CACrE,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,QAAQ,QAAQ,cAAc,SAAS,KAAK,GACnD,OAAO;EAIT,KAAK,QAAQ,kBAAkB,gBAAgB,KAAK,QAAQ,QAAQ,cACjE,KAAK,MACJ,mBAAmB;GAAE,KAAK,OAAO,CAAC;GAAG,UAAU,OAAO,CAAC;GAAG,MAAM;GAAM;EAAQ,CAAC,CACjF,EACC,KAAK,IAAI;EAEZ,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,uBAAgE;CAC3E,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,KAAK,QAAQ,QAAQ,iBAAiB,SAAS,KAAK,GACvD,OAAO;EAIT,KAAK,QAAQ,kBAAkB,mBAAmB,KAAK,QAAQ,QAAQ,iBACpE,KAAK,MACJ,mBAAmB;GAAE,KAAK,OAAO,CAAC;GAAG,UAAU,OAAO,CAAC;GAAG,MAAM;GAAM;EAAQ,CAAC,CACjF,EACC,KAAK,IAAI;EAEZ,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/common/equals-field-rules.d.mts

@@ -0,0 +1,22 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/equals-field-rules.d.ts
+/**
+ * Equals field rule - value must equal another field's value
+ * Supports both global and sibling scope
+ */
+declare const equalsFieldRule: SchemaRule<{
+  field: string;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Not equals field rule - value must NOT equal another field's value
+ * Supports both global and sibling scope
+ */
+declare const notEqualsFieldRule: SchemaRule<{
+  field: string;
+  scope?: "global" | "sibling";
+}>;
+//#endregion
+export { equalsFieldRule, notEqualsFieldRule };
+//# sourceMappingURL=equals-field-rules.d.mts.map

package/esm/rules/common/equals-field-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals-field-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/equals-field-rules.ts"],"mappings":";;;;;AAOA;;cAAa,eAAA,EAAiB,UAAU;EACtC,KAAA;EACA,KAAA;AAAA;;;AAAK;AAwBP;cAAa,kBAAA,EAAoB,UAAU;EACzC,KAAA;EACA,KAAA;AAAA"}

package/esm/rules/common/equals-field-rules.mjs

@@ -0,0 +1,42 @@
+import { getFieldValue } from "../../helpers/get-field-value.mjs";
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/equals-field-rules.ts
+/**
+* Equals field rule - value must equal another field's value
+* Supports both global and sibling scope
+*/
+const equalsFieldRule = {
+	name: "equalsField",
+	description: "The value must equal another field's value",
+	sortOrder: -1,
+	requiresValue: true,
+	defaultErrorMessage: "The :input must match the :field field",
+	async validate(value, context) {
+		if (value !== getFieldValue(this, context)) {
+			this.context.translatableParams.field = this.context.options.field;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+/**
+* Not equals field rule - value must NOT equal another field's value
+* Supports both global and sibling scope
+*/
+const notEqualsFieldRule = {
+	name: "notEqualsField",
+	description: "The value must NOT equal another field's value",
+	sortOrder: -1,
+	requiresValue: true,
+	defaultErrorMessage: "The :input must not match the :field field",
+	async validate(value, context) {
+		if (value === getFieldValue(this, context)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { equalsFieldRule, notEqualsFieldRule };
+//# sourceMappingURL=equals-field-rules.mjs.map

package/esm/rules/common/equals-field-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"equals-field-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/equals-field-rules.ts"],"sourcesContent":["import { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Equals field rule - value must equal another field's value\r\n * Supports both global and sibling scope\r\n */\r\nexport const equalsFieldRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"equalsField\",\r\n  description: \"The value must equal another field's value\",\r\n  sortOrder: -1,\r\n  requiresValue: true,\r\n  defaultErrorMessage: \"The :input must match the :field field\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Value must equal the other field's value\r\n    if (value !== fieldValue) {\r\n      this.context.translatableParams.field = this.context.options.field;\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Not equals field rule - value must NOT equal another field's value\r\n * Supports both global and sibling scope\r\n */\r\nexport const notEqualsFieldRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"notEqualsField\",\r\n  description: \"The value must NOT equal another field's value\",\r\n  sortOrder: -1,\r\n  requiresValue: true,\r\n  defaultErrorMessage: \"The :input must not match the :field field\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Value must NOT equal the other field's value\r\n    if (value === fieldValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;AAOA,MAAa,kBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAIlC,IAAI,UAHe,cAAc,MAAM,OAGhB,GAAG;GACxB,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;;;;;AAMA,MAAa,qBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAIlC,IAAI,UAHe,cAAc,MAAM,OAGhB,GACrB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/rules/common/index.mjs

@@ -0,0 +1,8 @@
+import { allowedValuesRule, enumRule, inRule, notAllowedValuesRule } from "./enum.mjs";
+import { equalsFieldRule, notEqualsFieldRule } from "./equals-field-rules.mjs";
+import { instanceofRule } from "./instanceof.mjs";
+import { literalRule } from "./literal.mjs";
+import { arrayRule, booleanRule, floatRule, intRule, numberRule, objectRule, plainObjectRule, scalarRule, stringRule } from "./type-rules.mjs";
+import { unknownKeyRule } from "./unknown-key.mjs";
+
+export {  };

package/esm/rules/common/instanceof.d.mts

@@ -0,0 +1,16 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/instanceof.d.ts
+/**
+ * InstanceOf rule - value must be an instance of the given constructor.
+ *
+ * Uses the `instanceof` operator at runtime. Useful for class instances
+ * not representable in JSON Schema (File, Buffer, custom domain classes).
+ */
+declare const instanceofRule: SchemaRule<{
+  ctor: new (...args: any[]) => any;
+  name: string;
+}>;
+//#endregion
+export { instanceofRule };
+//# sourceMappingURL=instanceof.d.mts.map

package/esm/rules/common/instanceof.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanceof.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/instanceof.ts"],"mappings":";;;;;AASA;;;;cAAa,cAAA,EAAgB,UAAU;EAAG,IAAA,UAAc,IAAA;EAAqB,IAAA;AAAA"}

package/esm/rules/common/instanceof.mjs

@@ -0,0 +1,23 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/instanceof.ts
+/**
+* InstanceOf rule - value must be an instance of the given constructor.
+*
+* Uses the `instanceof` operator at runtime. Useful for class instances
+* not representable in JSON Schema (File, Buffer, custom domain classes).
+*/
+const instanceofRule = {
+	name: "instanceof",
+	defaultErrorMessage: "The :input must be an instance of :name",
+	async validate(value, context) {
+		if (value instanceof this.context.options.ctor) return VALID_RULE;
+		this.context.translationParams.name = this.context.options.name;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { instanceofRule };
+//# sourceMappingURL=instanceof.mjs.map

package/esm/rules/common/instanceof.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanceof.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/instanceof.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\nimport type { SchemaRule } from \"../../types\";\n\n/**\n * InstanceOf rule - value must be an instance of the given constructor.\n *\n * Uses the `instanceof` operator at runtime. Useful for class instances\n * not representable in JSON Schema (File, Buffer, custom domain classes).\n */\nexport const instanceofRule: SchemaRule<{ ctor: new (...args: any[]) => any; name: string }> = {\n  name: \"instanceof\",\n  defaultErrorMessage: \"The :input must be an instance of :name\",\n  async validate(value: any, context) {\n    if (value instanceof this.context.options.ctor) {\n      return VALID_RULE;\n    }\n\n    this.context.translationParams.name = this.context.options.name;\n\n    return invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;;AASA,MAAa,iBAAkF;CAC7F,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,iBAAiB,KAAK,QAAQ,QAAQ,MACxC,OAAO;EAGT,KAAK,QAAQ,kBAAkB,OAAO,KAAK,QAAQ,QAAQ;EAE3D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/common/literal.d.mts

@@ -0,0 +1,16 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/literal.d.ts
+/**
+ * Literal rule - value must be strictly equal to one of the literal values.
+ *
+ * Uses === (referential / strict equality), so distinguishes 1 from "1",
+ * true from "true", etc. Mirrors `v.string().oneOf([...])` but at the
+ * literal type level (TypeScript narrows to the union of literals).
+ */
+declare const literalRule: SchemaRule<{
+  values: readonly (string | number | boolean)[];
+}>;
+//#endregion
+export { literalRule };
+//# sourceMappingURL=literal.d.mts.map

package/esm/rules/common/literal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/literal.ts"],"mappings":";;;;;AAUA;;;;AAA6C;cAAhC,WAAA,EAAa,UAAU;EAAG,MAAM;AAAA"}

package/esm/rules/common/literal.mjs

@@ -0,0 +1,29 @@
+import { VALID_RULE, invalidRule, resolveTranslation } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/literal.ts
+/**
+* Literal rule - value must be strictly equal to one of the literal values.
+*
+* Uses === (referential / strict equality), so distinguishes 1 from "1",
+* true from "true", etc. Mirrors `v.string().oneOf([...])` but at the
+* literal type level (TypeScript narrows to the union of literals).
+*/
+const literalRule = {
+	name: "literal",
+	defaultErrorMessage: "The :input must be one of the following values: :values",
+	async validate(value, context) {
+		if (this.context.options.values.includes(value)) return VALID_RULE;
+		this.context.translationParams.values = this.context.options.values.map((v) => resolveTranslation({
+			key: String(v),
+			rawValue: String(v),
+			rule: this,
+			context
+		})).join(", ");
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { literalRule };
+//# sourceMappingURL=literal.mjs.map

package/esm/rules/common/literal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/literal.ts"],"sourcesContent":["import { invalidRule, resolveTranslation, VALID_RULE } from \"../../helpers\";\nimport type { SchemaRule } from \"../../types\";\n\n/**\n * Literal rule - value must be strictly equal to one of the literal values.\n *\n * Uses === (referential / strict equality), so distinguishes 1 from \"1\",\n * true from \"true\", etc. Mirrors `v.string().oneOf([...])` but at the\n * literal type level (TypeScript narrows to the union of literals).\n */\nexport const literalRule: SchemaRule<{ values: readonly (string | number | boolean)[] }> = {\n  name: \"literal\",\n  defaultErrorMessage: \"The :input must be one of the following values: :values\",\n  async validate(value: any, context) {\n    if (this.context.options.values.includes(value)) {\n      return VALID_RULE;\n    }\n\n    this.context.translationParams.values = this.context.options.values\n      .map(v =>\n        resolveTranslation({ key: String(v), rawValue: String(v), rule: this, context }),\n      )\n      .join(\", \");\n\n    return invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,cAA8E;CACzF,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,QAAQ,QAAQ,OAAO,SAAS,KAAK,GAC5C,OAAO;EAGT,KAAK,QAAQ,kBAAkB,SAAS,KAAK,QAAQ,QAAQ,OAC1D,KAAI,MACH,mBAAmB;GAAE,KAAK,OAAO,CAAC;GAAG,UAAU,OAAO,CAAC;GAAG,MAAM;GAAM;EAAQ,CAAC,CACjF,EACC,KAAK,IAAI;EAEZ,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/common/type-rules.d.mts

@@ -0,0 +1,42 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/common/type-rules.d.ts
+/**
+ * String rule - validates string type
+ */
+declare const stringRule: SchemaRule;
+/**
+ * Number rule - validates number type
+ */
+declare const numberRule: SchemaRule;
+/**
+ * Boolean rule - validates boolean type
+ */
+declare const booleanRule: SchemaRule;
+/**
+ * Int rule - validates integer type
+ */
+declare const intRule: SchemaRule;
+/**
+ * Float rule - validates float type
+ */
+declare const floatRule: SchemaRule;
+/**
+ * Scalar rule - validates scalar value (string, number, or boolean)
+ */
+declare const scalarRule: SchemaRule;
+/**
+ * Object rule - validates object type
+ */
+declare const objectRule: SchemaRule;
+/**
+ * Object rule - validates object type
+ */
+declare const plainObjectRule: SchemaRule;
+/**
+ * Array rule - validates array type
+ */
+declare const arrayRule: SchemaRule;
+//#endregion
+export { arrayRule, booleanRule, floatRule, intRule, numberRule, objectRule, plainObjectRule, scalarRule, stringRule };
+//# sourceMappingURL=type-rules.d.mts.map

package/esm/rules/common/type-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/common/type-rules.ts"],"mappings":";;;;;AAOA;cAAa,UAAA,EAAY,UASxB;;;AAAA;cAKY,UAAA,EAAY,UASxB;;;;cAKY,WAAA,EAAa,UASzB;AATD;;;AAAA,cAca,OAAA,EAAS,UASrB;AAdA;AAKD;;AALC,cAmBY,SAAA,EAAW,UASvB;;AAdA;AAKD;cAca,UAAA,EAAY,UASxB;;;AAdA;cAmBY,UAAA,EAAY,UAUxB;;;;cAKY,eAAA,EAAiB,UAU7B;AAzBD;;;AAAA,cA8Ba,SAAA,EAAW,UAUvB"}