@attrx/role-morphic 0.1.0

package/dist/index.js

@@ -0,0 +1,4680 @@
+'use strict';
+
+// src/RoleMorphic.ts
+var RoleMorphic = class {
+  constructor() {
+    /** Registry de roles */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.roles = /* @__PURE__ */ new Map();
+    /** Registry de morphers (transformações cross-role) */
+    this.morphers = /* @__PURE__ */ new Map();
+  }
+  // ===========================================================================
+  // ROLE MANAGEMENT
+  // ===========================================================================
+  /**
+   * Registra uma nova role
+   */
+  register(roleId, spec) {
+    if (this.roles.has(roleId)) {
+      throw new Error(`Role "${roleId}" is already registered`);
+    }
+    if (!spec.variants[spec.base]) {
+      throw new Error(
+        `Base variant "${spec.base}" not found in role "${roleId}" variants`
+      );
+    }
+    this.roles.set(roleId, spec);
+    return this;
+  }
+  /**
+   * Remove uma role registrada
+   */
+  unregister(roleId) {
+    return this.roles.delete(roleId);
+  }
+  /**
+   * Verifica se uma role está registrada
+   */
+  hasRole(roleId) {
+    return this.roles.has(roleId);
+  }
+  /**
+   * Obtém a spec de uma role
+   */
+  getRole(roleId) {
+    return this.roles.get(roleId);
+  }
+  /**
+   * Lista todas as roles registradas
+   */
+  listRoles() {
+    return Array.from(this.roles.keys());
+  }
+  // ===========================================================================
+  // VARIANT UTILITIES
+  // ===========================================================================
+  /**
+   * Parseia um identificador de variante
+   *
+   * "color:rgb:object" => { role: "color", variant: "rgb:object" }
+   * "area:m2" => { role: "area", variant: "m2" }
+   */
+  parseVariantId(fullId) {
+    const colonIndex = fullId.indexOf(":");
+    if (colonIndex === -1) {
+      throw new Error(
+        `Invalid variant identifier "${fullId}". Expected format: "role:variant"`
+      );
+    }
+    return {
+      role: fullId.slice(0, colonIndex),
+      variant: fullId.slice(colonIndex + 1)
+    };
+  }
+  /**
+   * Verifica se uma variante existe
+   */
+  hasVariant(fullId) {
+    try {
+      const { role, variant } = this.parseVariantId(fullId);
+      const spec = this.roles.get(role);
+      return spec ? variant in spec.variants : false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Obtém a spec de uma variante
+   */
+  getVariant(fullId) {
+    const { role, variant } = this.parseVariantId(fullId);
+    const spec = this.roles.get(role);
+    return spec?.variants[variant];
+  }
+  /**
+   * Lista todas as variantes de uma role
+   */
+  listVariants(roleId) {
+    const spec = this.roles.get(roleId);
+    if (!spec) return [];
+    return Object.keys(spec.variants);
+  }
+  /**
+   * Lista variantes para as quais uma variante pode converter
+   */
+  getConvertibleVariants(fullId) {
+    const { role, variant } = this.parseVariantId(fullId);
+    const spec = this.roles.get(role);
+    if (!spec) return [];
+    return Object.keys(spec.variants).filter((v) => v !== variant).map((v) => `${role}:${v}`);
+  }
+  // ===========================================================================
+  // CONVERSION
+  // ===========================================================================
+  /**
+   * Converte um valor de uma variante para outra (mesma role)
+   *
+   * @param from - Identificador da variante de origem (ex: "color:hex")
+   * @param to - Identificador da variante de destino (ex: "color:rgb:object")
+   * @param value - Valor a converter
+   * @returns Valor convertido
+   * @throws Error se a conversão não for possível
+   */
+  convert(from, to, value) {
+    const fromParsed = this.parseVariantId(from);
+    const toParsed = this.parseVariantId(to);
+    if (fromParsed.role !== toParsed.role) {
+      throw new Error(
+        `Cannot convert between different roles ("${fromParsed.role}" -> "${toParsed.role}"). Use morph() for cross-role transformations.`
+      );
+    }
+    const roleSpec = this.roles.get(fromParsed.role);
+    if (!roleSpec) {
+      throw new Error(`Role "${fromParsed.role}" is not registered`);
+    }
+    const fromVariant = roleSpec.variants[fromParsed.variant];
+    const toVariant = roleSpec.variants[toParsed.variant];
+    if (!fromVariant) {
+      throw new Error(
+        `Variant "${fromParsed.variant}" not found in role "${fromParsed.role}"`
+      );
+    }
+    if (!toVariant) {
+      throw new Error(
+        `Variant "${toParsed.variant}" not found in role "${fromParsed.role}"`
+      );
+    }
+    if (fromParsed.variant === toParsed.variant) {
+      return value;
+    }
+    const baseVariant = roleSpec.base;
+    const baseValue = fromParsed.variant === baseVariant ? value : fromVariant.toBase(value);
+    if (toParsed.variant === baseVariant) {
+      return baseValue;
+    }
+    return toVariant.fromBase(baseValue);
+  }
+  /**
+   * Tenta converter, retornando Result ao invés de throw
+   */
+  tryConvert(from, to, value) {
+    try {
+      const result = this.convert(from, to, value);
+      return { ok: true, value: result };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  // ===========================================================================
+  // SAFE CONVERSION (with reversibility check)
+  // ===========================================================================
+  /**
+   * Verifica se uma conversão é reversível (sem perda de dados)
+   */
+  isReversible(from, to, value) {
+    try {
+      const converted = this.convert(from, to, value);
+      const reconverted = this.convert(to, from, converted);
+      return JSON.stringify(value) === JSON.stringify(reconverted);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Retorna detalhes sobre a reversibilidade de uma conversão
+   */
+  checkReversibility(from, to, value) {
+    try {
+      const converted = this.convert(from, to, value);
+      const reconverted = this.convert(to, from, converted);
+      const reversible = JSON.stringify(value) === JSON.stringify(reconverted);
+      return {
+        reversible,
+        original: value,
+        converted,
+        reconverted
+      };
+    } catch (error) {
+      return {
+        reversible: false,
+        original: value,
+        converted: null,
+        reconverted: null
+      };
+    }
+  }
+  /**
+   * Converte apenas se a conversão for reversível
+   *
+   * @throws Error se a conversão causar perda de dados
+   */
+  convertSafe(from, to, value) {
+    const result = this.checkReversibility(from, to, value);
+    if (!result.reversible) {
+      throw new Error(
+        `Conversion from "${from}" to "${to}" is not reversible. Original: ${JSON.stringify(value)}, Reconverted: ${JSON.stringify(result.reconverted)}`
+      );
+    }
+    return result.converted;
+  }
+  // ===========================================================================
+  // MORPHERS (cross-role transformations)
+  // ===========================================================================
+  /**
+   * Registra um morpher para transformação entre roles diferentes
+   */
+  registerMorpher(spec) {
+    const key = `${spec.from}->${spec.to}`;
+    if (this.morphers.has(key)) {
+      throw new Error(`Morpher "${key}" is already registered`);
+    }
+    this.morphers.set(key, spec.transform);
+    return this;
+  }
+  /**
+   * Remove um morpher
+   */
+  unregisterMorpher(from, to) {
+    return this.morphers.delete(`${from}->${to}`);
+  }
+  /**
+   * Verifica se existe um morpher para a transformação
+   */
+  hasMorpher(from, to) {
+    return this.morphers.has(`${from}->${to}`);
+  }
+  /**
+   * Lista morphers disponíveis a partir de uma variante
+   */
+  getMorphersFrom(from) {
+    const prefix = `${from}->`;
+    const targets = [];
+    for (const key of this.morphers.keys()) {
+      if (key.startsWith(prefix)) {
+        targets.push(key.slice(prefix.length));
+      }
+    }
+    return targets;
+  }
+  /**
+   * Transforma um valor de uma role para outra usando um morpher registrado
+   */
+  morph(from, to, value) {
+    const key = `${from}->${to}`;
+    const morpher = this.morphers.get(key);
+    if (!morpher) {
+      throw new Error(
+        `No morpher registered for "${from}" -> "${to}". Register one with registerMorpher().`
+      );
+    }
+    return morpher(value);
+  }
+  /**
+   * Tenta transformar, retornando Result ao invés de throw
+   */
+  tryMorph(from, to, value) {
+    try {
+      const result = this.morph(from, to, value);
+      return { ok: true, value: result };
+    } catch (error) {
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  // ===========================================================================
+  // CONVENIENCE METHODS
+  // ===========================================================================
+  /**
+   * Converte ou transforma automaticamente
+   *
+   * - Se mesma role: usa convert()
+   * - Se roles diferentes: usa morph()
+   */
+  auto(from, to, value) {
+    const fromParsed = this.parseVariantId(from);
+    const toParsed = this.parseVariantId(to);
+    if (fromParsed.role === toParsed.role) {
+      return this.convert(from, to, value);
+    }
+    return this.morph(from, to, value);
+  }
+  /**
+   * Converte um valor para a variante base da sua role
+   */
+  toBase(fullId, value) {
+    const { role, variant } = this.parseVariantId(fullId);
+    const spec = this.roles.get(role);
+    if (!spec) {
+      throw new Error(`Role "${role}" is not registered`);
+    }
+    if (variant === spec.base) {
+      return value;
+    }
+    const variantSpec = spec.variants[variant];
+    if (!variantSpec) {
+      throw new Error(`Variant "${variant}" not found in role "${role}"`);
+    }
+    return variantSpec.toBase(value);
+  }
+  /**
+   * Converte um valor da base para uma variante específica
+   */
+  fromBase(fullId, baseValue) {
+    const { role, variant } = this.parseVariantId(fullId);
+    const spec = this.roles.get(role);
+    if (!spec) {
+      throw new Error(`Role "${role}" is not registered`);
+    }
+    if (variant === spec.base) {
+      return baseValue;
+    }
+    const variantSpec = spec.variants[variant];
+    if (!variantSpec) {
+      throw new Error(`Variant "${variant}" not found in role "${role}"`);
+    }
+    return variantSpec.fromBase(baseValue);
+  }
+};
+
+// src/contracts/IVariant.ts
+var BaseVariant = class {
+  /**
+   * Implementação padrão de tryCast usando cast
+   */
+  tryCast(input) {
+    const result = this.cast(input);
+    if (result === null) {
+      return {
+        ok: false,
+        error: `Cannot cast "${String(input)}" to ${this.name}`
+      };
+    }
+    return { ok: true, value: result };
+  }
+  /**
+   * Implementação padrão de isValid usando validate
+   */
+  isValid(value) {
+    return this.validate(value).valid;
+  }
+};
+
+// src/contracts/SimpleRole.ts
+var SimpleRole = class {
+  constructor() {
+    // ===========================================================================
+    // OPTIONAL PROPERTIES (subclasses podem sobrescrever)
+    // ===========================================================================
+    /** Aliases para reconhecimento no cast (ex: "ha" → "hectare") */
+    this.aliases = {};
+    /** Regras de validação */
+    this.validation = {};
+  }
+  // ===========================================================================
+  // INTROSPECTION
+  // ===========================================================================
+  getVariants() {
+    return Object.keys(this.units);
+  }
+  hasVariant(variant) {
+    return variant in this.units;
+  }
+  // ===========================================================================
+  // CONVERT (Pilar 1)
+  // ===========================================================================
+  convert(from, to, value) {
+    const numValue = value;
+    if (from === to) {
+      return value;
+    }
+    const baseValue = this.toBase(from, numValue);
+    return this.fromBase(to, baseValue);
+  }
+  tryConvert(from, to, value) {
+    try {
+      if (!this.hasVariant(from)) {
+        return { ok: false, error: `Unknown variant: ${from}` };
+      }
+      if (!this.hasVariant(to)) {
+        return { ok: false, error: `Unknown variant: ${to}` };
+      }
+      const result = this.convert(from, to, value);
+      return { ok: true, value: result };
+    } catch (err) {
+      return { ok: false, error: String(err) };
+    }
+  }
+  toBase(variant, value) {
+    const numValue = value;
+    const unit = this.units[variant];
+    if (!unit) {
+      throw new Error(`Unknown variant: ${variant}`);
+    }
+    if (unit.toBase) {
+      return unit.toBase(numValue);
+    }
+    return numValue * (unit.factor ?? 1);
+  }
+  fromBase(variant, baseValue) {
+    const unit = this.units[variant];
+    if (!unit) {
+      throw new Error(`Unknown variant: ${variant}`);
+    }
+    if (unit.fromBase) {
+      return unit.fromBase(baseValue);
+    }
+    return baseValue / (unit.factor ?? 1);
+  }
+  // ===========================================================================
+  // CAST (Pilar 2)
+  // ===========================================================================
+  cast(variant, input) {
+    if (typeof input === "number") {
+      return Number.isFinite(input) ? input : null;
+    }
+    if (typeof input === "string") {
+      const parsed = this.parseString(input, variant);
+      return parsed !== null ? parsed : null;
+    }
+    return null;
+  }
+  tryCast(variant, input) {
+    const result = this.cast(variant, input);
+    if (result === null) {
+      return {
+        ok: false,
+        error: `Cannot cast "${String(input)}" to ${this.name}:${variant}`
+      };
+    }
+    return { ok: true, value: result };
+  }
+  /**
+   * Parseia string para número, detectando unidade se presente.
+   * Subclasses podem sobrescrever para lógica customizada.
+   */
+  parseString(input, targetVariant) {
+    const trimmed = input.trim().toLowerCase();
+    const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+    if (!match) {
+      return null;
+    }
+    let [, numStr, unitStr] = match;
+    const numValue = this.parseNumber(numStr);
+    if (numValue === null) {
+      return null;
+    }
+    unitStr = unitStr.trim();
+    if (unitStr) {
+      const detectedUnit = this.detectUnit(unitStr);
+      if (detectedUnit && detectedUnit !== targetVariant) {
+        return this.convert(detectedUnit, targetVariant, numValue);
+      }
+    }
+    return numValue;
+  }
+  /**
+   * Parseia string numérica considerando formatos brasileiro e americano
+   */
+  parseNumber(numStr) {
+    numStr = numStr.replace(/\s/g, "");
+    const lastComma = numStr.lastIndexOf(",");
+    const lastDot = numStr.lastIndexOf(".");
+    const hasComma = lastComma !== -1;
+    const hasDot = lastDot !== -1;
+    if (hasComma && hasDot) {
+      if (lastComma > lastDot) {
+        numStr = numStr.replace(/\./g, "").replace(",", ".");
+      } else {
+        numStr = numStr.replace(/,/g, "");
+      }
+    } else if (hasComma && !hasDot) {
+      const afterComma = numStr.split(",").slice(1);
+      const isThousandSep = afterComma.every((part) => part.length === 3);
+      if (isThousandSep) {
+        numStr = numStr.replace(/,/g, "");
+      } else {
+        numStr = numStr.replace(",", ".");
+      }
+    } else if (!hasComma && hasDot) {
+      const afterDot = numStr.split(".").slice(1);
+      if (afterDot.length > 1) {
+        numStr = numStr.replace(/\./g, "");
+      }
+    }
+    const value = parseFloat(numStr);
+    return isNaN(value) ? null : value;
+  }
+  /**
+   * Detecta unidade a partir de string (símbolo ou alias)
+   */
+  detectUnit(unitStr) {
+    const normalized = unitStr.toLowerCase().trim();
+    if (normalized in this.aliases) {
+      return this.aliases[normalized];
+    }
+    for (const [variant, config] of Object.entries(this.units)) {
+      if (config.symbol.toLowerCase() === normalized || config.singular?.toLowerCase() === normalized || config.plural?.toLowerCase() === normalized || variant.toLowerCase() === normalized) {
+        return variant;
+      }
+    }
+    return null;
+  }
+  // ===========================================================================
+  // VALIDATE (Pilar 3)
+  // ===========================================================================
+  validate(variant, value) {
+    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 (this.validation.min !== void 0 && value < this.validation.min) {
+      const msg = this.validation.minError ?? `Value must be at least ${this.validation.min}`;
+      errors.push(msg);
+    }
+    if (this.validation.max !== void 0 && value > this.validation.max) {
+      const msg = this.validation.maxError ?? `Value must be at most ${this.validation.max}`;
+      errors.push(msg);
+    }
+    if (this.validation.integer && !Number.isInteger(value)) {
+      errors.push("Value must be an integer");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  isValid(variant, value) {
+    return this.validate(variant, value).valid;
+  }
+  // ===========================================================================
+  // FORMAT (Pilar 4)
+  // ===========================================================================
+  format(variant, value, options = {}) {
+    const { decimals = 2, verbose = false, locale } = options;
+    const unit = this.units[variant];
+    if (!unit) {
+      throw new Error(`Unknown variant: ${variant}`);
+    }
+    const numValue = value;
+    let formattedValue;
+    if (locale) {
+      formattedValue = numValue.toLocaleString(locale, {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: decimals
+      });
+    } else {
+      formattedValue = Number(numValue.toFixed(decimals)).toString();
+    }
+    const separator = unit.noSpace ? "" : " ";
+    if (verbose) {
+      const name = numValue === 1 ? unit.singular : unit.plural;
+      return `${formattedValue} ${name || unit.symbol}`;
+    }
+    return `${formattedValue}${separator}${unit.symbol}`;
+  }
+  // ===========================================================================
+  // COMPATIBILITY
+  // ===========================================================================
+  toSpec() {
+    const variants = {};
+    for (const [name, config] of Object.entries(this.units)) {
+      const factor = config.factor ?? 1;
+      const toBaseFn = config.toBase ? (v) => config.toBase(v) : (v) => v * factor;
+      const fromBaseFn = config.fromBase ? (v) => config.fromBase(v) : (v) => v / factor;
+      variants[name] = {
+        type: "number",
+        toBase: toBaseFn,
+        fromBase: fromBaseFn,
+        cast: (input) => this.cast(name, input),
+        validate: {
+          min: this.validation.min,
+          max: this.validation.max,
+          integer: this.validation.integer,
+          custom: (v) => {
+            const result = this.validate(name, v);
+            return result.valid ? null : result.errors[0];
+          }
+        },
+        format: {
+          symbol: config.symbol,
+          singular: config.singular,
+          plural: config.plural
+        }
+      };
+    }
+    return {
+      base: this.base,
+      variants
+    };
+  }
+};
+
+// src/contracts/ComplexRole.ts
+var ComplexRole = class {
+  constructor() {
+    // ===========================================================================
+    // VARIANTS
+    // ===========================================================================
+    /** Cache das variantes */
+    this._variants = null;
+  }
+  /**
+   * Retorna mapa de variantes (lazy initialization)
+   */
+  get variants() {
+    if (!this._variants) {
+      this._variants = new Map(Object.entries(this.createVariants()));
+    }
+    return this._variants;
+  }
+  /**
+   * Retorna uma variante específica
+   */
+  getVariant(name) {
+    const variant = this.variants.get(name);
+    if (!variant) {
+      throw new Error(`Unknown variant: ${name}`);
+    }
+    return variant;
+  }
+  // ===========================================================================
+  // INTROSPECTION
+  // ===========================================================================
+  getVariants() {
+    return Array.from(this.variants.keys());
+  }
+  hasVariant(variant) {
+    return this.variants.has(variant);
+  }
+  // ===========================================================================
+  // CONVERT (Pilar 1)
+  // ===========================================================================
+  convert(from, to, value) {
+    if (from === to) {
+      return value;
+    }
+    const fromVariant = this.getVariant(from);
+    const toVariant = this.getVariant(to);
+    const baseValue = fromVariant.toBase(value);
+    return toVariant.fromBase(baseValue);
+  }
+  tryConvert(from, to, value) {
+    try {
+      if (!this.hasVariant(from)) {
+        return { ok: false, error: `Unknown variant: ${from}` };
+      }
+      if (!this.hasVariant(to)) {
+        return { ok: false, error: `Unknown variant: ${to}` };
+      }
+      const result = this.convert(from, to, value);
+      return { ok: true, value: result };
+    } catch (err) {
+      return { ok: false, error: String(err) };
+    }
+  }
+  toBase(variant, value) {
+    return this.getVariant(variant).toBase(value);
+  }
+  fromBase(variant, baseValue) {
+    return this.getVariant(variant).fromBase(baseValue);
+  }
+  // ===========================================================================
+  // CAST (Pilar 2)
+  // ===========================================================================
+  cast(variant, input) {
+    return this.getVariant(variant).cast(input);
+  }
+  tryCast(variant, input) {
+    const result = this.cast(variant, input);
+    if (result === null) {
+      return {
+        ok: false,
+        error: `Cannot cast "${String(input)}" to ${this.name}:${variant}`
+      };
+    }
+    return { ok: true, value: result };
+  }
+  // ===========================================================================
+  // VALIDATE (Pilar 3)
+  // ===========================================================================
+  validate(variant, value) {
+    return this.getVariant(variant).validate(value);
+  }
+  isValid(variant, value) {
+    return this.validate(variant, value).valid;
+  }
+  // ===========================================================================
+  // FORMAT (Pilar 4)
+  // ===========================================================================
+  format(variant, value, options) {
+    return this.getVariant(variant).format(value, options);
+  }
+  // ===========================================================================
+  // COMPATIBILITY
+  // ===========================================================================
+  toSpec() {
+    const variants = {};
+    for (const [name, variant] of this.variants.entries()) {
+      variants[name] = {
+        type: variant.type,
+        toBase: (v) => variant.toBase(v),
+        fromBase: (v) => variant.fromBase(v),
+        cast: (input) => variant.cast(input),
+        validate: {
+          custom: (v) => {
+            const result = variant.validate(v);
+            return result.valid ? null : result.errors[0];
+          }
+        },
+        format: {
+          symbol: name,
+          formatter: (v, opts) => variant.format(v, opts)
+        }
+      };
+    }
+    return {
+      base: this.base,
+      variants
+    };
+  }
+};
+
+// src/roles/area/constants.ts
+var AREA_UNITS = {
+  // SI Units (todos exatos)
+  square_kilometer: {
+    factor: 1e6,
+    symbol: "km\xB2",
+    singular: "square kilometer",
+    plural: "square kilometers"
+  },
+  hectare: {
+    factor: 1e4,
+    symbol: "ha",
+    singular: "hectare",
+    plural: "hectares"
+  },
+  are: {
+    factor: 100,
+    symbol: "a",
+    singular: "are",
+    plural: "ares"
+  },
+  square_meter: {
+    factor: 1,
+    symbol: "m\xB2",
+    singular: "square meter",
+    plural: "square meters"
+  },
+  square_decimeter: {
+    factor: 0.01,
+    symbol: "dm\xB2",
+    singular: "square decimeter",
+    plural: "square decimeters"
+  },
+  square_centimeter: {
+    factor: 1e-4,
+    symbol: "cm\xB2",
+    singular: "square centimeter",
+    plural: "square centimeters"
+  },
+  square_millimeter: {
+    factor: 1e-6,
+    symbol: "mm\xB2",
+    singular: "square millimeter",
+    plural: "square millimeters"
+  },
+  // Imperial/US (todos exatos, derivados de comprimento² desde 1959)
+  square_mile: {
+    factor: 2589988110336e-6,
+    symbol: "mi\xB2",
+    singular: "square mile",
+    plural: "square miles"
+  },
+  acre: {
+    factor: 4046.8564224,
+    symbol: "ac",
+    singular: "acre",
+    plural: "acres"
+  },
+  square_yard: {
+    factor: 0.83612736,
+    symbol: "yd\xB2",
+    singular: "square yard",
+    plural: "square yards"
+  },
+  square_foot: {
+    factor: 0.09290304,
+    symbol: "ft\xB2",
+    singular: "square foot",
+    plural: "square feet"
+  },
+  square_inch: {
+    factor: 64516e-8,
+    symbol: "in\xB2",
+    singular: "square inch",
+    plural: "square inches"
+  }
+};
+var AREA_ALIASES = {
+  // square_kilometer
+  "km\xB2": "square_kilometer",
+  km2: "square_kilometer",
+  "sq km": "square_kilometer",
+  "square kilometer": "square_kilometer",
+  "square kilometers": "square_kilometer",
+  "quil\xF4metro quadrado": "square_kilometer",
+  "quil\xF4metros quadrados": "square_kilometer",
+  // hectare
+  ha: "hectare",
+  hectare: "hectare",
+  hectares: "hectare",
+  // are
+  a: "are",
+  are: "are",
+  ares: "are",
+  // square_meter
+  "m\xB2": "square_meter",
+  m2: "square_meter",
+  "sq m": "square_meter",
+  "square meter": "square_meter",
+  "square meters": "square_meter",
+  "metro quadrado": "square_meter",
+  "metros quadrados": "square_meter",
+  // square_decimeter
+  "dm\xB2": "square_decimeter",
+  dm2: "square_decimeter",
+  // square_centimeter
+  "cm\xB2": "square_centimeter",
+  cm2: "square_centimeter",
+  "sq cm": "square_centimeter",
+  // square_millimeter
+  "mm\xB2": "square_millimeter",
+  mm2: "square_millimeter",
+  "sq mm": "square_millimeter",
+  // square_mile
+  "mi\xB2": "square_mile",
+  mi2: "square_mile",
+  "sq mi": "square_mile",
+  "square mile": "square_mile",
+  "square miles": "square_mile",
+  // acre
+  ac: "acre",
+  acre: "acre",
+  acres: "acre",
+  // square_yard
+  "yd\xB2": "square_yard",
+  yd2: "square_yard",
+  "sq yd": "square_yard",
+  "square yard": "square_yard",
+  "square yards": "square_yard",
+  // square_foot
+  "ft\xB2": "square_foot",
+  ft2: "square_foot",
+  "sq ft": "square_foot",
+  "square foot": "square_foot",
+  "square feet": "square_foot",
+  // square_inch
+  "in\xB2": "square_inch",
+  in2: "square_inch",
+  "sq in": "square_inch",
+  "square inch": "square_inch",
+  "square inches": "square_inch"
+};
+Object.fromEntries(
+  Object.entries(AREA_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/area/AreaRole.ts
+var AreaRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "area";
+    this.base = "square_meter";
+    this.units = AREA_UNITS;
+    this.aliases = AREA_ALIASES;
+    this.validation = {
+      min: 0,
+      minError: "Area cannot be negative"
+    };
+  }
+};
+var areaRole = new AreaRole();
+
+// src/roles/length/constants.ts
+var LENGTH_UNITS = {
+  // SI Units (todos exatos)
+  kilometer: {
+    factor: 1e3,
+    symbol: "km",
+    singular: "kilometer",
+    plural: "kilometers"
+  },
+  hectometer: {
+    factor: 100,
+    symbol: "hm",
+    singular: "hectometer",
+    plural: "hectometers"
+  },
+  decameter: {
+    factor: 10,
+    symbol: "dam",
+    singular: "decameter",
+    plural: "decameters"
+  },
+  meter: {
+    factor: 1,
+    symbol: "m",
+    singular: "meter",
+    plural: "meters"
+  },
+  decimeter: {
+    factor: 0.1,
+    symbol: "dm",
+    singular: "decimeter",
+    plural: "decimeters"
+  },
+  centimeter: {
+    factor: 0.01,
+    symbol: "cm",
+    singular: "centimeter",
+    plural: "centimeters"
+  },
+  millimeter: {
+    factor: 1e-3,
+    symbol: "mm",
+    singular: "millimeter",
+    plural: "millimeters"
+  },
+  micrometer: {
+    factor: 1e-6,
+    symbol: "\u03BCm",
+    singular: "micrometer",
+    plural: "micrometers"
+  },
+  nanometer: {
+    factor: 1e-9,
+    symbol: "nm",
+    singular: "nanometer",
+    plural: "nanometers"
+  },
+  // Imperial/US (exatos desde 1959)
+  inch: {
+    factor: 0.0254,
+    symbol: "in",
+    singular: "inch",
+    plural: "inches"
+  },
+  foot: {
+    factor: 0.3048,
+    symbol: "ft",
+    singular: "foot",
+    plural: "feet"
+  },
+  yard: {
+    factor: 0.9144,
+    symbol: "yd",
+    singular: "yard",
+    plural: "yards"
+  },
+  mile: {
+    factor: 1609.344,
+    symbol: "mi",
+    singular: "mile",
+    plural: "miles"
+  },
+  // Nautical (exato por definição internacional)
+  nautical_mile: {
+    factor: 1852,
+    symbol: "nmi",
+    singular: "nautical mile",
+    plural: "nautical miles"
+  },
+  // Other (derivados, portanto exatos)
+  fathom: {
+    factor: 1.8288,
+    // 6 feet
+    symbol: "ftm",
+    singular: "fathom",
+    plural: "fathoms"
+  },
+  furlong: {
+    factor: 201.168,
+    // 660 feet = 1/8 mile
+    symbol: "fur",
+    singular: "furlong",
+    plural: "furlongs"
+  },
+  league: {
+    factor: 4828.032,
+    // 3 miles
+    symbol: "lea",
+    singular: "league",
+    plural: "leagues"
+  }
+};
+var LENGTH_ALIASES = {
+  // kilometer
+  km: "kilometer",
+  kilometer: "kilometer",
+  kilometers: "kilometer",
+  quil\u00F4metro: "kilometer",
+  quil\u00F4metros: "kilometer",
+  // hectometer
+  hm: "hectometer",
+  hectometer: "hectometer",
+  hectometers: "hectometer",
+  // decameter
+  dam: "decameter",
+  decameter: "decameter",
+  decameters: "decameter",
+  // meter
+  m: "meter",
+  meter: "meter",
+  meters: "meter",
+  metro: "meter",
+  metros: "meter",
+  // decimeter
+  dm: "decimeter",
+  decimeter: "decimeter",
+  decimeters: "decimeter",
+  // centimeter
+  cm: "centimeter",
+  centimeter: "centimeter",
+  centimeters: "centimeter",
+  cent\u00EDmetro: "centimeter",
+  cent\u00EDmetros: "centimeter",
+  // millimeter
+  mm: "millimeter",
+  millimeter: "millimeter",
+  millimeters: "millimeter",
+  mil\u00EDmetro: "millimeter",
+  mil\u00EDmetros: "millimeter",
+  // micrometer
+  \u03BCm: "micrometer",
+  um: "micrometer",
+  micrometer: "micrometer",
+  micrometers: "micrometer",
+  micron: "micrometer",
+  microns: "micrometer",
+  // nanometer
+  nm: "nanometer",
+  nanometer: "nanometer",
+  nanometers: "nanometer",
+  // inch
+  in: "inch",
+  '"': "inch",
+  inch: "inch",
+  inches: "inch",
+  polegada: "inch",
+  polegadas: "inch",
+  // foot
+  ft: "foot",
+  "'": "foot",
+  foot: "foot",
+  feet: "foot",
+  p\u00E9: "foot",
+  p\u00E9s: "foot",
+  // yard
+  yd: "yard",
+  yard: "yard",
+  yards: "yard",
+  jarda: "yard",
+  jardas: "yard",
+  // mile
+  mi: "mile",
+  mile: "mile",
+  miles: "mile",
+  milha: "mile",
+  milhas: "mile",
+  // nautical_mile
+  nmi: "nautical_mile",
+  "nautical mile": "nautical_mile",
+  "nautical miles": "nautical_mile",
+  "milha n\xE1utica": "nautical_mile",
+  "milhas n\xE1uticas": "nautical_mile",
+  // fathom
+  ftm: "fathom",
+  fathom: "fathom",
+  fathoms: "fathom",
+  bra\u00E7a: "fathom",
+  bra\u00E7as: "fathom",
+  // furlong
+  fur: "furlong",
+  furlong: "furlong",
+  furlongs: "furlong",
+  // league
+  lea: "league",
+  league: "league",
+  leagues: "league",
+  l\u00E9gua: "league",
+  l\u00E9guas: "league"
+};
+Object.fromEntries(
+  Object.entries(LENGTH_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/length/LengthRole.ts
+var LengthRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "length";
+    this.base = "meter";
+    this.units = LENGTH_UNITS;
+    this.aliases = LENGTH_ALIASES;
+  }
+  // Length pode ser negativo (posição relativa), então não definimos min
+};
+var lengthRole = new LengthRole();
+
+// src/roles/mass/constants.ts
+var MASS_UNITS = {
+  // ===========================================================================
+  // SI / Metric
+  // ===========================================================================
+  metric_ton: {
+    factor: 1e3,
+    symbol: "t",
+    singular: "metric ton",
+    plural: "metric tons"
+  },
+  kilogram: {
+    factor: 1,
+    symbol: "kg",
+    singular: "kilogram",
+    plural: "kilograms"
+  },
+  hectogram: {
+    factor: 0.1,
+    symbol: "hg",
+    singular: "hectogram",
+    plural: "hectograms"
+  },
+  decagram: {
+    factor: 0.01,
+    symbol: "dag",
+    singular: "decagram",
+    plural: "decagrams"
+  },
+  gram: {
+    factor: 1e-3,
+    symbol: "g",
+    singular: "gram",
+    plural: "grams"
+  },
+  decigram: {
+    factor: 1e-4,
+    symbol: "dg",
+    singular: "decigram",
+    plural: "decigrams"
+  },
+  centigram: {
+    factor: 1e-5,
+    symbol: "cg",
+    singular: "centigram",
+    plural: "centigrams"
+  },
+  milligram: {
+    factor: 1e-6,
+    symbol: "mg",
+    singular: "milligram",
+    plural: "milligrams"
+  },
+  microgram: {
+    factor: 1e-9,
+    symbol: "\u03BCg",
+    singular: "microgram",
+    plural: "micrograms"
+  },
+  // ===========================================================================
+  // Avoirdupois (US/UK) - Sistema padrão para peso comum
+  // ===========================================================================
+  long_ton: {
+    factor: 1016.0469088,
+    // 2240 lb (exato)
+    symbol: "long tn",
+    singular: "long ton",
+    plural: "long tons"
+  },
+  short_ton: {
+    factor: 907.18474,
+    // 2000 lb (exato)
+    symbol: "sh tn",
+    singular: "short ton",
+    plural: "short tons"
+  },
+  stone: {
+    factor: 6.35029318,
+    // 14 lb (exato)
+    symbol: "st",
+    singular: "stone",
+    plural: "stone"
+    // stone não muda no plural em inglês
+  },
+  pound: {
+    factor: 0.45359237,
+    // Exato desde 1959
+    symbol: "lb",
+    singular: "pound",
+    plural: "pounds"
+  },
+  ounce: {
+    factor: 0.028349523125,
+    // 1/16 lb (exato)
+    symbol: "oz",
+    singular: "ounce",
+    plural: "ounces"
+  },
+  dram: {
+    factor: 0.0017718451953125,
+    // 1/16 oz (exato)
+    symbol: "dr",
+    singular: "dram",
+    plural: "drams"
+  },
+  grain: {
+    factor: 6479891e-11,
+    // 1/7000 lb (exato)
+    symbol: "gr",
+    singular: "grain",
+    plural: "grains"
+  },
+  // ===========================================================================
+  // Troy (metais preciosos)
+  // ===========================================================================
+  troy_pound: {
+    factor: 0.3732417216,
+    // 12 troy oz (exato)
+    symbol: "lb t",
+    singular: "troy pound",
+    plural: "troy pounds"
+  },
+  troy_ounce: {
+    factor: 0.0311034768,
+    // 480 grains (exato)
+    symbol: "oz t",
+    singular: "troy ounce",
+    plural: "troy ounces"
+  },
+  pennyweight: {
+    factor: 0.00155517384,
+    // 1/20 troy oz (exato)
+    symbol: "dwt",
+    singular: "pennyweight",
+    plural: "pennyweights"
+  }
+};
+var MASS_ALIASES = {
+  // metric_ton
+  t: "metric_ton",
+  tonne: "metric_ton",
+  tonnes: "metric_ton",
+  "metric ton": "metric_ton",
+  "metric tons": "metric_ton",
+  tonelada: "metric_ton",
+  toneladas: "metric_ton",
+  // kilogram
+  kg: "kilogram",
+  kilo: "kilogram",
+  kilos: "kilogram",
+  kilogram: "kilogram",
+  kilograms: "kilogram",
+  quilograma: "kilogram",
+  quilogramas: "kilogram",
+  // hectogram
+  hg: "hectogram",
+  hectogram: "hectogram",
+  hectograms: "hectogram",
+  // decagram
+  dag: "decagram",
+  decagram: "decagram",
+  decagrams: "decagram",
+  // gram
+  g: "gram",
+  gram: "gram",
+  grams: "gram",
+  grama: "gram",
+  gramas: "gram",
+  // decigram
+  dg: "decigram",
+  decigram: "decigram",
+  decigrams: "decigram",
+  // centigram
+  cg: "centigram",
+  centigram: "centigram",
+  centigrams: "centigram",
+  // milligram
+  mg: "milligram",
+  milligram: "milligram",
+  milligrams: "milligram",
+  miligrama: "milligram",
+  miligramas: "milligram",
+  // microgram
+  \u03BCg: "microgram",
+  ug: "microgram",
+  mcg: "microgram",
+  microgram: "microgram",
+  micrograms: "microgram",
+  // long_ton
+  "long tn": "long_ton",
+  "long ton": "long_ton",
+  "long tons": "long_ton",
+  "imperial ton": "long_ton",
+  // short_ton
+  "sh tn": "short_ton",
+  "short ton": "short_ton",
+  "short tons": "short_ton",
+  "us ton": "short_ton",
+  ton: "short_ton",
+  // Default "ton" para short ton (US)
+  tons: "short_ton",
+  // stone
+  st: "stone",
+  stone: "stone",
+  stones: "stone",
+  // pound
+  lb: "pound",
+  lbs: "pound",
+  pound: "pound",
+  pounds: "pound",
+  libra: "pound",
+  libras: "pound",
+  "#": "pound",
+  // ounce
+  oz: "ounce",
+  ounce: "ounce",
+  ounces: "ounce",
+  on\u00E7a: "ounce",
+  on\u00E7as: "ounce",
+  // dram
+  dr: "dram",
+  dram: "dram",
+  drams: "dram",
+  // grain
+  gr: "grain",
+  grain: "grain",
+  grains: "grain",
+  // troy_pound
+  "lb t": "troy_pound",
+  "troy pound": "troy_pound",
+  "troy pounds": "troy_pound",
+  // troy_ounce
+  "oz t": "troy_ounce",
+  ozt: "troy_ounce",
+  "troy ounce": "troy_ounce",
+  "troy ounces": "troy_ounce",
+  // pennyweight
+  dwt: "pennyweight",
+  pennyweight: "pennyweight",
+  pennyweights: "pennyweight"
+};
+Object.fromEntries(
+  Object.entries(MASS_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/mass/MassRole.ts
+var MassRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "mass";
+    this.base = "kilogram";
+    this.units = MASS_UNITS;
+    this.aliases = MASS_ALIASES;
+    this.validation = {
+      min: 0,
+      minError: "Mass cannot be negative"
+    };
+  }
+};
+var massRole = new MassRole();
+
+// src/roles/temperature/constants.ts
+var TEMPERATURE_UNITS = {
+  celsius: {
+    symbol: "\xB0C",
+    singular: "degree Celsius",
+    plural: "degrees Celsius",
+    toBase: (c) => c,
+    fromBase: (c) => c,
+    noSpace: true
+    // 25°C não 25 °C
+  },
+  fahrenheit: {
+    symbol: "\xB0F",
+    singular: "degree Fahrenheit",
+    plural: "degrees Fahrenheit",
+    toBase: (f) => (f - 32) * (5 / 9),
+    fromBase: (c) => c * (9 / 5) + 32,
+    noSpace: true
+    // 77°F não 77 °F
+  },
+  kelvin: {
+    symbol: "K",
+    singular: "kelvin",
+    plural: "kelvins",
+    toBase: (k) => k - 273.15,
+    fromBase: (c) => c + 273.15
+    // Kelvin usa espaço: "273 K" (convenção SI)
+  },
+  rankine: {
+    symbol: "\xB0R",
+    singular: "degree Rankine",
+    plural: "degrees Rankine",
+    toBase: (r) => (r - 491.67) * (5 / 9),
+    fromBase: (c) => (c + 273.15) * (9 / 5),
+    noSpace: true
+    // 500°R não 500 °R
+  }
+};
+var TEMPERATURE_ALIASES = {
+  // celsius
+  c: "celsius",
+  "\xB0c": "celsius",
+  celsius: "celsius",
+  centigrade: "celsius",
+  grau: "celsius",
+  graus: "celsius",
+  // fahrenheit
+  f: "fahrenheit",
+  "\xB0f": "fahrenheit",
+  fahrenheit: "fahrenheit",
+  fahr: "fahrenheit",
+  // kelvin
+  k: "kelvin",
+  kelvin: "kelvin",
+  kelvins: "kelvin",
+  // rankine
+  r: "rankine",
+  "\xB0r": "rankine",
+  rankine: "rankine",
+  ra: "rankine"
+};
+var TEMPERATURE_CONSTANTS = {
+  /** Zero absoluto em Celsius */
+  ABSOLUTE_ZERO_CELSIUS: -273.15,
+  /** Zero absoluto em Fahrenheit */
+  ABSOLUTE_ZERO_FAHRENHEIT: -459.67};
+
+// src/roles/temperature/TemperatureRole.ts
+var TemperatureRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "temperature";
+    this.base = "celsius";
+    this.units = TEMPERATURE_UNITS;
+    this.aliases = TEMPERATURE_ALIASES;
+    // Temperatura tem validação especial: não pode ser abaixo do zero absoluto
+    this.validation = {
+      min: TEMPERATURE_CONSTANTS.ABSOLUTE_ZERO_CELSIUS,
+      minError: "Temperature cannot be below absolute zero (-273.15\xB0C)"
+    };
+  }
+  /**
+   * Override validate para considerar o zero absoluto na escala correta
+   */
+  validate(variant, value) {
+    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"] };
+    }
+    const absoluteZero = this.getAbsoluteZero(variant);
+    if (value < absoluteZero) {
+      errors.push(
+        `Temperature cannot be below absolute zero (${absoluteZero}${this.units[variant]?.symbol || ""})`
+      );
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Retorna o zero absoluto na escala especificada
+   */
+  getAbsoluteZero(variant) {
+    switch (variant) {
+      case "celsius":
+        return TEMPERATURE_CONSTANTS.ABSOLUTE_ZERO_CELSIUS;
+      case "fahrenheit":
+        return TEMPERATURE_CONSTANTS.ABSOLUTE_ZERO_FAHRENHEIT;
+      case "kelvin":
+        return 0;
+      case "rankine":
+        return 0;
+      default:
+        return TEMPERATURE_CONSTANTS.ABSOLUTE_ZERO_CELSIUS;
+    }
+  }
+};
+var temperatureRole = new TemperatureRole();
+
+// src/roles/angle/constants.ts
+var DEGREES_PER_RADIAN = 180 / Math.PI;
+var DEGREES_PER_MILLIRADIAN = 180 / (1e3 * Math.PI);
+var ANGLE_UNITS = {
+  // Volta completa
+  turn: {
+    factor: 360,
+    symbol: "tr",
+    singular: "turn",
+    plural: "turns"
+  },
+  // Base
+  degree: {
+    factor: 1,
+    symbol: "\xB0",
+    singular: "degree",
+    plural: "degrees",
+    noSpace: true
+    // 45° não 45 °
+  },
+  // Subdivisões do grau
+  arcminute: {
+    factor: 1 / 60,
+    // 0.016666...
+    symbol: "\u2032",
+    singular: "arcminute",
+    plural: "arcminutes",
+    noSpace: true
+    // 30′ não 30 ′
+  },
+  arcsecond: {
+    factor: 1 / 3600,
+    // 0.000277...
+    symbol: "\u2033",
+    singular: "arcsecond",
+    plural: "arcseconds",
+    noSpace: true
+    // 45″ não 45 ″
+  },
+  milliarcsecond: {
+    factor: 1 / 36e5,
+    // 2.777...e-7
+    symbol: "mas",
+    singular: "milliarcsecond",
+    plural: "milliarcseconds"
+  },
+  // Radianos (unidade SI)
+  radian: {
+    factor: DEGREES_PER_RADIAN,
+    // 180/π ≈ 57.2958
+    symbol: "rad",
+    singular: "radian",
+    plural: "radians"
+  },
+  milliradian: {
+    factor: DEGREES_PER_MILLIRADIAN,
+    // 180/(1000π) ≈ 0.0573
+    symbol: "mrad",
+    singular: "milliradian",
+    plural: "milliradians"
+  },
+  // Gradiano (gon)
+  gradian: {
+    factor: 0.9,
+    // 360/400
+    symbol: "gon",
+    singular: "gradian",
+    plural: "gradians"
+  }
+};
+var ANGLE_ALIASES = {
+  // turn
+  tr: "turn",
+  turn: "turn",
+  turns: "turn",
+  rev: "turn",
+  revolution: "turn",
+  revolutions: "turn",
+  volta: "turn",
+  voltas: "turn",
+  // degree
+  "\xB0": "degree",
+  deg: "degree",
+  degree: "degree",
+  degrees: "degree",
+  grau: "degree",
+  graus: "degree",
+  // arcminute
+  "\u2032": "arcminute",
+  "'": "arcminute",
+  arcmin: "arcminute",
+  arcminute: "arcminute",
+  arcminutes: "arcminute",
+  "minute of arc": "arcminute",
+  "minutes of arc": "arcminute",
+  // arcsecond
+  "\u2033": "arcsecond",
+  '"': "arcsecond",
+  arcsec: "arcsecond",
+  arcsecond: "arcsecond",
+  arcseconds: "arcsecond",
+  "second of arc": "arcsecond",
+  "seconds of arc": "arcsecond",
+  // milliarcsecond
+  mas: "milliarcsecond",
+  milliarcsecond: "milliarcsecond",
+  milliarcseconds: "milliarcsecond",
+  // radian
+  rad: "radian",
+  radian: "radian",
+  radians: "radian",
+  radiano: "radian",
+  radianos: "radian",
+  // milliradian
+  mrad: "milliradian",
+  milliradian: "milliradian",
+  milliradians: "milliradian",
+  milirradiano: "milliradian",
+  milirredianos: "milliradian",
+  // gradian
+  gon: "gradian",
+  grad: "gradian",
+  grade: "gradian",
+  gradian: "gradian",
+  gradians: "gradian",
+  grado: "gradian",
+  grados: "gradian"
+};
+Object.fromEntries(
+  Object.entries(ANGLE_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/angle/AngleRole.ts
+var AngleRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "angle";
+    this.base = "degree";
+    this.units = ANGLE_UNITS;
+    this.aliases = ANGLE_ALIASES;
+  }
+  // Ângulo pode ser negativo (rotação anti-horária) e maior que 360° (múltiplas voltas)
+  // Não definimos min/max na validação
+};
+var angleRole = new AngleRole();
+
+// src/roles/energy/constants.ts
+var ENERGY_UNITS = {
+  // SI Units (todos exatos)
+  gigajoule: {
+    factor: 1e9,
+    symbol: "GJ",
+    singular: "gigajoule",
+    plural: "gigajoules"
+  },
+  megajoule: {
+    factor: 1e6,
+    symbol: "MJ",
+    singular: "megajoule",
+    plural: "megajoules"
+  },
+  kilojoule: {
+    factor: 1e3,
+    symbol: "kJ",
+    singular: "kilojoule",
+    plural: "kilojoules"
+  },
+  joule: {
+    factor: 1,
+    symbol: "J",
+    singular: "joule",
+    plural: "joules"
+  },
+  millijoule: {
+    factor: 1e-3,
+    symbol: "mJ",
+    singular: "millijoule",
+    plural: "millijoules"
+  },
+  // Calories (International Table - IT)
+  // 1 cal (IT) = 4.1868 J (exato por definição)
+  calorie: {
+    factor: 4.1868,
+    symbol: "cal",
+    singular: "calorie",
+    plural: "calories"
+  },
+  // 1 kcal = 1000 cal = 4186.8 J (= 1 "food Calorie")
+  kilocalorie: {
+    factor: 4186.8,
+    symbol: "kcal",
+    singular: "kilocalorie",
+    plural: "kilocalories"
+  },
+  // Watt-hour (exatos)
+  // 1 Wh = 1 W × 3600 s = 3600 J
+  watt_hour: {
+    factor: 3600,
+    symbol: "Wh",
+    singular: "watt-hour",
+    plural: "watt-hours"
+  },
+  kilowatt_hour: {
+    factor: 36e5,
+    symbol: "kWh",
+    singular: "kilowatt-hour",
+    plural: "kilowatt-hours"
+  },
+  megawatt_hour: {
+    factor: 36e8,
+    symbol: "MWh",
+    singular: "megawatt-hour",
+    plural: "megawatt-hours"
+  },
+  gigawatt_hour: {
+    factor: 36e11,
+    symbol: "GWh",
+    singular: "gigawatt-hour",
+    plural: "gigawatt-hours"
+  },
+  // BTU (International Table)
+  // 1 BTU (IT) = 1055.05585262 J (definição)
+  btu: {
+    factor: 1055.05585262,
+    symbol: "BTU",
+    singular: "BTU",
+    plural: "BTUs"
+  },
+  // 1 therm = 100,000 BTU (IT)
+  therm: {
+    factor: 105505585262e-3,
+    symbol: "thm",
+    singular: "therm",
+    plural: "therms"
+  },
+  // Scientific
+  // 1 eV = 1.602176634e-19 J (SI 2019, exato por definição)
+  electronvolt: {
+    factor: 1602176634e-28,
+    symbol: "eV",
+    singular: "electronvolt",
+    plural: "electronvolts"
+  },
+  kiloelectronvolt: {
+    factor: 1602176634e-25,
+    symbol: "keV",
+    singular: "kiloelectronvolt",
+    plural: "kiloelectronvolts"
+  },
+  megaelectronvolt: {
+    factor: 1602176634e-22,
+    symbol: "MeV",
+    singular: "megaelectronvolt",
+    plural: "megaelectronvolts"
+  },
+  // 1 erg = 1e-7 J (CGS, exato)
+  erg: {
+    factor: 1e-7,
+    symbol: "erg",
+    singular: "erg",
+    plural: "ergs"
+  },
+  // Mechanical
+  // 1 ft⋅lbf = 1.3558179483314004 J (derivado de foot e pound-force)
+  foot_pound: {
+    factor: 1.3558179483314003,
+    symbol: "ft\u22C5lbf",
+    singular: "foot-pound",
+    plural: "foot-pounds"
+  }
+};
+var ENERGY_ALIASES = {
+  // gigajoule
+  gj: "gigajoule",
+  gigajoule: "gigajoule",
+  gigajoules: "gigajoule",
+  // megajoule
+  mj: "megajoule",
+  megajoule: "megajoule",
+  megajoules: "megajoule",
+  // kilojoule
+  kj: "kilojoule",
+  kilojoule: "kilojoule",
+  kilojoules: "kilojoule",
+  // joule
+  j: "joule",
+  joule: "joule",
+  joules: "joule",
+  // millijoule
+  "mj ": "millijoule",
+  // note: conflict with megajoule, use context
+  millijoule: "millijoule",
+  millijoules: "millijoule",
+  // calorie
+  cal: "calorie",
+  calorie: "calorie",
+  calories: "calorie",
+  caloria: "calorie",
+  calorias: "calorie",
+  // kilocalorie
+  kcal: "kilocalorie",
+  kilocalorie: "kilocalorie",
+  kilocalories: "kilocalorie",
+  quilocaloria: "kilocalorie",
+  quilocalorias: "kilocalorie",
+  caloria_alimentar: "kilocalorie",
+  "food calorie": "kilocalorie",
+  "food calories": "kilocalorie",
+  Calorie: "kilocalorie",
+  // big C = kcal
+  Calories: "kilocalorie",
+  Cal: "kilocalorie",
+  // watt_hour
+  wh: "watt_hour",
+  "watt-hour": "watt_hour",
+  "watt-hours": "watt_hour",
+  "watt hour": "watt_hour",
+  "watt hours": "watt_hour",
+  // kilowatt_hour
+  kwh: "kilowatt_hour",
+  "kw-h": "kilowatt_hour",
+  "kw h": "kilowatt_hour",
+  "kilowatt-hour": "kilowatt_hour",
+  "kilowatt-hours": "kilowatt_hour",
+  "kilowatt hour": "kilowatt_hour",
+  "kilowatt hours": "kilowatt_hour",
+  // megawatt_hour
+  mwh: "megawatt_hour",
+  "megawatt-hour": "megawatt_hour",
+  "megawatt-hours": "megawatt_hour",
+  // gigawatt_hour
+  gwh: "gigawatt_hour",
+  "gigawatt-hour": "gigawatt_hour",
+  "gigawatt-hours": "gigawatt_hour",
+  // btu
+  btu: "btu",
+  btus: "btu",
+  "british thermal unit": "btu",
+  "british thermal units": "btu",
+  // therm
+  thm: "therm",
+  therm: "therm",
+  therms: "therm",
+  // electronvolt
+  ev: "electronvolt",
+  electronvolt: "electronvolt",
+  electronvolts: "electronvolt",
+  "electron-volt": "electronvolt",
+  "electron-volts": "electronvolt",
+  "electron volt": "electronvolt",
+  "electron volts": "electronvolt",
+  // kiloelectronvolt
+  kev: "kiloelectronvolt",
+  kiloelectronvolt: "kiloelectronvolt",
+  kiloelectronvolts: "kiloelectronvolt",
+  // megaelectronvolt
+  mev: "megaelectronvolt",
+  megaelectronvolt: "megaelectronvolt",
+  megaelectronvolts: "megaelectronvolt",
+  // erg
+  erg: "erg",
+  ergs: "erg",
+  // foot_pound
+  "ft-lb": "foot_pound",
+  "ft-lbf": "foot_pound",
+  "ft\u22C5lbf": "foot_pound",
+  "ft\xB7lbf": "foot_pound",
+  "foot-pound": "foot_pound",
+  "foot-pounds": "foot_pound",
+  "foot pound": "foot_pound",
+  "foot pounds": "foot_pound"
+};
+Object.fromEntries(
+  Object.entries(ENERGY_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/energy/EnergyRole.ts
+var EnergyRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "energy";
+    this.base = "joule";
+    this.units = ENERGY_UNITS;
+    this.aliases = ENERGY_ALIASES;
+    this.validation = {
+      min: 0,
+      minError: "Energy cannot be negative"
+    };
+  }
+};
+var energyRole = new EnergyRole();
+
+// src/roles/power/constants.ts
+var POWER_UNITS = {
+  // SI Units (todos exatos)
+  gigawatt: {
+    factor: 1e9,
+    symbol: "GW",
+    singular: "gigawatt",
+    plural: "gigawatts"
+  },
+  megawatt: {
+    factor: 1e6,
+    symbol: "MW",
+    singular: "megawatt",
+    plural: "megawatts"
+  },
+  kilowatt: {
+    factor: 1e3,
+    symbol: "kW",
+    singular: "kilowatt",
+    plural: "kilowatts"
+  },
+  watt: {
+    factor: 1,
+    symbol: "W",
+    singular: "watt",
+    plural: "watts"
+  },
+  milliwatt: {
+    factor: 1e-3,
+    symbol: "mW",
+    singular: "milliwatt",
+    plural: "milliwatts"
+  },
+  microwatt: {
+    factor: 1e-6,
+    symbol: "\u03BCW",
+    singular: "microwatt",
+    plural: "microwatts"
+  },
+  // Horsepower variants
+  // Mechanical (imperial): 550 ft⋅lbf/s
+  // = 550 × 0.3048 m × 4.4482216152605 N / s = 745.69987158227 W
+  horsepower_mechanical: {
+    factor: 745.69987158227,
+    symbol: "hp",
+    singular: "horsepower",
+    plural: "horsepower"
+  },
+  // Metric (PS, CV, pk): 75 kgf⋅m/s = 75 × 9.80665 W = 735.49875 W (exato)
+  horsepower_metric: {
+    factor: 735.49875,
+    symbol: "PS",
+    singular: "metric horsepower",
+    plural: "metric horsepower"
+  },
+  // Electrical: 746 W (exato por definição)
+  horsepower_electric: {
+    factor: 746,
+    symbol: "hp(E)",
+    singular: "electric horsepower",
+    plural: "electric horsepower"
+  },
+  // Boiler: 33,475 BTU/h = 9809.5 W
+  horsepower_boiler: {
+    factor: 9809.5,
+    symbol: "hp(S)",
+    singular: "boiler horsepower",
+    plural: "boiler horsepower"
+  },
+  // BTU-based
+  // 1 BTU/h = 1055.05585262 J / 3600 s = 0.29307107017222 W
+  btu_per_hour: {
+    factor: 0.29307107017222,
+    symbol: "BTU/h",
+    singular: "BTU per hour",
+    plural: "BTUs per hour"
+  },
+  // 1 BTU/s = 1055.05585262 W
+  btu_per_second: {
+    factor: 1055.05585262,
+    symbol: "BTU/s",
+    singular: "BTU per second",
+    plural: "BTUs per second"
+  },
+  // Other
+  // 1 ton of refrigeration = 12000 BTU/h = 3516.8528420667 W
+  ton_of_refrigeration: {
+    factor: 3516.8528420667,
+    symbol: "TR",
+    singular: "ton of refrigeration",
+    plural: "tons of refrigeration"
+  },
+  // 1 ft⋅lbf/s = 1.3558179483314004 W
+  foot_pound_per_second: {
+    factor: 1.3558179483314003,
+    symbol: "ft\u22C5lbf/s",
+    singular: "foot-pound per second",
+    plural: "foot-pounds per second"
+  },
+  // 1 cal/s = 4.1868 W
+  calorie_per_second: {
+    factor: 4.1868,
+    symbol: "cal/s",
+    singular: "calorie per second",
+    plural: "calories per second"
+  },
+  // 1 kcal/h = 4186.8 / 3600 = 1.163 W
+  kilocalorie_per_hour: {
+    factor: 1.163,
+    symbol: "kcal/h",
+    singular: "kilocalorie per hour",
+    plural: "kilocalories per hour"
+  }
+};
+var POWER_ALIASES = {
+  // gigawatt
+  gw: "gigawatt",
+  gigawatt: "gigawatt",
+  gigawatts: "gigawatt",
+  // megawatt
+  mw: "megawatt",
+  megawatt: "megawatt",
+  megawatts: "megawatt",
+  // kilowatt
+  kw: "kilowatt",
+  kilowatt: "kilowatt",
+  kilowatts: "kilowatt",
+  // watt
+  w: "watt",
+  watt: "watt",
+  watts: "watt",
+  // milliwatt
+  milliwatt: "milliwatt",
+  milliwatts: "milliwatt",
+  // microwatt
+  \u03BCw: "microwatt",
+  uw: "microwatt",
+  microwatt: "microwatt",
+  microwatts: "microwatt",
+  // horsepower_mechanical
+  hp: "horsepower_mechanical",
+  horsepower: "horsepower_mechanical",
+  "horse power": "horsepower_mechanical",
+  "cavalo-vapor": "horsepower_mechanical",
+  // horsepower_metric
+  ps: "horsepower_metric",
+  cv: "horsepower_metric",
+  pk: "horsepower_metric",
+  "metric horsepower": "horsepower_metric",
+  "cavalo-vapor m\xE9trico": "horsepower_metric",
+  pferdest\u00E4rke: "horsepower_metric",
+  // horsepower_electric
+  "hp(e)": "horsepower_electric",
+  "electric horsepower": "horsepower_electric",
+  "electrical horsepower": "horsepower_electric",
+  // horsepower_boiler
+  "hp(s)": "horsepower_boiler",
+  "boiler horsepower": "horsepower_boiler",
+  bhp: "horsepower_boiler",
+  // btu_per_hour
+  "btu/h": "btu_per_hour",
+  "btu/hr": "btu_per_hour",
+  btuh: "btu_per_hour",
+  "btu per hour": "btu_per_hour",
+  "btus per hour": "btu_per_hour",
+  // btu_per_second
+  "btu/s": "btu_per_second",
+  "btu per second": "btu_per_second",
+  // ton_of_refrigeration
+  tr: "ton_of_refrigeration",
+  rt: "ton_of_refrigeration",
+  "ton of refrigeration": "ton_of_refrigeration",
+  "tons of refrigeration": "ton_of_refrigeration",
+  "refrigeration ton": "ton_of_refrigeration",
+  "refrigeration tons": "ton_of_refrigeration",
+  // foot_pound_per_second
+  "ft-lb/s": "foot_pound_per_second",
+  "ft-lbf/s": "foot_pound_per_second",
+  "ft\u22C5lbf/s": "foot_pound_per_second",
+  "ft\xB7lbf/s": "foot_pound_per_second",
+  "foot-pound per second": "foot_pound_per_second",
+  "foot-pounds per second": "foot_pound_per_second",
+  // calorie_per_second
+  "cal/s": "calorie_per_second",
+  "calorie per second": "calorie_per_second",
+  "calories per second": "calorie_per_second",
+  // kilocalorie_per_hour
+  "kcal/h": "kilocalorie_per_hour",
+  "kcal/hr": "kilocalorie_per_hour",
+  "kilocalorie per hour": "kilocalorie_per_hour",
+  "kilocalories per hour": "kilocalorie_per_hour"
+};
+Object.fromEntries(
+  Object.entries(POWER_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/power/PowerRole.ts
+var PowerRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "power";
+    this.base = "watt";
+    this.units = POWER_UNITS;
+    this.aliases = POWER_ALIASES;
+    this.validation = {
+      min: 0,
+      minError: "Power cannot be negative"
+    };
+  }
+};
+var powerRole = new PowerRole();
+
+// src/roles/speed/constants.ts
+var SPEED_UNITS = {
+  // SI Units
+  meter_per_second: {
+    factor: 1,
+    symbol: "m/s",
+    singular: "meter per second",
+    plural: "meters per second"
+  },
+  kilometer_per_hour: {
+    factor: 1e3 / 3600,
+    // 0.277777...
+    symbol: "km/h",
+    singular: "kilometer per hour",
+    plural: "kilometers per hour"
+  },
+  // Imperial/US (exatos desde 1959)
+  mile_per_hour: {
+    factor: 0.44704,
+    // 1609.344 / 3600 (exato)
+    symbol: "mph",
+    singular: "mile per hour",
+    plural: "miles per hour"
+  },
+  foot_per_second: {
+    factor: 0.3048,
+    // exato
+    symbol: "ft/s",
+    singular: "foot per second",
+    plural: "feet per second"
+  },
+  // Nautical (exato)
+  knot: {
+    factor: 1852 / 3600,
+    // 0.514444...
+    symbol: "kn",
+    singular: "knot",
+    plural: "knots"
+  },
+  // Scientific
+  mach: {
+    factor: 340.29,
+    // velocidade do som ao nível do mar, 15°C (aproximado)
+    symbol: "Ma",
+    singular: "mach",
+    plural: "mach"
+  },
+  speed_of_light: {
+    factor: 299792458,
+    // exato por definição SI
+    symbol: "c",
+    singular: "speed of light",
+    plural: "speed of light"
+  }
+};
+var SPEED_ALIASES = {
+  // meter_per_second
+  "m/s": "meter_per_second",
+  mps: "meter_per_second",
+  "meter per second": "meter_per_second",
+  "meters per second": "meter_per_second",
+  "metro por segundo": "meter_per_second",
+  "metros por segundo": "meter_per_second",
+  // kilometer_per_hour
+  "km/h": "kilometer_per_hour",
+  kmh: "kilometer_per_hour",
+  kph: "kilometer_per_hour",
+  "kilometer per hour": "kilometer_per_hour",
+  "kilometers per hour": "kilometer_per_hour",
+  "kilometre per hour": "kilometer_per_hour",
+  "kilometres per hour": "kilometer_per_hour",
+  "quil\xF4metro por hora": "kilometer_per_hour",
+  "quil\xF4metros por hora": "kilometer_per_hour",
+  // mile_per_hour
+  mph: "mile_per_hour",
+  "mi/h": "mile_per_hour",
+  "mile per hour": "mile_per_hour",
+  "miles per hour": "mile_per_hour",
+  "milha por hora": "mile_per_hour",
+  "milhas por hora": "mile_per_hour",
+  // foot_per_second
+  "ft/s": "foot_per_second",
+  fps: "foot_per_second",
+  "foot per second": "foot_per_second",
+  "feet per second": "foot_per_second",
+  "p\xE9 por segundo": "foot_per_second",
+  "p\xE9s por segundo": "foot_per_second",
+  // knot
+  kn: "knot",
+  kt: "knot",
+  kts: "knot",
+  knot: "knot",
+  knots: "knot",
+  n\u00F3: "knot",
+  n\u00F3s: "knot",
+  // mach
+  ma: "mach",
+  mach: "mach",
+  // speed_of_light
+  c: "speed_of_light",
+  "speed of light": "speed_of_light",
+  "velocidade da luz": "speed_of_light"
+};
+Object.fromEntries(
+  Object.entries(SPEED_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/speed/SpeedRole.ts
+var SpeedRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "speed";
+    this.base = "meter_per_second";
+    this.units = SPEED_UNITS;
+    this.aliases = SPEED_ALIASES;
+  }
+  // Speed pode ser negativo (movimento em direção oposta)
+};
+var speedRole = new SpeedRole();
+
+// src/roles/date/variants/IsoVariant.ts
+var ISO_DATE_ONLY_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var ISO_DATE_TIME_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+var IsoVariant = class extends BaseVariant {
+  constructor() {
+    super(...arguments);
+    this.name = "iso";
+    this.type = "string";
+  }
+  // ===========================================================================
+  // CONVERT
+  // ===========================================================================
+  toBase(value) {
+    const date = new Date(value);
+    if (isNaN(date.getTime())) {
+      throw new Error(`Invalid ISO date: ${value}`);
+    }
+    return date.getTime();
+  }
+  fromBase(base) {
+    const date = new Date(base);
+    if (isNaN(date.getTime())) {
+      throw new Error(`Invalid timestamp: ${base}`);
+    }
+    return date.toISOString();
+  }
+  // ===========================================================================
+  // CAST
+  // ===========================================================================
+  cast(input) {
+    if (typeof input === "string") {
+      const trimmed = input.trim();
+      const date = new Date(trimmed);
+      if (!isNaN(date.getTime())) {
+        return date.toISOString();
+      }
+      return null;
+    }
+    if (typeof input === "number") {
+      if (!Number.isFinite(input)) return null;
+      const date = new Date(input);
+      if (!isNaN(date.getTime())) {
+        return date.toISOString();
+      }
+      return null;
+    }
+    if (input instanceof Date) {
+      if (isNaN(input.getTime())) return null;
+      return input.toISOString();
+    }
+    return null;
+  }
+  // ===========================================================================
+  // VALIDATE
+  // ===========================================================================
+  validate(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: [] };
+  }
+  // ===========================================================================
+  // FORMAT
+  // ===========================================================================
+  format(value, options) {
+    const opts = options;
+    const date = new Date(value);
+    if (isNaN(date.getTime())) {
+      return "Invalid Date";
+    }
+    if (!opts || !opts.dateStyle && !opts.timeStyle && !opts.dateOnly && !opts.timeOnly) {
+      return value;
+    }
+    const locale = opts.locale || "en-US";
+    const formatOptions = {};
+    if (opts.timeZone) {
+      formatOptions.timeZone = opts.timeZone;
+    }
+    if (opts.dateOnly) {
+      formatOptions.dateStyle = opts.dateStyle || "medium";
+    } else if (opts.timeOnly) {
+      formatOptions.timeStyle = opts.timeStyle || "medium";
+    } else {
+      if (opts.dateStyle) formatOptions.dateStyle = opts.dateStyle;
+      if (opts.timeStyle) formatOptions.timeStyle = opts.timeStyle;
+    }
+    return new Intl.DateTimeFormat(locale, formatOptions).format(date);
+  }
+};
+
+// src/roles/date/variants/TimestampVariant.ts
+var TimestampVariant = class extends BaseVariant {
+  constructor() {
+    super(...arguments);
+    this.name = "timestamp";
+    this.type = "number";
+  }
+  // ===========================================================================
+  // CONVERT
+  // ===========================================================================
+  toBase(value) {
+    return value;
+  }
+  fromBase(base) {
+    return base;
+  }
+  // ===========================================================================
+  // CAST
+  // ===========================================================================
+  cast(input) {
+    if (typeof input === "number") {
+      if (!Number.isFinite(input)) return null;
+      return input;
+    }
+    if (typeof input === "string") {
+      const trimmed = input.trim();
+      if (/^-?\d+$/.test(trimmed)) {
+        const num = parseInt(trimmed, 10);
+        if (Number.isFinite(num)) return num;
+      }
+      const date = new Date(trimmed);
+      if (!isNaN(date.getTime())) {
+        return date.getTime();
+      }
+      return null;
+    }
+    if (input instanceof Date) {
+      const ts = input.getTime();
+      return isNaN(ts) ? null : ts;
+    }
+    return null;
+  }
+  // ===========================================================================
+  // VALIDATE
+  // ===========================================================================
+  validate(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: [] };
+  }
+  // ===========================================================================
+  // FORMAT
+  // ===========================================================================
+  format(value, options) {
+    const opts = options;
+    const date = new Date(value);
+    if (isNaN(date.getTime())) {
+      return "Invalid Date";
+    }
+    if (!opts || !opts.dateStyle && !opts.timeStyle && !opts.dateOnly && !opts.timeOnly) {
+      return String(value);
+    }
+    const locale = opts.locale || "en-US";
+    const formatOptions = {};
+    if (opts.timeZone) {
+      formatOptions.timeZone = opts.timeZone;
+    }
+    if (opts.dateOnly) {
+      formatOptions.dateStyle = opts.dateStyle || "medium";
+    } else if (opts.timeOnly) {
+      formatOptions.timeStyle = opts.timeStyle || "medium";
+    } else {
+      if (opts.dateStyle) formatOptions.dateStyle = opts.dateStyle;
+      if (opts.timeStyle) formatOptions.timeStyle = opts.timeStyle;
+    }
+    return new Intl.DateTimeFormat(locale, formatOptions).format(date);
+  }
+};
+
+// src/roles/date/variants/EpochVariant.ts
+var EpochVariant = class extends BaseVariant {
+  constructor() {
+    super(...arguments);
+    this.name = "epoch";
+    this.type = "number";
+  }
+  // ===========================================================================
+  // CONVERT
+  // ===========================================================================
+  toBase(value) {
+    return value * 1e3;
+  }
+  fromBase(base) {
+    return Math.floor(base / 1e3);
+  }
+  // ===========================================================================
+  // CAST
+  // ===========================================================================
+  cast(input) {
+    if (typeof input === "number") {
+      if (!Number.isFinite(input)) return null;
+      if (Math.abs(input) > 1e11) {
+        return Math.floor(input / 1e3);
+      }
+      return Math.floor(input);
+    }
+    if (typeof input === "string") {
+      const trimmed = input.trim();
+      if (/^-?\d+$/.test(trimmed)) {
+        const num = parseInt(trimmed, 10);
+        if (Number.isFinite(num)) {
+          if (Math.abs(num) > 1e11) {
+            return Math.floor(num / 1e3);
+          }
+          return num;
+        }
+      }
+      const date = new Date(trimmed);
+      if (!isNaN(date.getTime())) {
+        return Math.floor(date.getTime() / 1e3);
+      }
+      return null;
+    }
+    if (input instanceof Date) {
+      const ts = input.getTime();
+      return isNaN(ts) ? null : Math.floor(ts / 1e3);
+    }
+    return null;
+  }
+  // ===========================================================================
+  // VALIDATE
+  // ===========================================================================
+  validate(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: [] };
+  }
+  // ===========================================================================
+  // FORMAT
+  // ===========================================================================
+  format(value, options) {
+    const opts = options;
+    const date = new Date(value * 1e3);
+    if (isNaN(date.getTime())) {
+      return "Invalid Date";
+    }
+    if (!opts || !opts.dateStyle && !opts.timeStyle && !opts.dateOnly && !opts.timeOnly) {
+      return String(value);
+    }
+    const locale = opts.locale || "en-US";
+    const formatOptions = {};
+    if (opts.timeZone) {
+      formatOptions.timeZone = opts.timeZone;
+    }
+    if (opts.dateOnly) {
+      formatOptions.dateStyle = opts.dateStyle || "medium";
+    } else if (opts.timeOnly) {
+      formatOptions.timeStyle = opts.timeStyle || "medium";
+    } else {
+      if (opts.dateStyle) formatOptions.dateStyle = opts.dateStyle;
+      if (opts.timeStyle) formatOptions.timeStyle = opts.timeStyle;
+    }
+    return new Intl.DateTimeFormat(locale, formatOptions).format(date);
+  }
+};
+
+// src/roles/date/DateRole.ts
+var DateRole = class extends ComplexRole {
+  constructor() {
+    super(...arguments);
+    this.name = "date";
+    this.base = "timestamp";
+  }
+  createVariants() {
+    return {
+      iso: new IsoVariant(),
+      timestamp: new TimestampVariant(),
+      epoch: new EpochVariant()
+    };
+  }
+  /**
+   * Override format to accept DateFormatOptions
+   */
+  format(variant, value, options) {
+    return super.format(variant, value, options);
+  }
+};
+var dateRole = new DateRole();
+
+// src/roles/volume/constants.ts
+var VOLUME_UNITS = {
+  // SI / Métrico
+  cubic_meter: {
+    factor: 1e3,
+    symbol: "m\xB3",
+    singular: "cubic meter",
+    plural: "cubic meters"
+  },
+  cubic_decimeter: {
+    factor: 1,
+    symbol: "dm\xB3",
+    singular: "cubic decimeter",
+    plural: "cubic decimeters"
+  },
+  cubic_centimeter: {
+    factor: 1e-3,
+    symbol: "cm\xB3",
+    singular: "cubic centimeter",
+    plural: "cubic centimeters"
+  },
+  cubic_millimeter: {
+    factor: 1e-6,
+    symbol: "mm\xB3",
+    singular: "cubic millimeter",
+    plural: "cubic millimeters"
+  },
+  hectoliter: {
+    factor: 100,
+    symbol: "hL",
+    singular: "hectoliter",
+    plural: "hectoliters"
+  },
+  decaliter: {
+    factor: 10,
+    symbol: "daL",
+    singular: "decaliter",
+    plural: "decaliters"
+  },
+  liter: {
+    factor: 1,
+    symbol: "L",
+    singular: "liter",
+    plural: "liters"
+  },
+  deciliter: {
+    factor: 0.1,
+    symbol: "dL",
+    singular: "deciliter",
+    plural: "deciliters"
+  },
+  centiliter: {
+    factor: 0.01,
+    symbol: "cL",
+    singular: "centiliter",
+    plural: "centiliters"
+  },
+  milliliter: {
+    factor: 1e-3,
+    symbol: "mL",
+    singular: "milliliter",
+    plural: "milliliters"
+  },
+  microliter: {
+    factor: 1e-6,
+    symbol: "\u03BCL",
+    singular: "microliter",
+    plural: "microliters"
+  },
+  // US Customary (baseado em 1 gallon = 231 in³ = 3.785411784 L)
+  gallon_us: {
+    factor: 3.785411784,
+    symbol: "gal",
+    singular: "gallon",
+    plural: "gallons"
+  },
+  quart_us: {
+    factor: 0.946352946,
+    // gallon/4
+    symbol: "qt",
+    singular: "quart",
+    plural: "quarts"
+  },
+  pint_us: {
+    factor: 0.473176473,
+    // gallon/8
+    symbol: "pt",
+    singular: "pint",
+    plural: "pints"
+  },
+  cup_us: {
+    factor: 0.2365882365,
+    // gallon/16
+    symbol: "cup",
+    singular: "cup",
+    plural: "cups"
+  },
+  fluid_ounce_us: {
+    factor: 0.0295735295625,
+    // gallon/128
+    symbol: "fl oz",
+    singular: "fluid ounce",
+    plural: "fluid ounces"
+  },
+  tablespoon_us: {
+    factor: 0.01478676478125,
+    // fl oz/2
+    symbol: "tbsp",
+    singular: "tablespoon",
+    plural: "tablespoons"
+  },
+  teaspoon_us: {
+    factor: 0.00492892159375,
+    // tbsp/3
+    symbol: "tsp",
+    singular: "teaspoon",
+    plural: "teaspoons"
+  },
+  // Imperial UK (1 gallon UK = 4.54609 L exato)
+  gallon_uk: {
+    factor: 4.54609,
+    symbol: "gal (UK)",
+    singular: "gallon (UK)",
+    plural: "gallons (UK)"
+  },
+  quart_uk: {
+    factor: 1.1365225,
+    // gallon/4
+    symbol: "qt (UK)",
+    singular: "quart (UK)",
+    plural: "quarts (UK)"
+  },
+  pint_uk: {
+    factor: 0.56826125,
+    // gallon/8
+    symbol: "pt (UK)",
+    singular: "pint (UK)",
+    plural: "pints (UK)"
+  },
+  fluid_ounce_uk: {
+    factor: 0.0284130625,
+    // gallon/160
+    symbol: "fl oz (UK)",
+    singular: "fluid ounce (UK)",
+    plural: "fluid ounces (UK)"
+  },
+  // Other
+  barrel_oil: {
+    factor: 158.987294928,
+    // 42 US gallons (petroleum)
+    symbol: "bbl",
+    singular: "barrel",
+    plural: "barrels"
+  },
+  cubic_inch: {
+    factor: 0.016387064,
+    // (0.0254)³ × 1000
+    symbol: "in\xB3",
+    singular: "cubic inch",
+    plural: "cubic inches"
+  },
+  cubic_foot: {
+    factor: 28.316846592,
+    // (0.3048)³ × 1000
+    symbol: "ft\xB3",
+    singular: "cubic foot",
+    plural: "cubic feet"
+  },
+  cubic_yard: {
+    factor: 764.554857984,
+    // (0.9144)³ × 1000
+    symbol: "yd\xB3",
+    singular: "cubic yard",
+    plural: "cubic yards"
+  }
+};
+var VOLUME_ALIASES = {
+  // cubic_meter
+  "m\xB3": "cubic_meter",
+  m3: "cubic_meter",
+  "cubic meter": "cubic_meter",
+  "cubic meters": "cubic_meter",
+  "metro c\xFAbico": "cubic_meter",
+  "metros c\xFAbicos": "cubic_meter",
+  // cubic_decimeter
+  "dm\xB3": "cubic_decimeter",
+  dm3: "cubic_decimeter",
+  "cubic decimeter": "cubic_decimeter",
+  "cubic decimeters": "cubic_decimeter",
+  // cubic_centimeter
+  "cm\xB3": "cubic_centimeter",
+  cm3: "cubic_centimeter",
+  cc: "cubic_centimeter",
+  "cubic centimeter": "cubic_centimeter",
+  "cubic centimeters": "cubic_centimeter",
+  // cubic_millimeter
+  "mm\xB3": "cubic_millimeter",
+  mm3: "cubic_millimeter",
+  "cubic millimeter": "cubic_millimeter",
+  "cubic millimeters": "cubic_millimeter",
+  // hectoliter
+  hL: "hectoliter",
+  hl: "hectoliter",
+  hectoliter: "hectoliter",
+  hectoliters: "hectoliter",
+  hectolitre: "hectoliter",
+  hectolitres: "hectoliter",
+  // decaliter
+  daL: "decaliter",
+  dal: "decaliter",
+  decaliter: "decaliter",
+  decaliters: "decaliter",
+  // liter
+  L: "liter",
+  l: "liter",
+  liter: "liter",
+  liters: "liter",
+  litre: "liter",
+  litres: "liter",
+  litro: "liter",
+  litros: "liter",
+  // deciliter
+  dL: "deciliter",
+  dl: "deciliter",
+  deciliter: "deciliter",
+  deciliters: "deciliter",
+  // centiliter
+  cL: "centiliter",
+  cl: "centiliter",
+  centiliter: "centiliter",
+  centiliters: "centiliter",
+  // milliliter
+  mL: "milliliter",
+  ml: "milliliter",
+  milliliter: "milliliter",
+  milliliters: "milliliter",
+  mililitro: "milliliter",
+  mililitros: "milliliter",
+  // microliter
+  \u03BCL: "microliter",
+  uL: "microliter",
+  ul: "microliter",
+  microliter: "microliter",
+  microliters: "microliter",
+  // gallon_us
+  gal: "gallon_us",
+  gallon: "gallon_us",
+  gallons: "gallon_us",
+  "gallon us": "gallon_us",
+  "gallons us": "gallon_us",
+  gal\u00E3o: "gallon_us",
+  gal\u00F5es: "gallon_us",
+  // quart_us
+  qt: "quart_us",
+  quart: "quart_us",
+  quarts: "quart_us",
+  // pint_us
+  pt: "pint_us",
+  pint: "pint_us",
+  pints: "pint_us",
+  // cup_us
+  cup: "cup_us",
+  cups: "cup_us",
+  x\u00EDcara: "cup_us",
+  x\u00EDcaras: "cup_us",
+  // fluid_ounce_us
+  "fl oz": "fluid_ounce_us",
+  floz: "fluid_ounce_us",
+  "fluid ounce": "fluid_ounce_us",
+  "fluid ounces": "fluid_ounce_us",
+  // tablespoon_us
+  tbsp: "tablespoon_us",
+  tablespoon: "tablespoon_us",
+  tablespoons: "tablespoon_us",
+  "colher de sopa": "tablespoon_us",
+  "colheres de sopa": "tablespoon_us",
+  // teaspoon_us
+  tsp: "teaspoon_us",
+  teaspoon: "teaspoon_us",
+  teaspoons: "teaspoon_us",
+  "colher de ch\xE1": "teaspoon_us",
+  "colheres de ch\xE1": "teaspoon_us",
+  // gallon_uk
+  "gal uk": "gallon_uk",
+  "gallon uk": "gallon_uk",
+  "gallons uk": "gallon_uk",
+  "imperial gallon": "gallon_uk",
+  "imperial gallons": "gallon_uk",
+  // quart_uk
+  "qt uk": "quart_uk",
+  "quart uk": "quart_uk",
+  "quarts uk": "quart_uk",
+  // pint_uk
+  "pt uk": "pint_uk",
+  "pint uk": "pint_uk",
+  "pints uk": "pint_uk",
+  "imperial pint": "pint_uk",
+  "imperial pints": "pint_uk",
+  // fluid_ounce_uk
+  "fl oz uk": "fluid_ounce_uk",
+  "fluid ounce uk": "fluid_ounce_uk",
+  "fluid ounces uk": "fluid_ounce_uk",
+  // barrel_oil
+  bbl: "barrel_oil",
+  barrel: "barrel_oil",
+  barrels: "barrel_oil",
+  "oil barrel": "barrel_oil",
+  "oil barrels": "barrel_oil",
+  barril: "barrel_oil",
+  barris: "barrel_oil",
+  // cubic_inch
+  "in\xB3": "cubic_inch",
+  in3: "cubic_inch",
+  "cu in": "cubic_inch",
+  "cubic inch": "cubic_inch",
+  "cubic inches": "cubic_inch",
+  // cubic_foot
+  "ft\xB3": "cubic_foot",
+  ft3: "cubic_foot",
+  "cu ft": "cubic_foot",
+  "cubic foot": "cubic_foot",
+  "cubic feet": "cubic_foot",
+  // cubic_yard
+  "yd\xB3": "cubic_yard",
+  yd3: "cubic_yard",
+  "cu yd": "cubic_yard",
+  "cubic yard": "cubic_yard",
+  "cubic yards": "cubic_yard"
+};
+Object.fromEntries(
+  Object.entries(VOLUME_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/volume/VolumeRole.ts
+var VolumeRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "volume";
+    this.base = "liter";
+    this.units = VOLUME_UNITS;
+    this.aliases = VOLUME_ALIASES;
+    this.validation = {
+      min: 0,
+      minError: "Volume cannot be negative"
+    };
+  }
+};
+var volumeRole = new VolumeRole();
+
+// src/roles/time/constants.ts
+var TIME_UNITS = {
+  // SI prefixes (exatos)
+  nanosecond: {
+    factor: 1e-9,
+    symbol: "ns",
+    singular: "nanosecond",
+    plural: "nanoseconds"
+  },
+  microsecond: {
+    factor: 1e-6,
+    symbol: "\u03BCs",
+    singular: "microsecond",
+    plural: "microseconds"
+  },
+  millisecond: {
+    factor: 1e-3,
+    symbol: "ms",
+    singular: "millisecond",
+    plural: "milliseconds"
+  },
+  second: {
+    factor: 1,
+    symbol: "s",
+    singular: "second",
+    plural: "seconds"
+  },
+  // Common (exatos)
+  minute: {
+    factor: 60,
+    symbol: "min",
+    singular: "minute",
+    plural: "minutes"
+  },
+  hour: {
+    factor: 3600,
+    symbol: "h",
+    singular: "hour",
+    plural: "hours"
+  },
+  day: {
+    factor: 86400,
+    symbol: "d",
+    singular: "day",
+    plural: "days"
+  },
+  week: {
+    factor: 604800,
+    symbol: "wk",
+    singular: "week",
+    plural: "weeks"
+  },
+  // Calendar (aproximados - baseados no ano Gregoriano)
+  month: {
+    factor: 2629746,
+    // 31556952 / 12
+    symbol: "mo",
+    singular: "month",
+    plural: "months"
+  },
+  year: {
+    factor: 31556952,
+    // 365.2425 * 86400
+    symbol: "yr",
+    singular: "year",
+    plural: "years"
+  },
+  decade: {
+    factor: 315569520,
+    // 10 * year
+    symbol: "dec",
+    singular: "decade",
+    plural: "decades"
+  },
+  century: {
+    factor: 3155695200,
+    // 100 * year
+    symbol: "c",
+    singular: "century",
+    plural: "centuries"
+  },
+  millennium: {
+    factor: 31556952e3,
+    // 1000 * year
+    symbol: "ky",
+    singular: "millennium",
+    plural: "millennia"
+  }
+};
+var TIME_ALIASES = {
+  // nanosecond
+  ns: "nanosecond",
+  nanosecond: "nanosecond",
+  nanoseconds: "nanosecond",
+  nanoseg: "nanosecond",
+  nanossegundo: "nanosecond",
+  nanossegundos: "nanosecond",
+  // microsecond
+  \u03BCs: "microsecond",
+  us: "microsecond",
+  microsecond: "microsecond",
+  microseconds: "microsecond",
+  microseg: "microsecond",
+  microssegundo: "microsecond",
+  microssegundos: "microsecond",
+  // millisecond
+  ms: "millisecond",
+  millisecond: "millisecond",
+  milliseconds: "millisecond",
+  milliseg: "millisecond",
+  milissegundo: "millisecond",
+  milissegundos: "millisecond",
+  // second
+  s: "second",
+  sec: "second",
+  second: "second",
+  seconds: "second",
+  seg: "second",
+  segundo: "second",
+  segundos: "second",
+  // minute
+  min: "minute",
+  minute: "minute",
+  minutes: "minute",
+  minuto: "minute",
+  minutos: "minute",
+  // hour
+  h: "hour",
+  hr: "hour",
+  hrs: "hour",
+  hour: "hour",
+  hours: "hour",
+  hora: "hour",
+  horas: "hour",
+  // day
+  d: "day",
+  day: "day",
+  days: "day",
+  dia: "day",
+  dias: "day",
+  // week
+  wk: "week",
+  week: "week",
+  weeks: "week",
+  semana: "week",
+  semanas: "week",
+  // month
+  mo: "month",
+  month: "month",
+  months: "month",
+  m\u00EAs: "month",
+  mes: "month",
+  meses: "month",
+  // year
+  yr: "year",
+  y: "year",
+  year: "year",
+  years: "year",
+  ano: "year",
+  anos: "year",
+  // decade
+  dec: "decade",
+  decade: "decade",
+  decades: "decade",
+  d\u00E9cada: "decade",
+  decada: "decade",
+  d\u00E9cadas: "decade",
+  decadas: "decade",
+  // century
+  c: "century",
+  century: "century",
+  centuries: "century",
+  s\u00E9culo: "century",
+  seculo: "century",
+  s\u00E9culos: "century",
+  seculos: "century",
+  // millennium
+  ky: "millennium",
+  millennium: "millennium",
+  millennia: "millennium",
+  mil\u00EAnio: "millennium",
+  milenio: "millennium",
+  mil\u00EAnios: "millennium",
+  milenios: "millennium"
+};
+Object.fromEntries(
+  Object.entries(TIME_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/time/TimeRole.ts
+var TimeRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "time";
+    this.base = "second";
+    this.units = TIME_UNITS;
+    this.aliases = TIME_ALIASES;
+    this.validation = {
+      min: 0,
+      minError: "Duration cannot be negative"
+    };
+  }
+};
+var timeRole = new TimeRole();
+
+// src/roles/digital/constants.ts
+var DIGITAL_UNITS = {
+  // Fundamental
+  bit: {
+    factor: 0.125,
+    // 1/8 byte
+    symbol: "b",
+    singular: "bit",
+    plural: "bits"
+  },
+  byte: {
+    factor: 1,
+    symbol: "B",
+    singular: "byte",
+    plural: "bytes"
+  },
+  // IEC Binary (base 1024) - RAM, cache, file systems
+  kibibyte: {
+    factor: 1024,
+    // 2^10
+    symbol: "KiB",
+    singular: "kibibyte",
+    plural: "kibibytes"
+  },
+  mebibyte: {
+    factor: 1048576,
+    // 2^20
+    symbol: "MiB",
+    singular: "mebibyte",
+    plural: "mebibytes"
+  },
+  gibibyte: {
+    factor: 1073741824,
+    // 2^30
+    symbol: "GiB",
+    singular: "gibibyte",
+    plural: "gibibytes"
+  },
+  tebibyte: {
+    factor: 1099511627776,
+    // 2^40
+    symbol: "TiB",
+    singular: "tebibyte",
+    plural: "tebibytes"
+  },
+  pebibyte: {
+    factor: 1125899906842624,
+    // 2^50
+    symbol: "PiB",
+    singular: "pebibyte",
+    plural: "pebibytes"
+  },
+  exbibyte: {
+    factor: 1152921504606847e3,
+    // 2^60
+    symbol: "EiB",
+    singular: "exbibyte",
+    plural: "exbibytes"
+  },
+  // SI Decimal (base 1000) - HD marketing, network speeds
+  kilobyte: {
+    factor: 1e3,
+    // 10^3
+    symbol: "kB",
+    singular: "kilobyte",
+    plural: "kilobytes"
+  },
+  megabyte: {
+    factor: 1e6,
+    // 10^6
+    symbol: "MB",
+    singular: "megabyte",
+    plural: "megabytes"
+  },
+  gigabyte: {
+    factor: 1e9,
+    // 10^9
+    symbol: "GB",
+    singular: "gigabyte",
+    plural: "gigabytes"
+  },
+  terabyte: {
+    factor: 1e12,
+    // 10^12
+    symbol: "TB",
+    singular: "terabyte",
+    plural: "terabytes"
+  },
+  petabyte: {
+    factor: 1e15,
+    // 10^15
+    symbol: "PB",
+    singular: "petabyte",
+    plural: "petabytes"
+  },
+  exabyte: {
+    factor: 1e18,
+    // 10^18
+    symbol: "EB",
+    singular: "exabyte",
+    plural: "exabytes"
+  }
+};
+var DIGITAL_ALIASES = {
+  // bit
+  b: "bit",
+  bit: "bit",
+  bits: "bit",
+  // byte
+  B: "byte",
+  byte: "byte",
+  bytes: "byte",
+  octet: "byte",
+  octets: "byte",
+  // kibibyte (IEC)
+  KiB: "kibibyte",
+  kibibyte: "kibibyte",
+  kibibytes: "kibibyte",
+  // mebibyte (IEC)
+  MiB: "mebibyte",
+  mebibyte: "mebibyte",
+  mebibytes: "mebibyte",
+  // gibibyte (IEC)
+  GiB: "gibibyte",
+  gibibyte: "gibibyte",
+  gibibytes: "gibibyte",
+  // tebibyte (IEC)
+  TiB: "tebibyte",
+  tebibyte: "tebibyte",
+  tebibytes: "tebibyte",
+  // pebibyte (IEC)
+  PiB: "pebibyte",
+  pebibyte: "pebibyte",
+  pebibytes: "pebibyte",
+  // exbibyte (IEC)
+  EiB: "exbibyte",
+  exbibyte: "exbibyte",
+  exbibytes: "exbibyte",
+  // kilobyte (SI)
+  kB: "kilobyte",
+  kb: "kilobyte",
+  kilobyte: "kilobyte",
+  kilobytes: "kilobyte",
+  // megabyte (SI)
+  MB: "megabyte",
+  megabyte: "megabyte",
+  megabytes: "megabyte",
+  // gigabyte (SI)
+  GB: "gigabyte",
+  gigabyte: "gigabyte",
+  gigabytes: "gigabyte",
+  // terabyte (SI)
+  TB: "terabyte",
+  terabyte: "terabyte",
+  terabytes: "terabyte",
+  // petabyte (SI)
+  PB: "petabyte",
+  petabyte: "petabyte",
+  petabytes: "petabyte",
+  // exabyte (SI)
+  EB: "exabyte",
+  exabyte: "exabyte",
+  exabytes: "exabyte"
+};
+Object.fromEntries(
+  Object.entries(DIGITAL_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/digital/DigitalRole.ts
+var DigitalRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "digital";
+    this.base = "byte";
+    this.units = DIGITAL_UNITS;
+    this.aliases = DIGITAL_ALIASES;
+    this.validation = {
+      min: 0,
+      minError: "Digital storage cannot be negative"
+    };
+  }
+};
+var digitalRole = new DigitalRole();
+
+// src/roles/frequency/constants.ts
+var FREQUENCY_UNITS = {
+  // SI Units (todos exatos)
+  terahertz: {
+    factor: 1e12,
+    symbol: "THz",
+    singular: "terahertz",
+    plural: "terahertz"
+  },
+  gigahertz: {
+    factor: 1e9,
+    symbol: "GHz",
+    singular: "gigahertz",
+    plural: "gigahertz"
+  },
+  megahertz: {
+    factor: 1e6,
+    symbol: "MHz",
+    singular: "megahertz",
+    plural: "megahertz"
+  },
+  kilohertz: {
+    factor: 1e3,
+    symbol: "kHz",
+    singular: "kilohertz",
+    plural: "kilohertz"
+  },
+  hertz: {
+    factor: 1,
+    symbol: "Hz",
+    singular: "hertz",
+    plural: "hertz"
+  },
+  millihertz: {
+    factor: 1e-3,
+    symbol: "mHz",
+    singular: "millihertz",
+    plural: "millihertz"
+  },
+  microhertz: {
+    factor: 1e-6,
+    symbol: "\u03BCHz",
+    singular: "microhertz",
+    plural: "microhertz"
+  },
+  // Other units
+  rpm: {
+    factor: 1 / 60,
+    // 1 RPM = 1/60 Hz
+    symbol: "rpm",
+    singular: "revolution per minute",
+    plural: "revolutions per minute"
+  },
+  bpm: {
+    factor: 1 / 60,
+    // 1 BPM = 1/60 Hz
+    symbol: "bpm",
+    singular: "beat per minute",
+    plural: "beats per minute"
+  },
+  radians_per_second: {
+    factor: 1 / (2 * Math.PI),
+    // 1 rad/s = 1/(2π) Hz ≈ 0.159154943
+    symbol: "rad/s",
+    singular: "radian per second",
+    plural: "radians per second"
+  },
+  cycles_per_minute: {
+    factor: 1 / 60,
+    // same as RPM
+    symbol: "cpm",
+    singular: "cycle per minute",
+    plural: "cycles per minute"
+  }
+};
+var FREQUENCY_ALIASES = {
+  // terahertz
+  thz: "terahertz",
+  terahertz: "terahertz",
+  // gigahertz
+  ghz: "gigahertz",
+  gigahertz: "gigahertz",
+  // megahertz
+  mhz: "megahertz",
+  megahertz: "megahertz",
+  // kilohertz
+  khz: "kilohertz",
+  kilohertz: "kilohertz",
+  // hertz
+  hz: "hertz",
+  hertz: "hertz",
+  "cycles per second": "hertz",
+  cps: "hertz",
+  // millihertz
+  // Note: "mhz" já é megahertz, usar "milli hz" ou similar
+  millihertz: "millihertz",
+  // microhertz
+  \u03BChz: "microhertz",
+  uhz: "microhertz",
+  microhertz: "microhertz",
+  // rpm
+  rpm: "rpm",
+  "r/min": "rpm",
+  "rev/min": "rpm",
+  "revolutions per minute": "rpm",
+  "revolution per minute": "rpm",
+  rota\u00E7\u00F5es: "rpm",
+  "rota\xE7\xF5es por minuto": "rpm",
+  // bpm
+  bpm: "bpm",
+  "beats per minute": "bpm",
+  "beat per minute": "bpm",
+  batimentos: "bpm",
+  "batimentos por minuto": "bpm",
+  // radians_per_second
+  "rad/s": "radians_per_second",
+  "radian per second": "radians_per_second",
+  "radians per second": "radians_per_second",
+  // cycles_per_minute
+  cpm: "cycles_per_minute",
+  "cycles per minute": "cycles_per_minute",
+  "cycle per minute": "cycles_per_minute"
+};
+Object.fromEntries(
+  Object.entries(FREQUENCY_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/frequency/FrequencyRole.ts
+var FrequencyRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "frequency";
+    this.base = "hertz";
+    this.units = FREQUENCY_UNITS;
+    this.aliases = FREQUENCY_ALIASES;
+    this.validation = {
+      min: 0,
+      minError: "Frequency cannot be negative"
+    };
+  }
+};
+var frequencyRole = new FrequencyRole();
+
+// src/roles/pressure/constants.ts
+var PRESSURE_UNITS = {
+  // SI Units (todos exatos)
+  megapascal: {
+    factor: 1e6,
+    symbol: "MPa",
+    singular: "megapascal",
+    plural: "megapascals"
+  },
+  kilopascal: {
+    factor: 1e3,
+    symbol: "kPa",
+    singular: "kilopascal",
+    plural: "kilopascals"
+  },
+  hectopascal: {
+    factor: 100,
+    symbol: "hPa",
+    singular: "hectopascal",
+    plural: "hectopascals"
+  },
+  pascal: {
+    factor: 1,
+    symbol: "Pa",
+    singular: "pascal",
+    plural: "pascals"
+  },
+  // Bar (exatos por definição)
+  bar: {
+    factor: 1e5,
+    symbol: "bar",
+    singular: "bar",
+    plural: "bar"
+  },
+  millibar: {
+    factor: 100,
+    // = 1 hPa
+    symbol: "mbar",
+    singular: "millibar",
+    plural: "millibar"
+  },
+  // Atmosphere (exato, CGPM 1954)
+  atmosphere: {
+    factor: 101325,
+    symbol: "atm",
+    singular: "atmosphere",
+    plural: "atmospheres"
+  },
+  // Mercury column
+  torr: {
+    factor: 101325 / 760,
+    // ≈ 133.322368421
+    symbol: "Torr",
+    singular: "torr",
+    plural: "torr"
+  },
+  mmhg: {
+    factor: 133.322387415,
+    // Convenção NIST
+    symbol: "mmHg",
+    singular: "millimeter of mercury",
+    plural: "millimeters of mercury"
+  },
+  inhg: {
+    factor: 3386.389,
+    // Polegadas de mercúrio
+    symbol: "inHg",
+    singular: "inch of mercury",
+    plural: "inches of mercury"
+  },
+  // Imperial (derivados de lb/in²)
+  psi: {
+    factor: 6894.757293168,
+    // 1 lbf/in²
+    symbol: "psi",
+    singular: "pound per square inch",
+    plural: "pounds per square inch"
+  },
+  ksi: {
+    factor: 6894757293168e-6,
+    // 1000 psi
+    symbol: "ksi",
+    singular: "kilopound per square inch",
+    plural: "kilopounds per square inch"
+  },
+  // Water column
+  cmh2o: {
+    factor: 98.0665,
+    // cm de água a 4°C
+    symbol: "cmH\u2082O",
+    singular: "centimeter of water",
+    plural: "centimeters of water"
+  },
+  inh2o: {
+    factor: 249.08891,
+    // polegadas de água
+    symbol: "inH\u2082O",
+    singular: "inch of water",
+    plural: "inches of water"
+  }
+};
+var PRESSURE_ALIASES = {
+  // megapascal
+  mpa: "megapascal",
+  megapascal: "megapascal",
+  megapascals: "megapascal",
+  // kilopascal
+  kpa: "kilopascal",
+  kilopascal: "kilopascal",
+  kilopascals: "kilopascal",
+  // hectopascal
+  hpa: "hectopascal",
+  hectopascal: "hectopascal",
+  hectopascals: "hectopascal",
+  // pascal
+  pa: "pascal",
+  pascal: "pascal",
+  pascals: "pascal",
+  // bar
+  bar: "bar",
+  bars: "bar",
+  // millibar
+  mbar: "millibar",
+  millibar: "millibar",
+  millibars: "millibar",
+  mb: "millibar",
+  // atmosphere
+  atm: "atmosphere",
+  atmosphere: "atmosphere",
+  atmospheres: "atmosphere",
+  atmosfera: "atmosphere",
+  atmosferas: "atmosphere",
+  // torr
+  torr: "torr",
+  // mmhg
+  mmhg: "mmhg",
+  "mm hg": "mmhg",
+  "millimeter of mercury": "mmhg",
+  "millimeters of mercury": "mmhg",
+  "mil\xEDmetro de merc\xFArio": "mmhg",
+  "mil\xEDmetros de merc\xFArio": "mmhg",
+  // inhg
+  inhg: "inhg",
+  "in hg": "inhg",
+  "inch of mercury": "inhg",
+  "inches of mercury": "inhg",
+  // psi
+  psi: "psi",
+  "lbf/in\xB2": "psi",
+  "lb/in\xB2": "psi",
+  "pound per square inch": "psi",
+  "pounds per square inch": "psi",
+  // ksi
+  ksi: "ksi",
+  "kilopound per square inch": "ksi",
+  // cmh2o
+  cmh2o: "cmh2o",
+  "cmh\u2082o": "cmh2o",
+  "cm h2o": "cmh2o",
+  "centimeter of water": "cmh2o",
+  "centimeters of water": "cmh2o",
+  // inh2o
+  inh2o: "inh2o",
+  "inh\u2082o": "inh2o",
+  "in h2o": "inh2o",
+  "inch of water": "inh2o",
+  "inches of water": "inh2o"
+};
+Object.fromEntries(
+  Object.entries(PRESSURE_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/pressure/PressureRole.ts
+var PressureRole = class extends SimpleRole {
+  constructor() {
+    super(...arguments);
+    this.name = "pressure";
+    this.base = "pascal";
+    this.units = PRESSURE_UNITS;
+    this.aliases = PRESSURE_ALIASES;
+    this.validation = {
+      min: 0,
+      minError: "Pressure cannot be negative"
+    };
+  }
+};
+var pressureRole = new PressureRole();
+
+// src/roles/color/types.ts
+var NAMED_COLORS = {
+  // Basic colors
+  black: { r: 0, g: 0, b: 0, a: 1 },
+  white: { r: 255, g: 255, b: 255, a: 1 },
+  red: { r: 255, g: 0, b: 0, a: 1 },
+  green: { r: 0, g: 128, b: 0, a: 1 },
+  blue: { r: 0, g: 0, b: 255, a: 1 },
+  yellow: { r: 255, g: 255, b: 0, a: 1 },
+  cyan: { r: 0, g: 255, b: 255, a: 1 },
+  magenta: { r: 255, g: 0, b: 255, a: 1 },
+  // Extended colors
+  orange: { r: 255, g: 165, b: 0, a: 1 },
+  purple: { r: 128, g: 0, b: 128, a: 1 },
+  pink: { r: 255, g: 192, b: 203, a: 1 },
+  brown: { r: 165, g: 42, b: 42, a: 1 },
+  gray: { r: 128, g: 128, b: 128, a: 1 },
+  grey: { r: 128, g: 128, b: 128, a: 1 },
+  // Web colors
+  lime: { r: 0, g: 255, b: 0, a: 1 },
+  aqua: { r: 0, g: 255, b: 255, a: 1 },
+  fuchsia: { r: 255, g: 0, b: 255, a: 1 },
+  silver: { r: 192, g: 192, b: 192, a: 1 },
+  maroon: { r: 128, g: 0, b: 0, a: 1 },
+  olive: { r: 128, g: 128, b: 0, a: 1 },
+  navy: { r: 0, g: 0, b: 128, a: 1 },
+  teal: { r: 0, g: 128, b: 128, a: 1 },
+  // Transparent
+  transparent: { r: 0, g: 0, b: 0, a: 0 }
+};
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function normalizeRgbChannel(value) {
+  return clamp(Math.round(value), 0, 255);
+}
+function normalizeAlpha(value) {
+  if (value === void 0) return 1;
+  return clamp(value, 0, 1);
+}
+function rgbToHsl(r, g, b) {
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) {
+    return { h: 0, s: 0, l: l * 100 };
+  }
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h;
+  switch (max) {
+    case r:
+      h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+      break;
+    case g:
+      h = ((b - r) / d + 2) / 6;
+      break;
+    default:
+      h = ((r - g) / d + 4) / 6;
+      break;
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToRgb(h, s, l) {
+  h /= 360;
+  s /= 100;
+  l /= 100;
+  if (s === 0) {
+    const gray = Math.round(l * 255);
+    return { r: gray, g: gray, b: gray };
+  }
+  const hue2rgb = (p2, q2, t) => {
+    if (t < 0) t += 1;
+    if (t > 1) t -= 1;
+    if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+    if (t < 1 / 2) return q2;
+    if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+    return p2;
+  };
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  return {
+    r: Math.round(hue2rgb(p, q, h + 1 / 3) * 255),
+    g: Math.round(hue2rgb(p, q, h) * 255),
+    b: Math.round(hue2rgb(p, q, h - 1 / 3) * 255)
+  };
+}
+
+// src/roles/color/variants/HexVariant.ts
+var HEX_REGEX_3 = /^#?([0-9a-f])([0-9a-f])([0-9a-f])$/i;
+var HEX_REGEX_4 = /^#?([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])$/i;
+var HEX_REGEX_6 = /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;
+var HEX_REGEX_8 = /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;
+var HexVariant = class extends BaseVariant {
+  constructor() {
+    super(...arguments);
+    this.name = "hex";
+    this.type = "string";
+  }
+  // ===========================================================================
+  // CONVERT
+  // ===========================================================================
+  toBase(value) {
+    const hex = value.trim();
+    let match = hex.match(HEX_REGEX_8);
+    if (match) {
+      return {
+        r: parseInt(match[1], 16),
+        g: parseInt(match[2], 16),
+        b: parseInt(match[3], 16),
+        a: parseInt(match[4], 16) / 255
+      };
+    }
+    match = hex.match(HEX_REGEX_6);
+    if (match) {
+      return {
+        r: parseInt(match[1], 16),
+        g: parseInt(match[2], 16),
+        b: parseInt(match[3], 16),
+        a: 1
+      };
+    }
+    match = hex.match(HEX_REGEX_4);
+    if (match) {
+      return {
+        r: parseInt(match[1] + match[1], 16),
+        g: parseInt(match[2] + match[2], 16),
+        b: parseInt(match[3] + match[3], 16),
+        a: parseInt(match[4] + match[4], 16) / 255
+      };
+    }
+    match = hex.match(HEX_REGEX_3);
+    if (match) {
+      return {
+        r: parseInt(match[1] + match[1], 16),
+        g: parseInt(match[2] + match[2], 16),
+        b: parseInt(match[3] + match[3], 16),
+        a: 1
+      };
+    }
+    throw new Error(`Invalid hex color: ${value}`);
+  }
+  fromBase(base) {
+    const r = normalizeRgbChannel(base.r).toString(16).padStart(2, "0");
+    const g = normalizeRgbChannel(base.g).toString(16).padStart(2, "0");
+    const b = normalizeRgbChannel(base.b).toString(16).padStart(2, "0");
+    const alpha = normalizeAlpha(base.a);
+    if (alpha < 1) {
+      const a = Math.round(alpha * 255).toString(16).padStart(2, "0");
+      return `#${r}${g}${b}${a}`;
+    }
+    return `#${r}${g}${b}`;
+  }
+  // ===========================================================================
+  // CAST
+  // ===========================================================================
+  cast(input) {
+    if (typeof input === "string") {
+      const trimmed = input.trim().toLowerCase();
+      if (NAMED_COLORS[trimmed]) {
+        return this.fromBase(NAMED_COLORS[trimmed]);
+      }
+      if (HEX_REGEX_8.test(trimmed) || HEX_REGEX_6.test(trimmed) || HEX_REGEX_4.test(trimmed) || HEX_REGEX_3.test(trimmed)) {
+        try {
+          const rgba = this.toBase(trimmed);
+          return this.fromBase(rgba);
+        } catch {
+          return null;
+        }
+      }
+      const rgbMatch = trimmed.match(
+        /^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)$/
+      );
+      if (rgbMatch) {
+        const rgba = {
+          r: parseInt(rgbMatch[1], 10),
+          g: parseInt(rgbMatch[2], 10),
+          b: parseInt(rgbMatch[3], 10),
+          a: rgbMatch[4] ? parseFloat(rgbMatch[4]) : 1
+        };
+        return this.fromBase(rgba);
+      }
+      const hslMatch = trimmed.match(
+        /^hsla?\s*\(\s*(\d+)\s*,\s*(\d+)%?\s*,\s*(\d+)%?\s*(?:,\s*([\d.]+))?\s*\)$/
+      );
+      if (hslMatch) {
+        const rgb = hslToRgb(
+          parseInt(hslMatch[1], 10),
+          parseInt(hslMatch[2], 10),
+          parseInt(hslMatch[3], 10)
+        );
+        const rgba = {
+          ...rgb,
+          a: hslMatch[4] ? parseFloat(hslMatch[4]) : 1
+        };
+        return this.fromBase(rgba);
+      }
+      return null;
+    }
+    if (typeof input === "object" && input !== null && "r" in input && "g" in input && "b" in input) {
+      const obj = input;
+      const rgba = {
+        r: obj.r,
+        g: obj.g,
+        b: obj.b,
+        a: obj.a ?? 1
+      };
+      return this.fromBase(rgba);
+    }
+    if (typeof input === "object" && input !== null && "h" in input && "s" in input && "l" in input) {
+      const obj = input;
+      const rgb = hslToRgb(obj.h, obj.s, obj.l);
+      const rgba = {
+        ...rgb,
+        a: obj.a ?? 1
+      };
+      return this.fromBase(rgba);
+    }
+    return null;
+  }
+  // ===========================================================================
+  // VALIDATE
+  // ===========================================================================
+  validate(value) {
+    const errors = [];
+    if (typeof value !== "string") {
+      errors.push("Hex color must be a string");
+      return { valid: false, errors };
+    }
+    const hex = value.trim();
+    if (!HEX_REGEX_8.test(hex) && !HEX_REGEX_6.test(hex) && !HEX_REGEX_4.test(hex) && !HEX_REGEX_3.test(hex)) {
+      errors.push("Invalid hex format. Use #rgb, #rgba, #rrggbb, or #rrggbbaa");
+      return { valid: false, errors };
+    }
+    return { valid: true, errors: [] };
+  }
+  // ===========================================================================
+  // FORMAT
+  // ===========================================================================
+  format(value, options) {
+    const opts = options;
+    try {
+      const rgba = this.toBase(value);
+      let hex = this.fromBase(rgba);
+      if (opts?.uppercase) {
+        hex = hex.toUpperCase();
+      }
+      if (opts?.includeAlpha && rgba.a === 1) {
+        const a = "ff";
+        hex = hex.length === 7 ? `${hex}${opts.uppercase ? "FF" : "ff"}` : hex;
+      }
+      if (opts?.compact && hex.length === 7) {
+        const canShorten = hex[1] === hex[2] && hex[3] === hex[4] && hex[5] === hex[6];
+        if (canShorten) {
+          hex = `#${hex[1]}${hex[3]}${hex[5]}`;
+          if (opts.uppercase) hex = hex.toUpperCase();
+        }
+      }
+      return hex;
+    } catch {
+      return value;
+    }
+  }
+};
+
+// src/roles/color/variants/RgbObjectVariant.ts
+var RgbObjectVariant = class extends BaseVariant {
+  constructor() {
+    super(...arguments);
+    this.name = "rgb_object";
+    this.type = "object";
+  }
+  // ===========================================================================
+  // CONVERT
+  // ===========================================================================
+  toBase(value) {
+    return {
+      r: normalizeRgbChannel(value.r),
+      g: normalizeRgbChannel(value.g),
+      b: normalizeRgbChannel(value.b),
+      a: normalizeAlpha(value.a)
+    };
+  }
+  fromBase(base) {
+    const result = {
+      r: normalizeRgbChannel(base.r),
+      g: normalizeRgbChannel(base.g),
+      b: normalizeRgbChannel(base.b)
+    };
+    if (base.a !== void 0 && base.a < 1) {
+      result.a = normalizeAlpha(base.a);
+    }
+    return result;
+  }
+  // ===========================================================================
+  // CAST
+  // ===========================================================================
+  cast(input) {
+    if (typeof input === "object" && input !== null && "r" in input && "g" in input && "b" in input) {
+      const obj = input;
+      if (typeof obj.r !== "number" || typeof obj.g !== "number" || typeof obj.b !== "number") {
+        return null;
+      }
+      return this.fromBase({
+        r: obj.r,
+        g: obj.g,
+        b: obj.b,
+        a: typeof obj.a === "number" ? obj.a : 1
+      });
+    }
+    if (typeof input === "object" && input !== null && "h" in input && "s" in input && "l" in input) {
+      const obj = input;
+      const rgb = hslToRgb(obj.h, obj.s, obj.l);
+      return this.fromBase({
+        ...rgb,
+        a: obj.a ?? 1
+      });
+    }
+    if (typeof input === "string") {
+      const trimmed = input.trim().toLowerCase();
+      if (NAMED_COLORS[trimmed]) {
+        return this.fromBase(NAMED_COLORS[trimmed]);
+      }
+      const hexMatch = trimmed.match(
+        /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})?$/i
+      );
+      if (hexMatch) {
+        return this.fromBase({
+          r: parseInt(hexMatch[1], 16),
+          g: parseInt(hexMatch[2], 16),
+          b: parseInt(hexMatch[3], 16),
+          a: hexMatch[4] ? parseInt(hexMatch[4], 16) / 255 : 1
+        });
+      }
+      const hexShortMatch = trimmed.match(
+        /^#?([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])?$/i
+      );
+      if (hexShortMatch) {
+        return this.fromBase({
+          r: parseInt(hexShortMatch[1] + hexShortMatch[1], 16),
+          g: parseInt(hexShortMatch[2] + hexShortMatch[2], 16),
+          b: parseInt(hexShortMatch[3] + hexShortMatch[3], 16),
+          a: hexShortMatch[4] ? parseInt(hexShortMatch[4] + hexShortMatch[4], 16) / 255 : 1
+        });
+      }
+      const rgbMatch = trimmed.match(
+        /^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)$/
+      );
+      if (rgbMatch) {
+        return this.fromBase({
+          r: parseInt(rgbMatch[1], 10),
+          g: parseInt(rgbMatch[2], 10),
+          b: parseInt(rgbMatch[3], 10),
+          a: rgbMatch[4] ? parseFloat(rgbMatch[4]) : 1
+        });
+      }
+      const hslMatch = trimmed.match(
+        /^hsla?\s*\(\s*(\d+)\s*,\s*(\d+)%?\s*,\s*(\d+)%?\s*(?:,\s*([\d.]+))?\s*\)$/
+      );
+      if (hslMatch) {
+        const rgb = hslToRgb(
+          parseInt(hslMatch[1], 10),
+          parseInt(hslMatch[2], 10),
+          parseInt(hslMatch[3], 10)
+        );
+        return this.fromBase({
+          ...rgb,
+          a: hslMatch[4] ? parseFloat(hslMatch[4]) : 1
+        });
+      }
+    }
+    return null;
+  }
+  // ===========================================================================
+  // VALIDATE
+  // ===========================================================================
+  validate(value) {
+    const errors = [];
+    if (typeof value !== "object" || value === null) {
+      errors.push("RGB color must be an object");
+      return { valid: false, errors };
+    }
+    if (!("r" in value) || !("g" in value) || !("b" in value)) {
+      errors.push("RGB color must have r, g, b properties");
+      return { valid: false, errors };
+    }
+    if (typeof value.r !== "number" || typeof value.g !== "number" || typeof value.b !== "number") {
+      errors.push("r, g, b must be numbers");
+      return { valid: false, errors };
+    }
+    if (value.r < 0 || value.r > 255) {
+      errors.push("r must be between 0 and 255");
+    }
+    if (value.g < 0 || value.g > 255) {
+      errors.push("g must be between 0 and 255");
+    }
+    if (value.b < 0 || value.b > 255) {
+      errors.push("b must be between 0 and 255");
+    }
+    if (value.a !== void 0) {
+      if (typeof value.a !== "number") {
+        errors.push("a must be a number");
+      } else if (value.a < 0 || value.a > 1) {
+        errors.push("a must be between 0 and 1");
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  // ===========================================================================
+  // FORMAT
+  // ===========================================================================
+  format(value, options) {
+    const opts = options;
+    const rgba = this.toBase(value);
+    const r = rgba.r;
+    const g = rgba.g;
+    const b = rgba.b;
+    const a = rgba.a;
+    if (opts?.includeAlpha || a < 1) {
+      if (opts?.compact) {
+        return `rgba(${r},${g},${b},${a})`;
+      }
+      return `rgba(${r}, ${g}, ${b}, ${a})`;
+    }
+    if (opts?.compact) {
+      return `rgb(${r},${g},${b})`;
+    }
+    return `rgb(${r}, ${g}, ${b})`;
+  }
+};
+
+// src/roles/color/variants/RgbStringVariant.ts
+var RGB_REGEX = /^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i;
+var RGBA_REGEX = /^rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d.]+)\s*\)$/i;
+var RgbStringVariant = class extends BaseVariant {
+  constructor() {
+    super(...arguments);
+    this.name = "rgb_string";
+    this.type = "string";
+  }
+  // ===========================================================================
+  // CONVERT
+  // ===========================================================================
+  toBase(value) {
+    const str = value.trim();
+    let match = str.match(RGBA_REGEX);
+    if (match) {
+      return {
+        r: normalizeRgbChannel(parseInt(match[1], 10)),
+        g: normalizeRgbChannel(parseInt(match[2], 10)),
+        b: normalizeRgbChannel(parseInt(match[3], 10)),
+        a: normalizeAlpha(parseFloat(match[4]))
+      };
+    }
+    match = str.match(RGB_REGEX);
+    if (match) {
+      return {
+        r: normalizeRgbChannel(parseInt(match[1], 10)),
+        g: normalizeRgbChannel(parseInt(match[2], 10)),
+        b: normalizeRgbChannel(parseInt(match[3], 10)),
+        a: 1
+      };
+    }
+    throw new Error(`Invalid rgb string: ${value}`);
+  }
+  fromBase(base) {
+    const r = normalizeRgbChannel(base.r);
+    const g = normalizeRgbChannel(base.g);
+    const b = normalizeRgbChannel(base.b);
+    const a = normalizeAlpha(base.a);
+    if (a < 1) {
+      return `rgba(${r}, ${g}, ${b}, ${a})`;
+    }
+    return `rgb(${r}, ${g}, ${b})`;
+  }
+  // ===========================================================================
+  // CAST
+  // ===========================================================================
+  cast(input) {
+    if (typeof input === "string") {
+      const trimmed = input.trim().toLowerCase();
+      if (NAMED_COLORS[trimmed]) {
+        return this.fromBase(NAMED_COLORS[trimmed]);
+      }
+      if (RGB_REGEX.test(trimmed) || RGBA_REGEX.test(trimmed)) {
+        try {
+          const rgba = this.toBase(trimmed);
+          return this.fromBase(rgba);
+        } catch {
+          return null;
+        }
+      }
+      const hexMatch = trimmed.match(
+        /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})?$/i
+      );
+      if (hexMatch) {
+        return this.fromBase({
+          r: parseInt(hexMatch[1], 16),
+          g: parseInt(hexMatch[2], 16),
+          b: parseInt(hexMatch[3], 16),
+          a: hexMatch[4] ? parseInt(hexMatch[4], 16) / 255 : 1
+        });
+      }
+      const hexShortMatch = trimmed.match(
+        /^#?([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])?$/i
+      );
+      if (hexShortMatch) {
+        return this.fromBase({
+          r: parseInt(hexShortMatch[1] + hexShortMatch[1], 16),
+          g: parseInt(hexShortMatch[2] + hexShortMatch[2], 16),
+          b: parseInt(hexShortMatch[3] + hexShortMatch[3], 16),
+          a: hexShortMatch[4] ? parseInt(hexShortMatch[4] + hexShortMatch[4], 16) / 255 : 1
+        });
+      }
+      const hslMatch = trimmed.match(
+        /^hsla?\s*\(\s*(\d+)\s*,\s*(\d+)%?\s*,\s*(\d+)%?\s*(?:,\s*([\d.]+))?\s*\)$/
+      );
+      if (hslMatch) {
+        const rgb = hslToRgb(
+          parseInt(hslMatch[1], 10),
+          parseInt(hslMatch[2], 10),
+          parseInt(hslMatch[3], 10)
+        );
+        return this.fromBase({
+          ...rgb,
+          a: hslMatch[4] ? parseFloat(hslMatch[4]) : 1
+        });
+      }
+      return null;
+    }
+    if (typeof input === "object" && input !== null && "r" in input && "g" in input && "b" in input) {
+      const obj = input;
+      return this.fromBase({
+        r: obj.r,
+        g: obj.g,
+        b: obj.b,
+        a: obj.a ?? 1
+      });
+    }
+    if (typeof input === "object" && input !== null && "h" in input && "s" in input && "l" in input) {
+      const obj = input;
+      const rgb = hslToRgb(obj.h, obj.s, obj.l);
+      return this.fromBase({
+        ...rgb,
+        a: obj.a ?? 1
+      });
+    }
+    return null;
+  }
+  // ===========================================================================
+  // VALIDATE
+  // ===========================================================================
+  validate(value) {
+    const errors = [];
+    if (typeof value !== "string") {
+      errors.push("RGB string must be a string");
+      return { valid: false, errors };
+    }
+    const str = value.trim();
+    if (!RGB_REGEX.test(str) && !RGBA_REGEX.test(str)) {
+      errors.push('Invalid format. Use "rgb(r, g, b)" or "rgba(r, g, b, a)"');
+      return { valid: false, errors };
+    }
+    try {
+      const rgba = this.toBase(value);
+      if (rgba.r < 0 || rgba.r > 255) {
+        errors.push("Red value must be between 0 and 255");
+      }
+      if (rgba.g < 0 || rgba.g > 255) {
+        errors.push("Green value must be between 0 and 255");
+      }
+      if (rgba.b < 0 || rgba.b > 255) {
+        errors.push("Blue value must be between 0 and 255");
+      }
+      if (rgba.a < 0 || rgba.a > 1) {
+        errors.push("Alpha value must be between 0 and 1");
+      }
+    } catch {
+      errors.push("Invalid RGB string format");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  // ===========================================================================
+  // FORMAT
+  // ===========================================================================
+  format(value, options) {
+    const opts = options;
+    try {
+      const rgba = this.toBase(value);
+      const r = rgba.r;
+      const g = rgba.g;
+      const b = rgba.b;
+      const a = rgba.a;
+      if (opts?.includeAlpha || a < 1) {
+        if (opts?.compact) {
+          return `rgba(${r},${g},${b},${a})`;
+        }
+        return `rgba(${r}, ${g}, ${b}, ${a})`;
+      }
+      if (opts?.compact) {
+        return `rgb(${r},${g},${b})`;
+      }
+      return `rgb(${r}, ${g}, ${b})`;
+    } catch {
+      return value;
+    }
+  }
+};
+
+// src/roles/color/variants/HslObjectVariant.ts
+var HslObjectVariant = class extends BaseVariant {
+  constructor() {
+    super(...arguments);
+    this.name = "hsl_object";
+    this.type = "object";
+  }
+  // ===========================================================================
+  // CONVERT
+  // ===========================================================================
+  toBase(value) {
+    const h = clamp(value.h, 0, 360);
+    const s = clamp(value.s, 0, 100);
+    const l = clamp(value.l, 0, 100);
+    const a = normalizeAlpha(value.a);
+    const rgb = hslToRgb(h, s, l);
+    return {
+      r: rgb.r,
+      g: rgb.g,
+      b: rgb.b,
+      a
+    };
+  }
+  fromBase(base) {
+    const hsl = rgbToHsl(base.r, base.g, base.b);
+    const result = {
+      h: hsl.h,
+      s: hsl.s,
+      l: hsl.l
+    };
+    if (base.a !== void 0 && base.a < 1) {
+      result.a = normalizeAlpha(base.a);
+    }
+    return result;
+  }
+  // ===========================================================================
+  // CAST
+  // ===========================================================================
+  cast(input) {
+    if (typeof input === "object" && input !== null && "h" in input && "s" in input && "l" in input) {
+      const obj = input;
+      if (typeof obj.h !== "number" || typeof obj.s !== "number" || typeof obj.l !== "number") {
+        return null;
+      }
+      const result = {
+        h: clamp(Math.round(obj.h), 0, 360),
+        s: clamp(Math.round(obj.s), 0, 100),
+        l: clamp(Math.round(obj.l), 0, 100)
+      };
+      if (typeof obj.a === "number") {
+        result.a = normalizeAlpha(obj.a);
+      }
+      return result;
+    }
+    if (typeof input === "object" && input !== null && "r" in input && "g" in input && "b" in input) {
+      const obj = input;
+      return this.fromBase({
+        r: obj.r,
+        g: obj.g,
+        b: obj.b,
+        a: obj.a ?? 1
+      });
+    }
+    if (typeof input === "string") {
+      const trimmed = input.trim().toLowerCase();
+      if (NAMED_COLORS[trimmed]) {
+        return this.fromBase(NAMED_COLORS[trimmed]);
+      }
+      const hexMatch = trimmed.match(
+        /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})?$/i
+      );
+      if (hexMatch) {
+        return this.fromBase({
+          r: parseInt(hexMatch[1], 16),
+          g: parseInt(hexMatch[2], 16),
+          b: parseInt(hexMatch[3], 16),
+          a: hexMatch[4] ? parseInt(hexMatch[4], 16) / 255 : 1
+        });
+      }
+      const hexShortMatch = trimmed.match(
+        /^#?([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])?$/i
+      );
+      if (hexShortMatch) {
+        return this.fromBase({
+          r: parseInt(hexShortMatch[1] + hexShortMatch[1], 16),
+          g: parseInt(hexShortMatch[2] + hexShortMatch[2], 16),
+          b: parseInt(hexShortMatch[3] + hexShortMatch[3], 16),
+          a: hexShortMatch[4] ? parseInt(hexShortMatch[4] + hexShortMatch[4], 16) / 255 : 1
+        });
+      }
+      const rgbMatch = trimmed.match(
+        /^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)$/
+      );
+      if (rgbMatch) {
+        return this.fromBase({
+          r: parseInt(rgbMatch[1], 10),
+          g: parseInt(rgbMatch[2], 10),
+          b: parseInt(rgbMatch[3], 10),
+          a: rgbMatch[4] ? parseFloat(rgbMatch[4]) : 1
+        });
+      }
+      const hslMatch = trimmed.match(
+        /^hsla?\s*\(\s*(\d+)\s*,\s*(\d+)%?\s*,\s*(\d+)%?\s*(?:,\s*([\d.]+))?\s*\)$/
+      );
+      if (hslMatch) {
+        const result = {
+          h: clamp(parseInt(hslMatch[1], 10), 0, 360),
+          s: clamp(parseInt(hslMatch[2], 10), 0, 100),
+          l: clamp(parseInt(hslMatch[3], 10), 0, 100)
+        };
+        if (hslMatch[4]) {
+          result.a = normalizeAlpha(parseFloat(hslMatch[4]));
+        }
+        return result;
+      }
+    }
+    return null;
+  }
+  // ===========================================================================
+  // VALIDATE
+  // ===========================================================================
+  validate(value) {
+    const errors = [];
+    if (typeof value !== "object" || value === null) {
+      errors.push("HSL color must be an object");
+      return { valid: false, errors };
+    }
+    if (!("h" in value) || !("s" in value) || !("l" in value)) {
+      errors.push("HSL color must have h, s, l properties");
+      return { valid: false, errors };
+    }
+    if (typeof value.h !== "number" || typeof value.s !== "number" || typeof value.l !== "number") {
+      errors.push("h, s, l must be numbers");
+      return { valid: false, errors };
+    }
+    if (value.h < 0 || value.h > 360) {
+      errors.push("h (hue) must be between 0 and 360");
+    }
+    if (value.s < 0 || value.s > 100) {
+      errors.push("s (saturation) must be between 0 and 100");
+    }
+    if (value.l < 0 || value.l > 100) {
+      errors.push("l (lightness) must be between 0 and 100");
+    }
+    if (value.a !== void 0) {
+      if (typeof value.a !== "number") {
+        errors.push("a must be a number");
+      } else if (value.a < 0 || value.a > 1) {
+        errors.push("a must be between 0 and 1");
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  // ===========================================================================
+  // FORMAT
+  // ===========================================================================
+  format(value, options) {
+    const opts = options;
+    const h = clamp(Math.round(value.h), 0, 360);
+    const s = clamp(Math.round(value.s), 0, 100);
+    const l = clamp(Math.round(value.l), 0, 100);
+    const a = value.a !== void 0 ? normalizeAlpha(value.a) : 1;
+    if (opts?.includeAlpha || a < 1) {
+      if (opts?.compact) {
+        return `hsla(${h},${s}%,${l}%,${a})`;
+      }
+      return `hsla(${h}, ${s}%, ${l}%, ${a})`;
+    }
+    if (opts?.compact) {
+      return `hsl(${h},${s}%,${l}%)`;
+    }
+    return `hsl(${h}, ${s}%, ${l}%)`;
+  }
+};
+
+// src/roles/color/variants/HslStringVariant.ts
+var HSL_REGEX = /^hsl\s*\(\s*(\d+)\s*,\s*(\d+)%?\s*,\s*(\d+)%?\s*\)$/i;
+var HSLA_REGEX = /^hsla\s*\(\s*(\d+)\s*,\s*(\d+)%?\s*,\s*(\d+)%?\s*,\s*([\d.]+)\s*\)$/i;
+var HslStringVariant = class extends BaseVariant {
+  constructor() {
+    super(...arguments);
+    this.name = "hsl_string";
+    this.type = "string";
+  }
+  // ===========================================================================
+  // CONVERT
+  // ===========================================================================
+  toBase(value) {
+    const str = value.trim();
+    let match = str.match(HSLA_REGEX);
+    if (match) {
+      const h = clamp(parseInt(match[1], 10), 0, 360);
+      const s = clamp(parseInt(match[2], 10), 0, 100);
+      const l = clamp(parseInt(match[3], 10), 0, 100);
+      const a = normalizeAlpha(parseFloat(match[4]));
+      const rgb = hslToRgb(h, s, l);
+      return { ...rgb, a };
+    }
+    match = str.match(HSL_REGEX);
+    if (match) {
+      const h = clamp(parseInt(match[1], 10), 0, 360);
+      const s = clamp(parseInt(match[2], 10), 0, 100);
+      const l = clamp(parseInt(match[3], 10), 0, 100);
+      const rgb = hslToRgb(h, s, l);
+      return { ...rgb, a: 1 };
+    }
+    throw new Error(`Invalid hsl string: ${value}`);
+  }
+  fromBase(base) {
+    const hsl = rgbToHsl(base.r, base.g, base.b);
+    const a = normalizeAlpha(base.a);
+    if (a < 1) {
+      return `hsla(${hsl.h}, ${hsl.s}%, ${hsl.l}%, ${a})`;
+    }
+    return `hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%)`;
+  }
+  // ===========================================================================
+  // CAST
+  // ===========================================================================
+  cast(input) {
+    if (typeof input === "string") {
+      const trimmed = input.trim().toLowerCase();
+      if (NAMED_COLORS[trimmed]) {
+        return this.fromBase(NAMED_COLORS[trimmed]);
+      }
+      if (HSL_REGEX.test(trimmed) || HSLA_REGEX.test(trimmed)) {
+        try {
+          const rgba = this.toBase(trimmed);
+          return this.fromBase(rgba);
+        } catch {
+          return null;
+        }
+      }
+      const hexMatch = trimmed.match(
+        /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})?$/i
+      );
+      if (hexMatch) {
+        return this.fromBase({
+          r: parseInt(hexMatch[1], 16),
+          g: parseInt(hexMatch[2], 16),
+          b: parseInt(hexMatch[3], 16),
+          a: hexMatch[4] ? parseInt(hexMatch[4], 16) / 255 : 1
+        });
+      }
+      const hexShortMatch = trimmed.match(
+        /^#?([0-9a-f])([0-9a-f])([0-9a-f])([0-9a-f])?$/i
+      );
+      if (hexShortMatch) {
+        return this.fromBase({
+          r: parseInt(hexShortMatch[1] + hexShortMatch[1], 16),
+          g: parseInt(hexShortMatch[2] + hexShortMatch[2], 16),
+          b: parseInt(hexShortMatch[3] + hexShortMatch[3], 16),
+          a: hexShortMatch[4] ? parseInt(hexShortMatch[4] + hexShortMatch[4], 16) / 255 : 1
+        });
+      }
+      const rgbMatch = trimmed.match(
+        /^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)$/
+      );
+      if (rgbMatch) {
+        return this.fromBase({
+          r: parseInt(rgbMatch[1], 10),
+          g: parseInt(rgbMatch[2], 10),
+          b: parseInt(rgbMatch[3], 10),
+          a: rgbMatch[4] ? parseFloat(rgbMatch[4]) : 1
+        });
+      }
+      return null;
+    }
+    if (typeof input === "object" && input !== null && "r" in input && "g" in input && "b" in input) {
+      const obj = input;
+      return this.fromBase({
+        r: obj.r,
+        g: obj.g,
+        b: obj.b,
+        a: obj.a ?? 1
+      });
+    }
+    if (typeof input === "object" && input !== null && "h" in input && "s" in input && "l" in input) {
+      const obj = input;
+      const rgb = hslToRgb(obj.h, obj.s, obj.l);
+      return this.fromBase({
+        ...rgb,
+        a: obj.a ?? 1
+      });
+    }
+    return null;
+  }
+  // ===========================================================================
+  // VALIDATE
+  // ===========================================================================
+  validate(value) {
+    const errors = [];
+    if (typeof value !== "string") {
+      errors.push("HSL string must be a string");
+      return { valid: false, errors };
+    }
+    const str = value.trim();
+    if (!HSL_REGEX.test(str) && !HSLA_REGEX.test(str)) {
+      errors.push(
+        'Invalid format. Use "hsl(h, s%, l%)" or "hsla(h, s%, l%, a)"'
+      );
+      return { valid: false, errors };
+    }
+    try {
+      const rgba = this.toBase(value);
+      const hsl = rgbToHsl(rgba.r, rgba.g, rgba.b);
+      if (hsl.h < 0 || hsl.h > 360) {
+        errors.push("Hue must be between 0 and 360");
+      }
+      if (hsl.s < 0 || hsl.s > 100) {
+        errors.push("Saturation must be between 0 and 100");
+      }
+      if (hsl.l < 0 || hsl.l > 100) {
+        errors.push("Lightness must be between 0 and 100");
+      }
+      if (rgba.a < 0 || rgba.a > 1) {
+        errors.push("Alpha must be between 0 and 1");
+      }
+    } catch {
+      errors.push("Invalid HSL string format");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  // ===========================================================================
+  // FORMAT
+  // ===========================================================================
+  format(value, options) {
+    const opts = options;
+    try {
+      const rgba = this.toBase(value);
+      const hsl = rgbToHsl(rgba.r, rgba.g, rgba.b);
+      const a = rgba.a;
+      if (opts?.includeAlpha || a < 1) {
+        if (opts?.compact) {
+          return `hsla(${hsl.h},${hsl.s}%,${hsl.l}%,${a})`;
+        }
+        return `hsla(${hsl.h}, ${hsl.s}%, ${hsl.l}%, ${a})`;
+      }
+      if (opts?.compact) {
+        return `hsl(${hsl.h},${hsl.s}%,${hsl.l}%)`;
+      }
+      return `hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%)`;
+    } catch {
+      return value;
+    }
+  }
+};
+
+// src/roles/color/ColorRole.ts
+var ColorRole = class extends ComplexRole {
+  constructor() {
+    super(...arguments);
+    this.name = "color";
+    this.base = "rgb_object";
+  }
+  createVariants() {
+    return {
+      hex: new HexVariant(),
+      rgb_object: new RgbObjectVariant(),
+      rgb_string: new RgbStringVariant(),
+      hsl_object: new HslObjectVariant(),
+      hsl_string: new HslStringVariant()
+    };
+  }
+  /**
+   * Override format to accept ColorFormatOptions
+   */
+  format(variant, value, options) {
+    return super.format(variant, value, options);
+  }
+};
+var colorRole = new ColorRole();
+
+exports.AngleRole = AngleRole;
+exports.AreaRole = AreaRole;
+exports.ColorRole = ColorRole;
+exports.DateRole = DateRole;
+exports.DigitalRole = DigitalRole;
+exports.EnergyRole = EnergyRole;
+exports.FrequencyRole = FrequencyRole;
+exports.LengthRole = LengthRole;
+exports.MassRole = MassRole;
+exports.PowerRole = PowerRole;
+exports.PressureRole = PressureRole;
+exports.RoleMorphic = RoleMorphic;
+exports.SpeedRole = SpeedRole;
+exports.TemperatureRole = TemperatureRole;
+exports.TimeRole = TimeRole;
+exports.VolumeRole = VolumeRole;
+exports.angleRole = angleRole;
+exports.areaRole = areaRole;
+exports.colorRole = colorRole;
+exports.dateRole = dateRole;
+exports.digitalRole = digitalRole;
+exports.energyRole = energyRole;
+exports.frequencyRole = frequencyRole;
+exports.lengthRole = lengthRole;
+exports.massRole = massRole;
+exports.powerRole = powerRole;
+exports.pressureRole = pressureRole;
+exports.speedRole = speedRole;
+exports.temperatureRole = temperatureRole;
+exports.timeRole = timeRole;
+exports.volumeRole = volumeRole;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map