@attrx/role-morphic 0.1.0 → 0.2.1

package/dist/validate.mjs

@@ -0,0 +1,669 @@
+// src/roles/area/validate.ts
+var AREA_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Area cannot be negative"
+};
+function validateArea(value, config = AREA_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number") {
+    return { valid: false, errors: ["Value must be a number"] };
+  }
+  if (!Number.isFinite(value)) {
+    return { valid: false, errors: ["Value must be finite"] };
+  }
+  if (config.min !== void 0 && value < config.min) {
+    const msg = config.minError ?? `Value must be at least ${config.min}`;
+    errors.push(msg);
+  }
+  if (config.max !== void 0 && value > config.max) {
+    const msg = config.maxError ?? `Value must be at most ${config.max}`;
+    errors.push(msg);
+  }
+  if (config.integer && !Number.isInteger(value)) {
+    errors.push("Value must be an integer");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isValidArea(value, config = AREA_VALIDATION_CONFIG) {
+  return validateArea(value, config).valid;
+}
+
+// src/roles/length/validate.ts
+var LENGTH_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Length cannot be negative"
+};
+function validateLength(value, config = LENGTH_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number") {
+    return { valid: false, errors: ["Value must be a number"] };
+  }
+  if (!Number.isFinite(value)) {
+    return { valid: false, errors: ["Value must be finite"] };
+  }
+  if (config.min !== void 0 && value < config.min) {
+    const msg = config.minError ?? `Value must be at least ${config.min}`;
+    errors.push(msg);
+  }
+  if (config.max !== void 0 && value > config.max) {
+    const msg = config.maxError ?? `Value must be at most ${config.max}`;
+    errors.push(msg);
+  }
+  if (config.integer && !Number.isInteger(value)) {
+    errors.push("Value must be an integer");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isValidLength(value, config = LENGTH_VALIDATION_CONFIG) {
+  return validateLength(value, config).valid;
+}
+
+// src/roles/mass/validate.ts
+var MASS_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Mass cannot be negative"
+};
+function validateMass(value, config = MASS_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number") {
+    return { valid: false, errors: ["Value must be a number"] };
+  }
+  if (!Number.isFinite(value)) {
+    return { valid: false, errors: ["Value must be finite"] };
+  }
+  if (config.min !== void 0 && value < config.min) {
+    const msg = config.minError ?? `Value must be at least ${config.min}`;
+    errors.push(msg);
+  }
+  if (config.max !== void 0 && value > config.max) {
+    const msg = config.maxError ?? `Value must be at most ${config.max}`;
+    errors.push(msg);
+  }
+  if (config.integer && !Number.isInteger(value)) {
+    errors.push("Value must be an integer");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isValidMass(value, config = MASS_VALIDATION_CONFIG) {
+  return validateMass(value, config).valid;
+}
+var TEMPERATURE_CONSTANTS = {
+  /** Zero absoluto em Celsius */
+  ABSOLUTE_ZERO_CELSIUS: -273.15,
+  /** Zero absoluto em Fahrenheit */
+  ABSOLUTE_ZERO_FAHRENHEIT: -459.67};
+
+// src/roles/temperature/validate.ts
+var ABSOLUTE_ZERO = {
+  celsius: TEMPERATURE_CONSTANTS.ABSOLUTE_ZERO_CELSIUS,
+  fahrenheit: TEMPERATURE_CONSTANTS.ABSOLUTE_ZERO_FAHRENHEIT,
+  kelvin: 0,
+  rankine: 0
+};
+var UNIT_SYMBOLS = {
+  celsius: "\xB0C",
+  fahrenheit: "\xB0F",
+  kelvin: "K",
+  rankine: "\xB0R"
+};
+function validateTemperature(value, unit = "celsius", config = {}) {
+  const errors = [];
+  if (typeof value !== "number") {
+    return { valid: false, errors: ["Value must be a number"] };
+  }
+  if (!Number.isFinite(value)) {
+    return { valid: false, errors: ["Value must be finite"] };
+  }
+  if (!config.allowBelowAbsoluteZero) {
+    const absoluteZero = ABSOLUTE_ZERO[unit];
+    if (value < absoluteZero) {
+      const symbol = UNIT_SYMBOLS[unit];
+      errors.push(
+        `Temperature cannot be below absolute zero (${absoluteZero}${symbol})`
+      );
+    }
+  }
+  if (config.max !== void 0 && value > config.max) {
+    const msg = config.maxError ?? `Value must be at most ${config.max}`;
+    errors.push(msg);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isValidTemperature(value, unit = "celsius", config = {}) {
+  return validateTemperature(value, unit, config).valid;
+}
+
+// src/roles/volume/validate.ts
+var VOLUME_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Volume cannot be negative"
+};
+function validateVolume(value, config = VOLUME_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number") {
+    return { valid: false, errors: ["Value must be a number"] };
+  }
+  if (!Number.isFinite(value)) {
+    return { valid: false, errors: ["Value must be finite"] };
+  }
+  if (config.min !== void 0 && value < config.min) {
+    const msg = config.minError ?? `Value must be at least ${config.min}`;
+    errors.push(msg);
+  }
+  if (config.max !== void 0 && value > config.max) {
+    const msg = config.maxError ?? `Value must be at most ${config.max}`;
+    errors.push(msg);
+  }
+  if (config.integer && !Number.isInteger(value)) {
+    errors.push("Value must be an integer");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isValidVolume(value, config = VOLUME_VALIDATION_CONFIG) {
+  return validateVolume(value, config).valid;
+}
+
+// src/roles/speed/validate.ts
+var SPEED_VALIDATION_CONFIG = {};
+function validateSpeed(value, config = SPEED_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number") {
+    return { valid: false, errors: ["Value must be a number"] };
+  }
+  if (!Number.isFinite(value)) {
+    return { valid: false, errors: ["Value must be finite"] };
+  }
+  if (config.min !== void 0 && value < config.min) {
+    const msg = config.minError ?? `Value must be at least ${config.min}`;
+    errors.push(msg);
+  }
+  if (config.max !== void 0 && value > config.max) {
+    const msg = config.maxError ?? `Value must be at most ${config.max}`;
+    errors.push(msg);
+  }
+  if (config.integer && !Number.isInteger(value)) {
+    errors.push("Value must be an integer");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isValidSpeed(value, config = SPEED_VALIDATION_CONFIG) {
+  return validateSpeed(value, config).valid;
+}
+
+// src/roles/energy/validate.ts
+var ENERGY_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Energy cannot be negative"
+};
+function validateEnergy(value, config = ENERGY_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number") {
+    return { valid: false, errors: ["Value must be a number"] };
+  }
+  if (!Number.isFinite(value)) {
+    return { valid: false, errors: ["Value must be finite"] };
+  }
+  if (config.min !== void 0 && value < config.min) {
+    const msg = config.minError ?? `Value must be at least ${config.min}`;
+    errors.push(msg);
+  }
+  if (config.max !== void 0 && value > config.max) {
+    const msg = config.maxError ?? `Value must be at most ${config.max}`;
+    errors.push(msg);
+  }
+  if (config.integer && !Number.isInteger(value)) {
+    errors.push("Value must be an integer");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isValidEnergy(value, config = ENERGY_VALIDATION_CONFIG) {
+  return validateEnergy(value, config).valid;
+}
+
+// src/roles/power/validate.ts
+var POWER_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Power cannot be negative",
+  allowNegative: false
+};
+function validatePower(value, config = POWER_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return {
+      valid: false,
+      errors: ["Value must be a finite number"]
+    };
+  }
+  const effectiveConfig = { ...POWER_VALIDATION_CONFIG, ...config };
+  if (!effectiveConfig.allowNegative && value < 0) {
+    errors.push(effectiveConfig.minError || "Power cannot be negative");
+  }
+  if (effectiveConfig.allowNegative && effectiveConfig.min !== void 0 && value < effectiveConfig.min) {
+    errors.push(effectiveConfig.minError || `Value must be at least ${effectiveConfig.min}`);
+  }
+  if (effectiveConfig.max !== void 0 && value > effectiveConfig.max) {
+    errors.push(effectiveConfig.maxError || `Value must be at most ${effectiveConfig.max}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function isValidPower(value, config) {
+  return validatePower(value, config).valid;
+}
+
+// src/roles/pressure/validate.ts
+var PRESSURE_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Pressure cannot be negative",
+  allowNegative: false
+};
+function validatePressure(value, config = PRESSURE_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return {
+      valid: false,
+      errors: ["Value must be a finite number"]
+    };
+  }
+  const effectiveConfig = { ...PRESSURE_VALIDATION_CONFIG, ...config };
+  if (!effectiveConfig.allowNegative && value < 0) {
+    errors.push(effectiveConfig.minError || "Pressure cannot be negative");
+  }
+  if (effectiveConfig.allowNegative && effectiveConfig.min !== void 0 && value < effectiveConfig.min) {
+    errors.push(effectiveConfig.minError || `Value must be at least ${effectiveConfig.min}`);
+  }
+  if (effectiveConfig.max !== void 0 && value > effectiveConfig.max) {
+    errors.push(effectiveConfig.maxError || `Value must be at most ${effectiveConfig.max}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function isValidPressure(value, config) {
+  return validatePressure(value, config).valid;
+}
+
+// src/roles/frequency/validate.ts
+var FREQUENCY_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Frequency cannot be negative",
+  allowNegative: false
+};
+function validateFrequency(value, config = FREQUENCY_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return {
+      valid: false,
+      errors: ["Value must be a finite number"]
+    };
+  }
+  const effectiveConfig = { ...FREQUENCY_VALIDATION_CONFIG, ...config };
+  if (!effectiveConfig.allowNegative && value < 0) {
+    errors.push(effectiveConfig.minError || "Frequency cannot be negative");
+  }
+  if (effectiveConfig.allowNegative && effectiveConfig.min !== void 0 && value < effectiveConfig.min) {
+    errors.push(effectiveConfig.minError || `Value must be at least ${effectiveConfig.min}`);
+  }
+  if (effectiveConfig.max !== void 0 && value > effectiveConfig.max) {
+    errors.push(effectiveConfig.maxError || `Value must be at most ${effectiveConfig.max}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function isValidFrequency(value, config) {
+  return validateFrequency(value, config).valid;
+}
+
+// src/roles/angle/validate.ts
+var ANGLE_VALIDATION_CONFIG = {};
+function validateAngle(value, config = ANGLE_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return {
+      valid: false,
+      errors: ["Value must be a finite number"]
+    };
+  }
+  if (config.min !== void 0 && value < config.min) {
+    errors.push(config.minError || `Value must be at least ${config.min}`);
+  }
+  if (config.max !== void 0 && value > config.max) {
+    errors.push(config.maxError || `Value must be at most ${config.max}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function isValidAngle(value, config) {
+  return validateAngle(value, config).valid;
+}
+
+// src/roles/time/validate.ts
+var TIME_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Time cannot be negative",
+  allowNegative: false
+};
+function validateTime(value, config = TIME_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return {
+      valid: false,
+      errors: ["Value must be a finite number"]
+    };
+  }
+  const effectiveConfig = { ...TIME_VALIDATION_CONFIG, ...config };
+  if (!effectiveConfig.allowNegative && value < 0) {
+    errors.push(effectiveConfig.minError || "Time cannot be negative");
+  }
+  if (effectiveConfig.allowNegative && effectiveConfig.min !== void 0 && value < effectiveConfig.min) {
+    errors.push(effectiveConfig.minError || `Value must be at least ${effectiveConfig.min}`);
+  }
+  if (effectiveConfig.max !== void 0 && value > effectiveConfig.max) {
+    errors.push(effectiveConfig.maxError || `Value must be at most ${effectiveConfig.max}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function isValidTime(value, config) {
+  return validateTime(value, config).valid;
+}
+
+// src/roles/digital/validate.ts
+var DIGITAL_VALIDATION_CONFIG = {
+  min: 0,
+  minError: "Digital storage cannot be negative",
+  allowNegative: false
+};
+function validateDigital(value, config = DIGITAL_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return {
+      valid: false,
+      errors: ["Value must be a finite number"]
+    };
+  }
+  const effectiveConfig = { ...DIGITAL_VALIDATION_CONFIG, ...config };
+  if (!effectiveConfig.allowNegative && value < 0) {
+    errors.push(effectiveConfig.minError || "Digital storage cannot be negative");
+  }
+  if (effectiveConfig.allowNegative && effectiveConfig.min !== void 0 && value < effectiveConfig.min) {
+    errors.push(effectiveConfig.minError || `Value must be at least ${effectiveConfig.min}`);
+  }
+  if (effectiveConfig.max !== void 0 && value > effectiveConfig.max) {
+    errors.push(effectiveConfig.maxError || `Value must be at most ${effectiveConfig.max}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function isValidDigital(value, config) {
+  return validateDigital(value, config).valid;
+}
+
+// src/roles/color/validate.ts
+var HEX_3_REGEX = /^#?[0-9a-f]{3}$/i;
+var HEX_4_REGEX = /^#?[0-9a-f]{4}$/i;
+var HEX_6_REGEX = /^#?[0-9a-f]{6}$/i;
+var HEX_8_REGEX = /^#?[0-9a-f]{8}$/i;
+var RGB_STRING_REGEX = /^rgba?\s*\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(,\s*[\d.]+\s*)?\)$/i;
+var HSL_STRING_REGEX = /^hsla?\s*\(\s*[\d.]+\s*,\s*[\d.]+%?\s*,\s*[\d.]+%?\s*(,\s*[\d.]+\s*)?\)$/i;
+function validateHex(value) {
+  const errors = [];
+  if (typeof value !== "string") {
+    errors.push("Hex color must be a string");
+    return { valid: false, errors };
+  }
+  const trimmed = value.trim();
+  if (!HEX_3_REGEX.test(trimmed) && !HEX_4_REGEX.test(trimmed) && !HEX_6_REGEX.test(trimmed) && !HEX_8_REGEX.test(trimmed)) {
+    errors.push("Invalid hex color format");
+    return { valid: false, errors };
+  }
+  return { valid: true, errors: [] };
+}
+function validateRgbObject(value) {
+  const errors = [];
+  if (typeof value !== "object" || value === null) {
+    errors.push("RGB object must be an object");
+    return { valid: false, errors };
+  }
+  const obj = value;
+  if (typeof obj.r !== "number") {
+    errors.push("RGB object must have numeric 'r' property");
+  }
+  if (typeof obj.g !== "number") {
+    errors.push("RGB object must have numeric 'g' property");
+  }
+  if (typeof obj.b !== "number") {
+    errors.push("RGB object must have numeric 'b' property");
+  }
+  if (errors.length > 0) {
+    return { valid: false, errors };
+  }
+  const { r, g, b, a } = obj;
+  if (r < 0 || r > 255) {
+    errors.push("RGB 'r' must be between 0 and 255");
+  }
+  if (g < 0 || g > 255) {
+    errors.push("RGB 'g' must be between 0 and 255");
+  }
+  if (b < 0 || b > 255) {
+    errors.push("RGB 'b' must be between 0 and 255");
+  }
+  if (a !== void 0 && (typeof a !== "number" || a < 0 || a > 1)) {
+    errors.push("RGB 'a' must be a number between 0 and 1");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateRgbString(value) {
+  const errors = [];
+  if (typeof value !== "string") {
+    errors.push("RGB string must be a string");
+    return { valid: false, errors };
+  }
+  const trimmed = value.trim();
+  if (!RGB_STRING_REGEX.test(trimmed)) {
+    errors.push("Invalid RGB string format");
+    return { valid: false, errors };
+  }
+  return { valid: true, errors: [] };
+}
+function validateHslObject(value) {
+  const errors = [];
+  if (typeof value !== "object" || value === null) {
+    errors.push("HSL object must be an object");
+    return { valid: false, errors };
+  }
+  const obj = value;
+  if (typeof obj.h !== "number") {
+    errors.push("HSL object must have numeric 'h' property");
+  }
+  if (typeof obj.s !== "number") {
+    errors.push("HSL object must have numeric 's' property");
+  }
+  if (typeof obj.l !== "number") {
+    errors.push("HSL object must have numeric 'l' property");
+  }
+  if (errors.length > 0) {
+    return { valid: false, errors };
+  }
+  const { h, s, l, a } = obj;
+  if (h < 0 || h > 360) {
+    errors.push("HSL 'h' must be between 0 and 360");
+  }
+  if (s < 0 || s > 100) {
+    errors.push("HSL 's' must be between 0 and 100");
+  }
+  if (l < 0 || l > 100) {
+    errors.push("HSL 'l' must be between 0 and 100");
+  }
+  if (a !== void 0 && (typeof a !== "number" || a < 0 || a > 1)) {
+    errors.push("HSL 'a' must be a number between 0 and 1");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validateHslString(value) {
+  const errors = [];
+  if (typeof value !== "string") {
+    errors.push("HSL string must be a string");
+    return { valid: false, errors };
+  }
+  const trimmed = value.trim();
+  if (!HSL_STRING_REGEX.test(trimmed)) {
+    errors.push("Invalid HSL string format");
+    return { valid: false, errors };
+  }
+  return { valid: true, errors: [] };
+}
+function validateColor(variant, value) {
+  switch (variant) {
+    case "hex":
+      return validateHex(value);
+    case "rgb_object":
+      return validateRgbObject(value);
+    case "rgb_string":
+      return validateRgbString(value);
+    case "hsl_object":
+      return validateHslObject(value);
+    case "hsl_string":
+      return validateHslString(value);
+    default:
+      return { valid: false, errors: [`Unknown color variant: ${variant}`] };
+  }
+}
+function isValidColorVariant(variant, value) {
+  return validateColor(variant, value).valid;
+}
+
+// src/roles/date/validate.ts
+var ISO_DATE_TIME_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+var ISO_DATE_ONLY_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+function validateIso(value) {
+  const errors = [];
+  if (typeof value !== "string") {
+    errors.push("ISO date must be a string");
+    return { valid: false, errors };
+  }
+  const trimmed = value.trim();
+  if (!ISO_DATE_TIME_REGEX.test(trimmed) && !ISO_DATE_ONLY_REGEX.test(trimmed)) {
+    errors.push("Invalid ISO 8601 format");
+    return { valid: false, errors };
+  }
+  const date = new Date(trimmed);
+  if (isNaN(date.getTime())) {
+    errors.push("Invalid date value");
+    return { valid: false, errors };
+  }
+  return { valid: true, errors: [] };
+}
+function validateTimestamp(value) {
+  const errors = [];
+  if (typeof value !== "number") {
+    errors.push("Timestamp must be a number");
+    return { valid: false, errors };
+  }
+  if (!Number.isFinite(value)) {
+    errors.push("Timestamp must be a finite number");
+    return { valid: false, errors };
+  }
+  if (!Number.isInteger(value)) {
+    errors.push("Timestamp must be an integer");
+    return { valid: false, errors };
+  }
+  return { valid: true, errors: [] };
+}
+function validateEpoch(value) {
+  const errors = [];
+  if (typeof value !== "number") {
+    errors.push("Epoch must be a number");
+    return { valid: false, errors };
+  }
+  if (!Number.isFinite(value)) {
+    errors.push("Epoch must be a finite number");
+    return { valid: false, errors };
+  }
+  if (!Number.isInteger(value)) {
+    errors.push("Epoch must be an integer");
+    return { valid: false, errors };
+  }
+  return { valid: true, errors: [] };
+}
+function validateDate(variant, value) {
+  switch (variant) {
+    case "iso":
+      return validateIso(value);
+    case "timestamp":
+      return validateTimestamp(value);
+    case "epoch":
+      return validateEpoch(value);
+    default:
+      return { valid: false, errors: [`Unknown date variant: ${variant}`] };
+  }
+}
+function isValidDate(variant, value) {
+  return validateDate(variant, value).valid;
+}
+
+// src/roles/currency/validate.ts
+var CURRENCY_VALIDATION_CONFIG = {
+  min: 0,
+  allowNegative: false,
+  minError: "Currency value cannot be negative"
+};
+function validateCurrency(value, config = CURRENCY_VALIDATION_CONFIG) {
+  const errors = [];
+  if (typeof value !== "number") {
+    return { valid: false, errors: ["Value must be a number"] };
+  }
+  if (!Number.isFinite(value)) {
+    return { valid: false, errors: ["Value must be finite"] };
+  }
+  if (!config.allowNegative && value < 0) {
+    const msg = config.minError ?? "Currency value cannot be negative";
+    errors.push(msg);
+  }
+  if (config.allowNegative && config.min !== void 0 && value < config.min) {
+    const msg = config.minError ?? `Value must be at least ${config.min}`;
+    errors.push(msg);
+  }
+  if (config.max !== void 0 && value > config.max) {
+    const msg = config.maxError ?? `Value must be at most ${config.max}`;
+    errors.push(msg);
+  }
+  if (config.decimals !== void 0) {
+    const decimalPlaces = countDecimalPlaces(value);
+    if (decimalPlaces > config.decimals) {
+      errors.push(
+        `Value has too many decimal places (max: ${config.decimals})`
+      );
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isValidCurrency(value, config = CURRENCY_VALIDATION_CONFIG) {
+  return validateCurrency(value, config).valid;
+}
+function countDecimalPlaces(value) {
+  if (Number.isInteger(value)) {
+    return 0;
+  }
+  const str = String(value);
+  const decimalIndex = str.indexOf(".");
+  if (decimalIndex === -1) {
+    return 0;
+  }
+  return str.length - decimalIndex - 1;
+}
+
+export { AREA_VALIDATION_CONFIG, CURRENCY_VALIDATION_CONFIG, DIGITAL_VALIDATION_CONFIG, ENERGY_VALIDATION_CONFIG, FREQUENCY_VALIDATION_CONFIG, LENGTH_VALIDATION_CONFIG, MASS_VALIDATION_CONFIG, POWER_VALIDATION_CONFIG, PRESSURE_VALIDATION_CONFIG, TIME_VALIDATION_CONFIG, VOLUME_VALIDATION_CONFIG, isValidAngle, isValidArea, isValidColorVariant, isValidCurrency, isValidDate, isValidDigital, isValidEnergy, isValidFrequency, isValidLength, isValidMass, isValidPower, isValidPressure, isValidSpeed, isValidTemperature, isValidTime, isValidVolume, validateAngle, validateArea, validateColor, validateCurrency, validateDate, validateDigital, validateEnergy, validateFrequency, validateLength, validateMass, validatePower, validatePressure, validateSpeed, validateTemperature, validateTime, validateVolume };
+//# sourceMappingURL=validate.mjs.map
+//# sourceMappingURL=validate.mjs.map