@attrx/role-morphic 0.1.0 → 0.2.0

package/dist/cast.js

@@ -0,0 +1,3569 @@
+'use strict';
+
+// 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",
+  // hectare
+  ha: "hectare",
+  // are
+  a: "are",
+  // square_meter
+  "m\xB2": "square_meter",
+  m2: "square_meter",
+  // square_decimeter
+  "dm\xB2": "square_decimeter",
+  dm2: "square_decimeter",
+  // square_centimeter
+  "cm\xB2": "square_centimeter",
+  cm2: "square_centimeter",
+  // square_millimeter
+  "mm\xB2": "square_millimeter",
+  mm2: "square_millimeter",
+  // square_mile
+  "mi\xB2": "square_mile",
+  mi2: "square_mile",
+  // acre
+  ac: "acre",
+  // square_yard
+  "yd\xB2": "square_yard",
+  yd2: "square_yard",
+  // square_foot
+  "ft\xB2": "square_foot",
+  ft2: "square_foot",
+  // square_inch
+  "in\xB2": "square_inch",
+  in2: "square_inch"
+};
+Object.fromEntries(
+  Object.entries(AREA_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/area/convert.ts
+function toBaseArea(variant, value) {
+  const unit = AREA_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown area variant: ${variant}`);
+  }
+  return value * (unit.factor ?? 1);
+}
+function fromBaseArea(variant, baseValue) {
+  const unit = AREA_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown area variant: ${variant}`);
+  }
+  return baseValue / (unit.factor ?? 1);
+}
+function convertArea(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseArea(from, value);
+  return fromBaseArea(to, baseValue);
+}
+
+// src/roles/area/cast.ts
+function castArea(input, targetVariant = "square_meter") {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    return parseAreaString(input, targetVariant);
+  }
+  return null;
+}
+function tryCastArea(input, targetVariant = "square_meter") {
+  const result = castArea(input, targetVariant);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to area:${targetVariant}`
+    };
+  }
+  return { ok: true, value: result };
+}
+function parseAreaString(input, targetVariant) {
+  const trimmed = input.trim().toLowerCase();
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const [, numStr, unitStr] = match;
+  const numValue = parseNumber(numStr);
+  if (numValue === null) {
+    return null;
+  }
+  const cleanUnitStr = unitStr.trim();
+  if (cleanUnitStr) {
+    const detectedUnit = detectUnit(cleanUnitStr);
+    if (detectedUnit && detectedUnit !== targetVariant) {
+      return convertArea(detectedUnit, targetVariant, numValue);
+    }
+  }
+  return numValue;
+}
+function 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;
+}
+function detectUnit(unitStr) {
+  const normalized = unitStr.toLowerCase().trim();
+  if (normalized in AREA_ALIASES) {
+    return AREA_ALIASES[normalized];
+  }
+  for (const [variant, config] of Object.entries(AREA_UNITS)) {
+    if (config.symbol.toLowerCase() === normalized || config.singular?.toLowerCase() === normalized || config.plural?.toLowerCase() === normalized || variant.toLowerCase() === normalized) {
+      return variant;
+    }
+  }
+  return null;
+}
+
+// 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",
+  // hectometer
+  hm: "hectometer",
+  // decameter
+  dam: "decameter",
+  // meter
+  m: "meter",
+  // decimeter
+  dm: "decimeter",
+  // centimeter
+  cm: "centimeter",
+  // millimeter
+  mm: "millimeter",
+  // micrometer
+  "\u03BCm": "micrometer",
+  um: "micrometer",
+  // nanometer
+  nm: "nanometer",
+  // inch
+  in: "inch",
+  '"': "inch",
+  // foot
+  ft: "foot",
+  "'": "foot",
+  // yard
+  yd: "yard",
+  // mile
+  mi: "mile",
+  // nautical_mile
+  nmi: "nautical_mile",
+  // fathom
+  ftm: "fathom",
+  // furlong
+  fur: "furlong",
+  // league
+  lea: "league"
+};
+Object.fromEntries(
+  Object.entries(LENGTH_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/length/convert.ts
+function toBaseLength(variant, value) {
+  const unit = LENGTH_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown length variant: ${variant}`);
+  }
+  return value * (unit.factor ?? 1);
+}
+function fromBaseLength(variant, baseValue) {
+  const unit = LENGTH_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown length variant: ${variant}`);
+  }
+  return baseValue / (unit.factor ?? 1);
+}
+function convertLength(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseLength(from, value);
+  return fromBaseLength(to, baseValue);
+}
+
+// src/roles/length/cast.ts
+function castLength(input, targetVariant = "meter") {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    return parseLengthString(input, targetVariant);
+  }
+  return null;
+}
+function tryCastLength(input, targetVariant = "meter") {
+  const result = castLength(input, targetVariant);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to length:${targetVariant}`
+    };
+  }
+  return { ok: true, value: result };
+}
+function parseLengthString(input, targetVariant) {
+  const trimmed = input.trim().toLowerCase();
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const [, numStr, unitStr] = match;
+  const numValue = parseNumber2(numStr);
+  if (numValue === null) {
+    return null;
+  }
+  const cleanUnitStr = unitStr.trim();
+  if (cleanUnitStr) {
+    const detectedUnit = detectUnit2(cleanUnitStr);
+    if (detectedUnit && detectedUnit !== targetVariant) {
+      return convertLength(detectedUnit, targetVariant, numValue);
+    }
+  }
+  return numValue;
+}
+function parseNumber2(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;
+}
+function detectUnit2(unitStr) {
+  const normalized = unitStr.toLowerCase().trim();
+  if (normalized in LENGTH_ALIASES) {
+    return LENGTH_ALIASES[normalized];
+  }
+  for (const [variant, config] of Object.entries(LENGTH_UNITS)) {
+    if (config.symbol.toLowerCase() === normalized || config.singular?.toLowerCase() === normalized || config.plural?.toLowerCase() === normalized || variant.toLowerCase() === normalized) {
+      return variant;
+    }
+  }
+  return null;
+}
+
+// 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",
+  // kilogram
+  kg: "kilogram",
+  // hectogram
+  hg: "hectogram",
+  // decagram
+  dag: "decagram",
+  // gram
+  g: "gram",
+  // decigram
+  dg: "decigram",
+  // centigram
+  cg: "centigram",
+  // milligram
+  mg: "milligram",
+  // microgram
+  "\u03BCg": "microgram",
+  ug: "microgram",
+  mcg: "microgram",
+  // long_ton
+  "long tn": "long_ton",
+  // short_ton
+  "sh tn": "short_ton",
+  // stone
+  st: "stone",
+  // pound
+  lb: "pound",
+  lbs: "pound",
+  "#": "pound",
+  // ounce
+  oz: "ounce",
+  // dram
+  dr: "dram",
+  // grain
+  gr: "grain",
+  // troy_pound
+  "lb t": "troy_pound",
+  // troy_ounce
+  "oz t": "troy_ounce",
+  ozt: "troy_ounce",
+  // pennyweight
+  dwt: "pennyweight"
+};
+Object.fromEntries(
+  Object.entries(MASS_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/mass/convert.ts
+function toBaseMass(variant, value) {
+  const unit = MASS_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown mass variant: ${variant}`);
+  }
+  return value * (unit.factor ?? 1);
+}
+function fromBaseMass(variant, baseValue) {
+  const unit = MASS_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown mass variant: ${variant}`);
+  }
+  return baseValue / (unit.factor ?? 1);
+}
+function convertMass(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseMass(from, value);
+  return fromBaseMass(to, baseValue);
+}
+
+// src/roles/mass/cast.ts
+function castMass(input, targetVariant = "kilogram") {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    return parseMassString(input, targetVariant);
+  }
+  return null;
+}
+function tryCastMass(input, targetVariant = "kilogram") {
+  const result = castMass(input, targetVariant);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to mass:${targetVariant}`
+    };
+  }
+  return { ok: true, value: result };
+}
+function parseMassString(input, targetVariant) {
+  const trimmed = input.trim().toLowerCase();
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const [, numStr, unitStr] = match;
+  const numValue = parseNumber3(numStr);
+  if (numValue === null) {
+    return null;
+  }
+  const cleanUnitStr = unitStr.trim();
+  if (cleanUnitStr) {
+    const detectedUnit = detectUnit3(cleanUnitStr);
+    if (detectedUnit && detectedUnit !== targetVariant) {
+      return convertMass(detectedUnit, targetVariant, numValue);
+    }
+  }
+  return numValue;
+}
+function parseNumber3(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;
+}
+function detectUnit3(unitStr) {
+  const normalized = unitStr.toLowerCase().trim();
+  if (normalized in MASS_ALIASES) {
+    return MASS_ALIASES[normalized];
+  }
+  for (const [variant, config] of Object.entries(MASS_UNITS)) {
+    if (config.symbol.toLowerCase() === normalized || config.singular?.toLowerCase() === normalized || config.plural?.toLowerCase() === normalized || variant.toLowerCase() === normalized) {
+      return variant;
+    }
+  }
+  return null;
+}
+
+// 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",
+  // fahrenheit
+  f: "fahrenheit",
+  "\xB0f": "fahrenheit",
+  // kelvin
+  k: "kelvin",
+  // rankine
+  r: "rankine",
+  "\xB0r": "rankine"
+};
+
+// src/roles/temperature/convert.ts
+function toBaseTemperature(variant, value) {
+  const unit = TEMPERATURE_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown temperature variant: ${variant}`);
+  }
+  if (unit.toBase) {
+    return unit.toBase(value);
+  }
+  return value * (unit.factor ?? 1);
+}
+function fromBaseTemperature(variant, baseValue) {
+  const unit = TEMPERATURE_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown temperature variant: ${variant}`);
+  }
+  if (unit.fromBase) {
+    return unit.fromBase(baseValue);
+  }
+  return baseValue / (unit.factor ?? 1);
+}
+function convertTemperature(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseTemperature(from, value);
+  return fromBaseTemperature(to, baseValue);
+}
+
+// src/roles/temperature/cast.ts
+function castTemperature(input, targetVariant = "celsius") {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    return parseTemperatureString(input, targetVariant);
+  }
+  return null;
+}
+function tryCastTemperature(input, targetVariant = "celsius") {
+  const result = castTemperature(input, targetVariant);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to temperature:${targetVariant}`
+    };
+  }
+  return { ok: true, value: result };
+}
+function parseTemperatureString(input, targetVariant) {
+  const trimmed = input.trim().toLowerCase();
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const [, numStr, unitStr] = match;
+  const numValue = parseNumber4(numStr);
+  if (numValue === null) {
+    return null;
+  }
+  const cleanUnitStr = unitStr.trim();
+  if (cleanUnitStr) {
+    const detectedUnit = detectUnit4(cleanUnitStr);
+    if (detectedUnit && detectedUnit !== targetVariant) {
+      return convertTemperature(detectedUnit, targetVariant, numValue);
+    }
+  }
+  return numValue;
+}
+function parseNumber4(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;
+}
+function detectUnit4(unitStr) {
+  const normalized = unitStr.toLowerCase().trim();
+  if (normalized in TEMPERATURE_ALIASES) {
+    return TEMPERATURE_ALIASES[normalized];
+  }
+  for (const [variant, config] of Object.entries(TEMPERATURE_UNITS)) {
+    if (config.symbol.toLowerCase() === normalized || config.singular?.toLowerCase() === normalized || config.plural?.toLowerCase() === normalized || variant.toLowerCase() === normalized) {
+      return variant;
+    }
+  }
+  return null;
+}
+
+// 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_decimeter
+  "dm\xB3": "cubic_decimeter",
+  dm3: "cubic_decimeter",
+  // cubic_centimeter
+  "cm\xB3": "cubic_centimeter",
+  cm3: "cubic_centimeter",
+  cc: "cubic_centimeter",
+  // cubic_millimeter
+  "mm\xB3": "cubic_millimeter",
+  mm3: "cubic_millimeter",
+  // hectoliter
+  hL: "hectoliter",
+  hl: "hectoliter",
+  // decaliter
+  daL: "decaliter",
+  dal: "decaliter",
+  // liter
+  L: "liter",
+  l: "liter",
+  // deciliter
+  dL: "deciliter",
+  dl: "deciliter",
+  // centiliter
+  cL: "centiliter",
+  cl: "centiliter",
+  // milliliter
+  mL: "milliliter",
+  ml: "milliliter",
+  // microliter
+  "\u03BCL": "microliter",
+  uL: "microliter",
+  ul: "microliter",
+  // gallon_us
+  gal: "gallon_us",
+  // quart_us
+  qt: "quart_us",
+  // pint_us
+  pt: "pint_us",
+  // cup_us
+  cup: "cup_us",
+  // fluid_ounce_us
+  "fl oz": "fluid_ounce_us",
+  floz: "fluid_ounce_us",
+  // tablespoon_us
+  tbsp: "tablespoon_us",
+  // teaspoon_us
+  tsp: "teaspoon_us",
+  // gallon_uk
+  "gal uk": "gallon_uk",
+  // quart_uk
+  "qt uk": "quart_uk",
+  // pint_uk
+  "pt uk": "pint_uk",
+  // fluid_ounce_uk
+  "fl oz uk": "fluid_ounce_uk",
+  // barrel_oil
+  bbl: "barrel_oil",
+  // cubic_inch
+  "in\xB3": "cubic_inch",
+  in3: "cubic_inch",
+  // cubic_foot
+  "ft\xB3": "cubic_foot",
+  ft3: "cubic_foot",
+  // cubic_yard
+  "yd\xB3": "cubic_yard",
+  yd3: "cubic_yard"
+};
+Object.fromEntries(
+  Object.entries(VOLUME_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/volume/convert.ts
+function toBaseVolume(variant, value) {
+  const unit = VOLUME_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown volume variant: ${variant}`);
+  }
+  return value * (unit.factor ?? 1);
+}
+function fromBaseVolume(variant, baseValue) {
+  const unit = VOLUME_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown volume variant: ${variant}`);
+  }
+  return baseValue / (unit.factor ?? 1);
+}
+function convertVolume(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseVolume(from, value);
+  return fromBaseVolume(to, baseValue);
+}
+
+// src/roles/volume/cast.ts
+function castVolume(input, targetVariant = "liter") {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    return parseVolumeString(input, targetVariant);
+  }
+  return null;
+}
+function tryCastVolume(input, targetVariant = "liter") {
+  const result = castVolume(input, targetVariant);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to volume:${targetVariant}`
+    };
+  }
+  return { ok: true, value: result };
+}
+function parseVolumeString(input, targetVariant) {
+  const trimmed = input.trim().toLowerCase();
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const [, numStr, unitStr] = match;
+  const numValue = parseNumber5(numStr);
+  if (numValue === null) {
+    return null;
+  }
+  const cleanUnitStr = unitStr.trim();
+  if (cleanUnitStr) {
+    const detectedUnit = detectUnit5(cleanUnitStr);
+    if (detectedUnit && detectedUnit !== targetVariant) {
+      return convertVolume(detectedUnit, targetVariant, numValue);
+    }
+  }
+  return numValue;
+}
+function parseNumber5(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;
+}
+function detectUnit5(unitStr) {
+  const normalized = unitStr.toLowerCase().trim();
+  if (normalized in VOLUME_ALIASES) {
+    return VOLUME_ALIASES[normalized];
+  }
+  for (const [variant, config] of Object.entries(VOLUME_UNITS)) {
+    if (config.symbol.toLowerCase() === normalized || config.singular?.toLowerCase() === normalized || config.plural?.toLowerCase() === normalized || variant.toLowerCase() === normalized) {
+      return variant;
+    }
+  }
+  return null;
+}
+
+// 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",
+  // kilometer_per_hour
+  "km/h": "kilometer_per_hour",
+  kmh: "kilometer_per_hour",
+  kph: "kilometer_per_hour",
+  // mile_per_hour
+  mph: "mile_per_hour",
+  "mi/h": "mile_per_hour",
+  // foot_per_second
+  "ft/s": "foot_per_second",
+  fps: "foot_per_second",
+  // knot
+  kn: "knot",
+  kt: "knot",
+  kts: "knot",
+  // mach
+  ma: "mach",
+  // speed_of_light
+  c: "speed_of_light"
+};
+Object.fromEntries(
+  Object.entries(SPEED_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/speed/convert.ts
+function toBaseSpeed(variant, value) {
+  const unit = SPEED_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown speed variant: ${variant}`);
+  }
+  return value * (unit.factor ?? 1);
+}
+function fromBaseSpeed(variant, baseValue) {
+  const unit = SPEED_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown speed variant: ${variant}`);
+  }
+  return baseValue / (unit.factor ?? 1);
+}
+function convertSpeed(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseSpeed(from, value);
+  return fromBaseSpeed(to, baseValue);
+}
+
+// src/roles/speed/cast.ts
+function castSpeed(input, targetVariant = "meter_per_second") {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    return parseSpeedString(input, targetVariant);
+  }
+  return null;
+}
+function tryCastSpeed(input, targetVariant = "meter_per_second") {
+  const result = castSpeed(input, targetVariant);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to speed:${targetVariant}`
+    };
+  }
+  return { ok: true, value: result };
+}
+function parseSpeedString(input, targetVariant) {
+  const trimmed = input.trim().toLowerCase();
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const [, numStr, unitStr] = match;
+  const numValue = parseNumber6(numStr);
+  if (numValue === null) {
+    return null;
+  }
+  const cleanUnitStr = unitStr.trim();
+  if (cleanUnitStr) {
+    const detectedUnit = detectUnit6(cleanUnitStr);
+    if (detectedUnit && detectedUnit !== targetVariant) {
+      return convertSpeed(detectedUnit, targetVariant, numValue);
+    }
+  }
+  return numValue;
+}
+function parseNumber6(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;
+}
+function detectUnit6(unitStr) {
+  const normalized = unitStr.toLowerCase().trim();
+  if (normalized in SPEED_ALIASES) {
+    return SPEED_ALIASES[normalized];
+  }
+  for (const [variant, config] of Object.entries(SPEED_UNITS)) {
+    if (config.symbol.toLowerCase() === normalized || config.singular?.toLowerCase() === normalized || config.plural?.toLowerCase() === normalized || variant.toLowerCase() === normalized) {
+      return variant;
+    }
+  }
+  return null;
+}
+
+// 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",
+  // megajoule
+  mj: "megajoule",
+  // kilojoule
+  kj: "kilojoule",
+  // joule
+  j: "joule",
+  // calorie
+  cal: "calorie",
+  // kilocalorie
+  kcal: "kilocalorie",
+  Cal: "kilocalorie",
+  // watt_hour
+  wh: "watt_hour",
+  // kilowatt_hour
+  kwh: "kilowatt_hour",
+  // megawatt_hour
+  mwh: "megawatt_hour",
+  // gigawatt_hour
+  gwh: "gigawatt_hour",
+  // btu
+  btu: "btu",
+  // therm
+  thm: "therm",
+  // electronvolt
+  ev: "electronvolt",
+  // kiloelectronvolt
+  kev: "kiloelectronvolt",
+  // megaelectronvolt
+  mev: "megaelectronvolt",
+  // erg
+  erg: "erg",
+  // foot_pound
+  "ft-lb": "foot_pound",
+  "ft-lbf": "foot_pound"
+};
+Object.fromEntries(
+  Object.entries(ENERGY_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/energy/convert.ts
+function toBaseEnergy(variant, value) {
+  const unit = ENERGY_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown energy variant: ${variant}`);
+  }
+  return value * (unit.factor ?? 1);
+}
+function fromBaseEnergy(variant, baseValue) {
+  const unit = ENERGY_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown energy variant: ${variant}`);
+  }
+  return baseValue / (unit.factor ?? 1);
+}
+function convertEnergy(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseEnergy(from, value);
+  return fromBaseEnergy(to, baseValue);
+}
+
+// src/roles/energy/cast.ts
+function castEnergy(input, targetVariant = "joule") {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    return parseEnergyString(input, targetVariant);
+  }
+  return null;
+}
+function tryCastEnergy(input, targetVariant = "joule") {
+  const result = castEnergy(input, targetVariant);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to energy:${targetVariant}`
+    };
+  }
+  return { ok: true, value: result };
+}
+function parseEnergyString(input, targetVariant) {
+  const trimmed = input.trim().toLowerCase();
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const [, numStr, unitStr] = match;
+  const numValue = parseNumber7(numStr);
+  if (numValue === null) {
+    return null;
+  }
+  const cleanUnitStr = unitStr.trim();
+  if (cleanUnitStr) {
+    const detectedUnit = detectUnit7(cleanUnitStr);
+    if (detectedUnit && detectedUnit !== targetVariant) {
+      return convertEnergy(detectedUnit, targetVariant, numValue);
+    }
+  }
+  return numValue;
+}
+function parseNumber7(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;
+}
+function detectUnit7(unitStr) {
+  const normalized = unitStr.toLowerCase().trim();
+  if (normalized in ENERGY_ALIASES) {
+    return ENERGY_ALIASES[normalized];
+  }
+  for (const [variant, config] of Object.entries(ENERGY_UNITS)) {
+    if (config.symbol.toLowerCase() === normalized || config.singular?.toLowerCase() === normalized || config.plural?.toLowerCase() === normalized || variant.toLowerCase() === normalized) {
+      return variant;
+    }
+  }
+  return null;
+}
+
+// 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",
+  // megawatt
+  mw: "megawatt",
+  // kilowatt
+  kw: "kilowatt",
+  // watt
+  w: "watt",
+  // microwatt
+  "\u03BCw": "microwatt",
+  uw: "microwatt",
+  // horsepower_mechanical
+  hp: "horsepower_mechanical",
+  // horsepower_metric
+  ps: "horsepower_metric",
+  cv: "horsepower_metric",
+  // horsepower_electric
+  "hp(e)": "horsepower_electric",
+  // horsepower_boiler
+  "hp(s)": "horsepower_boiler",
+  bhp: "horsepower_boiler",
+  // btu_per_hour
+  "btu/h": "btu_per_hour",
+  "btu/hr": "btu_per_hour",
+  // btu_per_second
+  "btu/s": "btu_per_second",
+  // ton_of_refrigeration
+  tr: "ton_of_refrigeration",
+  rt: "ton_of_refrigeration",
+  // foot_pound_per_second
+  "ft-lb/s": "foot_pound_per_second",
+  "ft-lbf/s": "foot_pound_per_second",
+  // calorie_per_second
+  "cal/s": "calorie_per_second",
+  // kilocalorie_per_hour
+  "kcal/h": "kilocalorie_per_hour",
+  "kcal/hr": "kilocalorie_per_hour"
+};
+Object.fromEntries(
+  Object.entries(POWER_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/power/convert.ts
+var POWER_BASE = "watt";
+function toBasePower(variant, value) {
+  const config = POWER_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown power unit: ${variant}`);
+  }
+  return value * (config.factor ?? 1);
+}
+function fromBasePower(variant, baseValue) {
+  const config = POWER_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown power unit: ${variant}`);
+  }
+  return baseValue / (config.factor ?? 1);
+}
+function convertPower(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBasePower(from, value);
+  return fromBasePower(to, baseValue);
+}
+
+// src/roles/power/cast.ts
+function castPower(input, targetVariant = POWER_BASE) {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    const parsed = parsePowerString(input);
+    if (parsed === null) {
+      return null;
+    }
+    if (parsed.unit && parsed.unit !== targetVariant) {
+      return convertPower(parsed.unit, targetVariant, parsed.value);
+    }
+    return parsed.value;
+  }
+  return null;
+}
+function tryCastPower(input, targetVariant = POWER_BASE) {
+  const result = castPower(input, targetVariant);
+  if (result === null) {
+    return { ok: false, error: `Cannot cast "${String(input)}" to power` };
+  }
+  return { ok: true, value: result };
+}
+function parsePowerString(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const numStr = match[1].replace(/\s/g, "").replace(",", ".");
+  const value = parseFloat(numStr);
+  if (isNaN(value) || !Number.isFinite(value)) {
+    return null;
+  }
+  const unitStr = match[2]?.trim().toLowerCase() || "";
+  let unit = null;
+  if (unitStr) {
+    if (unitStr in POWER_ALIASES) {
+      unit = POWER_ALIASES[unitStr];
+    } else if (unitStr in POWER_UNITS) {
+      unit = unitStr;
+    } else {
+      for (const [u, config] of Object.entries(POWER_UNITS)) {
+        if (config.symbol.toLowerCase() === unitStr) {
+          unit = u;
+          break;
+        }
+      }
+    }
+  }
+  return { value, unit };
+}
+
+// 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",
+  // kilopascal
+  kpa: "kilopascal",
+  // hectopascal
+  hpa: "hectopascal",
+  // pascal
+  pa: "pascal",
+  // bar
+  bar: "bar",
+  // millibar
+  mbar: "millibar",
+  mb: "millibar",
+  // atmosphere
+  atm: "atmosphere",
+  // torr
+  torr: "torr",
+  // mmhg
+  mmhg: "mmhg",
+  // inhg
+  inhg: "inhg",
+  // psi
+  psi: "psi",
+  // ksi
+  ksi: "ksi",
+  // cmh2o
+  cmh2o: "cmh2o",
+  // inh2o
+  inh2o: "inh2o"
+};
+Object.fromEntries(
+  Object.entries(PRESSURE_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/pressure/convert.ts
+var PRESSURE_BASE = "pascal";
+function toBasePressure(variant, value) {
+  const config = PRESSURE_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown pressure unit: ${variant}`);
+  }
+  return value * (config.factor ?? 1);
+}
+function fromBasePressure(variant, baseValue) {
+  const config = PRESSURE_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown pressure unit: ${variant}`);
+  }
+  return baseValue / (config.factor ?? 1);
+}
+function convertPressure(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBasePressure(from, value);
+  return fromBasePressure(to, baseValue);
+}
+
+// src/roles/pressure/cast.ts
+function castPressure(input, targetVariant = PRESSURE_BASE) {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    const parsed = parsePressureString(input);
+    if (parsed === null) {
+      return null;
+    }
+    if (parsed.unit && parsed.unit !== targetVariant) {
+      return convertPressure(parsed.unit, targetVariant, parsed.value);
+    }
+    return parsed.value;
+  }
+  return null;
+}
+function tryCastPressure(input, targetVariant = PRESSURE_BASE) {
+  const result = castPressure(input, targetVariant);
+  if (result === null) {
+    return { ok: false, error: `Cannot cast "${String(input)}" to pressure` };
+  }
+  return { ok: true, value: result };
+}
+function parsePressureString(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const numStr = match[1].replace(/\s/g, "").replace(",", ".");
+  const value = parseFloat(numStr);
+  if (isNaN(value) || !Number.isFinite(value)) {
+    return null;
+  }
+  const unitStr = match[2]?.trim().toLowerCase() || "";
+  let unit = null;
+  if (unitStr) {
+    if (unitStr in PRESSURE_ALIASES) {
+      unit = PRESSURE_ALIASES[unitStr];
+    } else if (unitStr in PRESSURE_UNITS) {
+      unit = unitStr;
+    } else {
+      for (const [u, config] of Object.entries(PRESSURE_UNITS)) {
+        if (config.symbol.toLowerCase() === unitStr) {
+          unit = u;
+          break;
+        }
+      }
+    }
+  }
+  return { value, unit };
+}
+
+// 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",
+  // gigahertz
+  ghz: "gigahertz",
+  // megahertz
+  mhz: "megahertz",
+  // kilohertz
+  khz: "kilohertz",
+  // hertz
+  hz: "hertz",
+  cps: "hertz",
+  // microhertz
+  "\u03BChz": "microhertz",
+  uhz: "microhertz",
+  // rpm
+  rpm: "rpm",
+  // bpm
+  bpm: "bpm",
+  // radians_per_second
+  "rad/s": "radians_per_second",
+  // cycles_per_minute
+  cpm: "cycles_per_minute"
+};
+Object.fromEntries(
+  Object.entries(FREQUENCY_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/frequency/convert.ts
+var FREQUENCY_BASE = "hertz";
+function toBaseFrequency(variant, value) {
+  const config = FREQUENCY_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown frequency unit: ${variant}`);
+  }
+  return value * (config.factor ?? 1);
+}
+function fromBaseFrequency(variant, baseValue) {
+  const config = FREQUENCY_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown frequency unit: ${variant}`);
+  }
+  return baseValue / (config.factor ?? 1);
+}
+function convertFrequency(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseFrequency(from, value);
+  return fromBaseFrequency(to, baseValue);
+}
+
+// src/roles/frequency/cast.ts
+function castFrequency(input, targetVariant = FREQUENCY_BASE) {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    const parsed = parseFrequencyString(input);
+    if (parsed === null) {
+      return null;
+    }
+    if (parsed.unit && parsed.unit !== targetVariant) {
+      return convertFrequency(parsed.unit, targetVariant, parsed.value);
+    }
+    return parsed.value;
+  }
+  return null;
+}
+function tryCastFrequency(input, targetVariant = FREQUENCY_BASE) {
+  const result = castFrequency(input, targetVariant);
+  if (result === null) {
+    return { ok: false, error: `Cannot cast "${String(input)}" to frequency` };
+  }
+  return { ok: true, value: result };
+}
+function parseFrequencyString(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const numStr = match[1].replace(/\s/g, "").replace(",", ".");
+  const value = parseFloat(numStr);
+  if (isNaN(value) || !Number.isFinite(value)) {
+    return null;
+  }
+  const unitStr = match[2]?.trim().toLowerCase() || "";
+  let unit = null;
+  if (unitStr) {
+    if (unitStr in FREQUENCY_ALIASES) {
+      unit = FREQUENCY_ALIASES[unitStr];
+    } else if (unitStr in FREQUENCY_UNITS) {
+      unit = unitStr;
+    } else {
+      for (const [u, config] of Object.entries(FREQUENCY_UNITS)) {
+        if (config.symbol.toLowerCase() === unitStr) {
+          unit = u;
+          break;
+        }
+      }
+    }
+  }
+  return { value, unit };
+}
+
+// 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",
+  rev: "turn",
+  // degree
+  "\xB0": "degree",
+  deg: "degree",
+  // arcminute
+  "\u2032": "arcminute",
+  "'": "arcminute",
+  arcmin: "arcminute",
+  // arcsecond
+  "\u2033": "arcsecond",
+  '"': "arcsecond",
+  arcsec: "arcsecond",
+  // milliarcsecond
+  mas: "milliarcsecond",
+  // radian
+  rad: "radian",
+  // milliradian
+  mrad: "milliradian",
+  // gradian
+  gon: "gradian",
+  grad: "gradian"
+};
+Object.fromEntries(
+  Object.entries(ANGLE_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/angle/convert.ts
+var ANGLE_BASE = "degree";
+function toBaseAngle(variant, value) {
+  const config = ANGLE_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown angle unit: ${variant}`);
+  }
+  return value * (config.factor ?? 1);
+}
+function fromBaseAngle(variant, baseValue) {
+  const config = ANGLE_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown angle unit: ${variant}`);
+  }
+  return baseValue / (config.factor ?? 1);
+}
+function convertAngle(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseAngle(from, value);
+  return fromBaseAngle(to, baseValue);
+}
+
+// src/roles/angle/cast.ts
+function castAngle(input, targetVariant = ANGLE_BASE) {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    const parsed = parseAngleString(input);
+    if (parsed === null) {
+      return null;
+    }
+    if (parsed.unit && parsed.unit !== targetVariant) {
+      return convertAngle(parsed.unit, targetVariant, parsed.value);
+    }
+    return parsed.value;
+  }
+  return null;
+}
+function tryCastAngle(input, targetVariant = ANGLE_BASE) {
+  const result = castAngle(input, targetVariant);
+  if (result === null) {
+    return { ok: false, error: `Cannot cast "${String(input)}" to angle` };
+  }
+  return { ok: true, value: result };
+}
+function parseAngleString(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const degreeMatch = trimmed.match(/^([+-]?[\d.,]+)°$/);
+  if (degreeMatch) {
+    const numStr2 = degreeMatch[1].replace(",", ".");
+    const value2 = parseFloat(numStr2);
+    if (isNaN(value2) || !Number.isFinite(value2)) {
+      return null;
+    }
+    return { value: value2, unit: "degree" };
+  }
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const numStr = match[1].replace(/\s/g, "").replace(",", ".");
+  const value = parseFloat(numStr);
+  if (isNaN(value) || !Number.isFinite(value)) {
+    return null;
+  }
+  const unitStr = match[2]?.trim().toLowerCase() || "";
+  let unit = null;
+  if (unitStr) {
+    if (unitStr in ANGLE_ALIASES) {
+      unit = ANGLE_ALIASES[unitStr];
+    } else if (unitStr in ANGLE_UNITS) {
+      unit = unitStr;
+    } else {
+      for (const [u, config] of Object.entries(ANGLE_UNITS)) {
+        if (config.symbol.toLowerCase() === unitStr || config.symbol === unitStr) {
+          unit = u;
+          break;
+        }
+      }
+    }
+  }
+  return { value, unit };
+}
+
+// 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",
+  // microsecond
+  "\u03BCs": "microsecond",
+  us: "microsecond",
+  // millisecond
+  ms: "millisecond",
+  // second
+  s: "second",
+  sec: "second",
+  // minute
+  min: "minute",
+  // hour
+  h: "hour",
+  hr: "hour",
+  hrs: "hour",
+  // day
+  d: "day",
+  // week
+  wk: "week",
+  // month
+  mo: "month",
+  // year
+  yr: "year",
+  y: "year",
+  // decade
+  dec: "decade",
+  // century
+  c: "century",
+  // millennium
+  ky: "millennium"
+};
+Object.fromEntries(
+  Object.entries(TIME_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/time/convert.ts
+var TIME_BASE = "second";
+function toBaseTime(variant, value) {
+  const config = TIME_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown time unit: ${variant}`);
+  }
+  return value * (config.factor ?? 1);
+}
+function fromBaseTime(variant, baseValue) {
+  const config = TIME_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown time unit: ${variant}`);
+  }
+  return baseValue / (config.factor ?? 1);
+}
+function convertTime(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseTime(from, value);
+  return fromBaseTime(to, baseValue);
+}
+
+// src/roles/time/cast.ts
+function castTime(input, targetVariant = TIME_BASE) {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    const parsed = parseTimeString(input);
+    if (parsed === null) {
+      return null;
+    }
+    if (parsed.unit && parsed.unit !== targetVariant) {
+      return convertTime(parsed.unit, targetVariant, parsed.value);
+    }
+    return parsed.value;
+  }
+  return null;
+}
+function tryCastTime(input, targetVariant = TIME_BASE) {
+  const result = castTime(input, targetVariant);
+  if (result === null) {
+    return { ok: false, error: `Cannot cast "${String(input)}" to time` };
+  }
+  return { ok: true, value: result };
+}
+function parseTimeString(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const numStr = match[1].replace(/\s/g, "").replace(",", ".");
+  const value = parseFloat(numStr);
+  if (isNaN(value) || !Number.isFinite(value)) {
+    return null;
+  }
+  const unitStr = match[2]?.trim().toLowerCase() || "";
+  let unit = null;
+  if (unitStr) {
+    if (unitStr in TIME_ALIASES) {
+      unit = TIME_ALIASES[unitStr];
+    } else if (unitStr in TIME_UNITS) {
+      unit = unitStr;
+    } else {
+      for (const [u, config] of Object.entries(TIME_UNITS)) {
+        if (config.symbol.toLowerCase() === unitStr) {
+          unit = u;
+          break;
+        }
+      }
+    }
+  }
+  return { value, unit };
+}
+
+// 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",
+  // byte
+  B: "byte",
+  // kibibyte (IEC)
+  KiB: "kibibyte",
+  // mebibyte (IEC)
+  MiB: "mebibyte",
+  // gibibyte (IEC)
+  GiB: "gibibyte",
+  // tebibyte (IEC)
+  TiB: "tebibyte",
+  // pebibyte (IEC)
+  PiB: "pebibyte",
+  // exbibyte (IEC)
+  EiB: "exbibyte",
+  // kilobyte (SI)
+  kB: "kilobyte",
+  kb: "kilobyte",
+  // megabyte (SI)
+  MB: "megabyte",
+  // gigabyte (SI)
+  GB: "gigabyte",
+  // terabyte (SI)
+  TB: "terabyte",
+  // petabyte (SI)
+  PB: "petabyte",
+  // exabyte (SI)
+  EB: "exabyte"
+};
+Object.fromEntries(
+  Object.entries(DIGITAL_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/digital/convert.ts
+var DIGITAL_BASE = "byte";
+function toBaseDigital(variant, value) {
+  const config = DIGITAL_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown digital unit: ${variant}`);
+  }
+  return value * (config.factor ?? 1);
+}
+function fromBaseDigital(variant, baseValue) {
+  const config = DIGITAL_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown digital unit: ${variant}`);
+  }
+  return baseValue / (config.factor ?? 1);
+}
+function convertDigital(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const baseValue = toBaseDigital(from, value);
+  return fromBaseDigital(to, baseValue);
+}
+
+// src/roles/digital/cast.ts
+function castDigital(input, targetVariant = DIGITAL_BASE) {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    const parsed = parseDigitalString(input);
+    if (parsed === null) {
+      return null;
+    }
+    if (parsed.unit && parsed.unit !== targetVariant) {
+      return convertDigital(parsed.unit, targetVariant, parsed.value);
+    }
+    return parsed.value;
+  }
+  return null;
+}
+function tryCastDigital(input, targetVariant = DIGITAL_BASE) {
+  const result = castDigital(input, targetVariant);
+  if (result === null) {
+    return { ok: false, error: `Cannot cast "${String(input)}" to digital storage` };
+  }
+  return { ok: true, value: result };
+}
+function parseDigitalString(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const match = trimmed.match(/^([+-]?[\d.,\s]+)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const numStr = match[1].replace(/\s/g, "").replace(",", ".");
+  const value = parseFloat(numStr);
+  if (isNaN(value) || !Number.isFinite(value)) {
+    return null;
+  }
+  const unitStr = match[2]?.trim() || "";
+  const lowerUnitStr = unitStr.toLowerCase();
+  let unit = null;
+  if (unitStr) {
+    if (unitStr in DIGITAL_ALIASES) {
+      unit = DIGITAL_ALIASES[unitStr];
+    } else if (lowerUnitStr in DIGITAL_ALIASES) {
+      unit = DIGITAL_ALIASES[lowerUnitStr];
+    } else if (lowerUnitStr in DIGITAL_UNITS) {
+      unit = lowerUnitStr;
+    } else {
+      for (const [u, config] of Object.entries(DIGITAL_UNITS)) {
+        if (config.symbol === unitStr || config.symbol.toLowerCase() === lowerUnitStr) {
+          unit = u;
+          break;
+        }
+      }
+    }
+  }
+  return { value, unit };
+}
+
+// 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/convert.ts
+function hexToRgba(hex) {
+  let h = hex.trim();
+  if (h.startsWith("#")) h = h.slice(1);
+  let r, g, b, a;
+  if (h.length === 3) {
+    r = parseInt(h[0] + h[0], 16);
+    g = parseInt(h[1] + h[1], 16);
+    b = parseInt(h[2] + h[2], 16);
+    a = 1;
+  } else if (h.length === 4) {
+    r = parseInt(h[0] + h[0], 16);
+    g = parseInt(h[1] + h[1], 16);
+    b = parseInt(h[2] + h[2], 16);
+    a = parseInt(h[3] + h[3], 16) / 255;
+  } else if (h.length === 6) {
+    r = parseInt(h.slice(0, 2), 16);
+    g = parseInt(h.slice(2, 4), 16);
+    b = parseInt(h.slice(4, 6), 16);
+    a = 1;
+  } else if (h.length === 8) {
+    r = parseInt(h.slice(0, 2), 16);
+    g = parseInt(h.slice(2, 4), 16);
+    b = parseInt(h.slice(4, 6), 16);
+    a = parseInt(h.slice(6, 8), 16) / 255;
+  } else {
+    throw new Error(`Invalid hex color: ${hex}`);
+  }
+  return { r, g, b, a };
+}
+function rgbObjectToRgba(rgb) {
+  return {
+    r: normalizeRgbChannel(rgb.r),
+    g: normalizeRgbChannel(rgb.g),
+    b: normalizeRgbChannel(rgb.b),
+    a: normalizeAlpha(rgb.a)
+  };
+}
+function rgbStringToRgba(rgb) {
+  const match = rgb.match(/rgba?\s*\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)/i);
+  if (!match) {
+    throw new Error(`Invalid RGB string: ${rgb}`);
+  }
+  return {
+    r: normalizeRgbChannel(parseFloat(match[1])),
+    g: normalizeRgbChannel(parseFloat(match[2])),
+    b: normalizeRgbChannel(parseFloat(match[3])),
+    a: match[4] !== void 0 ? normalizeAlpha(parseFloat(match[4])) : 1
+  };
+}
+function hslObjectToRgba(hsl) {
+  const { r, g, b } = hslToRgb(hsl.h, hsl.s, hsl.l);
+  return {
+    r,
+    g,
+    b,
+    a: normalizeAlpha(hsl.a)
+  };
+}
+function hslStringToRgba(hsl) {
+  const match = hsl.match(/hsla?\s*\(\s*([\d.]+)\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?\s*(?:,\s*([\d.]+)\s*)?\)/i);
+  if (!match) {
+    throw new Error(`Invalid HSL string: ${hsl}`);
+  }
+  const h = parseFloat(match[1]);
+  const s = parseFloat(match[2]);
+  const l = parseFloat(match[3]);
+  const a = match[4] !== void 0 ? parseFloat(match[4]) : 1;
+  const { r, g, b } = hslToRgb(h, s, l);
+  return { r, g, b, a: normalizeAlpha(a) };
+}
+function rgbaToHex(rgba, includeAlpha = false) {
+  const r = rgba.r.toString(16).padStart(2, "0");
+  const g = rgba.g.toString(16).padStart(2, "0");
+  const b = rgba.b.toString(16).padStart(2, "0");
+  if (includeAlpha || rgba.a < 1) {
+    const a = Math.round(rgba.a * 255).toString(16).padStart(2, "0");
+    return `#${r}${g}${b}${a}`;
+  }
+  return `#${r}${g}${b}`;
+}
+function rgbaToRgbObject(rgba) {
+  if (rgba.a < 1) {
+    return { r: rgba.r, g: rgba.g, b: rgba.b, a: rgba.a };
+  }
+  return { r: rgba.r, g: rgba.g, b: rgba.b };
+}
+function rgbaToRgbString(rgba) {
+  if (rgba.a < 1) {
+    return `rgba(${rgba.r}, ${rgba.g}, ${rgba.b}, ${rgba.a})`;
+  }
+  return `rgb(${rgba.r}, ${rgba.g}, ${rgba.b})`;
+}
+function rgbaToHslObject(rgba) {
+  const { h, s, l } = rgbToHsl(rgba.r, rgba.g, rgba.b);
+  if (rgba.a < 1) {
+    return { h, s, l, a: rgba.a };
+  }
+  return { h, s, l };
+}
+function rgbaToHslString(rgba) {
+  const { h, s, l } = rgbToHsl(rgba.r, rgba.g, rgba.b);
+  if (rgba.a < 1) {
+    return `hsla(${h}, ${s}%, ${l}%, ${rgba.a})`;
+  }
+  return `hsl(${h}, ${s}%, ${l}%)`;
+}
+function fromBaseColor(variant, rgba) {
+  switch (variant) {
+    case "hex":
+      return rgbaToHex(rgba);
+    case "rgb_object":
+      return rgbaToRgbObject(rgba);
+    case "rgb_string":
+      return rgbaToRgbString(rgba);
+    case "hsl_object":
+      return rgbaToHslObject(rgba);
+    case "hsl_string":
+      return rgbaToHslString(rgba);
+    default:
+      throw new Error(`Unknown color variant: ${variant}`);
+  }
+}
+
+// src/roles/color/cast.ts
+function detectObjectFormat(obj) {
+  if (typeof obj.r === "number" && typeof obj.g === "number" && typeof obj.b === "number") {
+    return "rgb_object";
+  }
+  if (typeof obj.h === "number" && typeof obj.s === "number" && typeof obj.l === "number") {
+    return "hsl_object";
+  }
+  return null;
+}
+function parseToRgba(input) {
+  if (typeof input === "object" && input !== null && "r" in input && "g" in input && "b" in input && "a" in input) {
+    const rgba = input;
+    if (typeof rgba.r === "number" && typeof rgba.g === "number" && typeof rgba.b === "number" && typeof rgba.a === "number") {
+      return rgba;
+    }
+  }
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    const namedColor = NAMED_COLORS[trimmed.toLowerCase()];
+    if (namedColor) {
+      return namedColor;
+    }
+    if (/^#?[0-9a-f]{3,8}$/i.test(trimmed)) {
+      try {
+        return hexToRgba(trimmed);
+      } catch {
+        return null;
+      }
+    }
+    if (/^rgba?\s*\(/i.test(trimmed)) {
+      try {
+        return rgbStringToRgba(trimmed);
+      } catch {
+        return null;
+      }
+    }
+    if (/^hsla?\s*\(/i.test(trimmed)) {
+      try {
+        return hslStringToRgba(trimmed);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  if (typeof input === "object" && input !== null) {
+    const format = detectObjectFormat(input);
+    if (format === "rgb_object") {
+      try {
+        return rgbObjectToRgba(input);
+      } catch {
+        return null;
+      }
+    }
+    if (format === "hsl_object") {
+      try {
+        return hslObjectToRgba(input);
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function castColor(variant, input) {
+  const rgba = parseToRgba(input);
+  if (!rgba) {
+    return null;
+  }
+  try {
+    return fromBaseColor(variant, rgba);
+  } catch {
+    return null;
+  }
+}
+function tryCastColor(variant, input) {
+  const result = castColor(variant, input);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to color variant "${variant}"`
+    };
+  }
+  return { ok: true, value: result };
+}
+
+// src/roles/date/cast.ts
+function castIso(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;
+}
+function castTimestamp(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;
+}
+function castEpoch(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;
+}
+function castDate(variant, input) {
+  switch (variant) {
+    case "iso":
+      return castIso(input);
+    case "timestamp":
+      return castTimestamp(input);
+    case "epoch":
+      return castEpoch(input);
+    default:
+      return null;
+  }
+}
+function tryCastDate(variant, input) {
+  const result = castDate(variant, input);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to date variant "${variant}"`
+    };
+  }
+  return { ok: true, value: result };
+}
+
+// src/roles/currency/cast.ts
+function castCurrency(input) {
+  if (typeof input === "number") {
+    return Number.isFinite(input) ? input : null;
+  }
+  if (typeof input === "string") {
+    return parseCurrencyString(input);
+  }
+  return null;
+}
+function tryCastCurrency(input) {
+  const result = castCurrency(input);
+  if (result === null) {
+    return {
+      ok: false,
+      error: `Cannot cast "${String(input)}" to currency value`
+    };
+  }
+  return { ok: true, value: result };
+}
+var CURRENCY_SYMBOL_REGEX = /^[\s]*([A-Z]{1,3}\$?|[R$€£¥₹₩₽₺CHF]+)[\s]*/i;
+var CURRENCY_SYMBOL_SUFFIX_REGEX = /[\s]*([€₽])[\s]*$/;
+function parseCurrencyString(input) {
+  let str = input.trim();
+  if (!str) {
+    return null;
+  }
+  let isNegative = false;
+  if (str.startsWith("-")) {
+    isNegative = true;
+    str = str.slice(1).trim();
+  } else if (str.startsWith("(") && str.endsWith(")")) {
+    isNegative = true;
+    str = str.slice(1, -1).trim();
+  }
+  str = str.replace(CURRENCY_SYMBOL_REGEX, "");
+  str = str.replace(CURRENCY_SYMBOL_SUFFIX_REGEX, "");
+  str = str.trim();
+  if (!str) {
+    return null;
+  }
+  const numValue = parseNumber8(str);
+  if (numValue === null) {
+    return null;
+  }
+  return isNegative ? -numValue : numValue;
+}
+function parseNumber8(numStr) {
+  numStr = numStr.replace(/\s/g, "");
+  if (!/^[+-]?[\d.,]+$/.test(numStr)) {
+    return null;
+  }
+  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 parts = numStr.split(",");
+    const afterComma = parts.slice(1);
+    if (afterComma.length > 1 || afterComma.length === 1 && afterComma[0].length === 3 && parts[0].length <= 3) {
+      numStr = numStr.replace(/,/g, "");
+    } else {
+      numStr = numStr.replace(",", ".");
+    }
+  } else if (!hasComma && hasDot) {
+    const parts = numStr.split(".");
+    const afterDot = parts.slice(1);
+    if (afterDot.length > 1) {
+      numStr = numStr.replace(/\./g, "");
+    } else if (afterDot.length === 1 && afterDot[0].length === 3) {
+      numStr = numStr.replace(/\./g, "");
+    }
+  }
+  const value = parseFloat(numStr);
+  return isNaN(value) ? null : value;
+}
+
+exports.castAngle = castAngle;
+exports.castArea = castArea;
+exports.castColor = castColor;
+exports.castCurrency = castCurrency;
+exports.castDate = castDate;
+exports.castDigital = castDigital;
+exports.castEnergy = castEnergy;
+exports.castFrequency = castFrequency;
+exports.castLength = castLength;
+exports.castMass = castMass;
+exports.castPower = castPower;
+exports.castPressure = castPressure;
+exports.castSpeed = castSpeed;
+exports.castTemperature = castTemperature;
+exports.castTime = castTime;
+exports.castVolume = castVolume;
+exports.tryCastAngle = tryCastAngle;
+exports.tryCastArea = tryCastArea;
+exports.tryCastColor = tryCastColor;
+exports.tryCastCurrency = tryCastCurrency;
+exports.tryCastDate = tryCastDate;
+exports.tryCastDigital = tryCastDigital;
+exports.tryCastEnergy = tryCastEnergy;
+exports.tryCastFrequency = tryCastFrequency;
+exports.tryCastLength = tryCastLength;
+exports.tryCastMass = tryCastMass;
+exports.tryCastPower = tryCastPower;
+exports.tryCastPressure = tryCastPressure;
+exports.tryCastSpeed = tryCastSpeed;
+exports.tryCastTemperature = tryCastTemperature;
+exports.tryCastTime = tryCastTime;
+exports.tryCastVolume = tryCastVolume;
+//# sourceMappingURL=cast.js.map
+//# sourceMappingURL=cast.js.map