@attrx/role-morphic 0.1.0 → 0.2.0

package/dist/format.js

@@ -0,0 +1,2303 @@
+'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"
+  }
+};
+Object.fromEntries(
+  Object.entries(AREA_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/area/format.ts
+function formatArea(variant, value, options = {}) {
+  const { decimals = 2, verbose = false, locale, notation } = options;
+  const unit = AREA_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown area variant: ${variant}`);
+  }
+  let formattedValue;
+  if (locale) {
+    const formatOptions = {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: decimals
+    };
+    if (notation) {
+      formatOptions.notation = notation;
+    }
+    formattedValue = value.toLocaleString(locale, formatOptions);
+  } else {
+    formattedValue = Number(value.toFixed(decimals)).toString();
+  }
+  const separator = unit.noSpace ? "" : " ";
+  if (verbose) {
+    const name = value === 1 ? unit.singular : unit.plural;
+    return `${formattedValue} ${name || unit.symbol}`;
+  }
+  return `${formattedValue}${separator}${unit.symbol}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(LENGTH_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/length/format.ts
+function formatLength(variant, value, options = {}) {
+  const { decimals = 2, verbose = false, locale, notation } = options;
+  const unit = LENGTH_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown length variant: ${variant}`);
+  }
+  let formattedValue;
+  if (locale) {
+    const formatOptions = {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: decimals
+    };
+    if (notation) {
+      formatOptions.notation = notation;
+    }
+    formattedValue = value.toLocaleString(locale, formatOptions);
+  } else {
+    formattedValue = Number(value.toFixed(decimals)).toString();
+  }
+  const separator = unit.noSpace ? "" : " ";
+  if (verbose) {
+    const name = value === 1 ? unit.singular : unit.plural;
+    return `${formattedValue} ${name || unit.symbol}`;
+  }
+  return `${formattedValue}${separator}${unit.symbol}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(MASS_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/mass/format.ts
+function formatMass(variant, value, options = {}) {
+  const { decimals = 2, verbose = false, locale, notation } = options;
+  const unit = MASS_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown mass variant: ${variant}`);
+  }
+  let formattedValue;
+  if (locale) {
+    const formatOptions = {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: decimals
+    };
+    if (notation) {
+      formatOptions.notation = notation;
+    }
+    formattedValue = value.toLocaleString(locale, formatOptions);
+  } else {
+    formattedValue = Number(value.toFixed(decimals)).toString();
+  }
+  const separator = unit.noSpace ? "" : " ";
+  if (verbose) {
+    const name = value === 1 ? unit.singular : unit.plural;
+    return `${formattedValue} ${name || unit.symbol}`;
+  }
+  return `${formattedValue}${separator}${unit.symbol}`;
+}
+
+// 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
+  }
+};
+
+// src/roles/temperature/format.ts
+function formatTemperature(variant, value, options = {}) {
+  const { decimals = 2, verbose = false, locale, notation } = options;
+  const unit = TEMPERATURE_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown temperature variant: ${variant}`);
+  }
+  let formattedValue;
+  if (locale) {
+    const formatOptions = {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: decimals
+    };
+    if (notation) {
+      formatOptions.notation = notation;
+    }
+    formattedValue = value.toLocaleString(locale, formatOptions);
+  } else {
+    formattedValue = Number(value.toFixed(decimals)).toString();
+  }
+  const separator = unit.noSpace ? "" : " ";
+  if (verbose) {
+    const name = value === 1 ? unit.singular : unit.plural;
+    return `${formattedValue} ${name || unit.symbol}`;
+  }
+  return `${formattedValue}${separator}${unit.symbol}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(VOLUME_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/volume/format.ts
+function formatVolume(variant, value, options = {}) {
+  const { decimals = 2, verbose = false, locale, notation } = options;
+  const unit = VOLUME_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown volume variant: ${variant}`);
+  }
+  let formattedValue;
+  if (locale) {
+    const formatOptions = {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: decimals
+    };
+    if (notation) {
+      formatOptions.notation = notation;
+    }
+    formattedValue = value.toLocaleString(locale, formatOptions);
+  } else {
+    formattedValue = Number(value.toFixed(decimals)).toString();
+  }
+  const separator = unit.noSpace ? "" : " ";
+  if (verbose) {
+    const name = value === 1 ? unit.singular : unit.plural;
+    return `${formattedValue} ${name || unit.symbol}`;
+  }
+  return `${formattedValue}${separator}${unit.symbol}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(SPEED_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/speed/format.ts
+function formatSpeed(variant, value, options = {}) {
+  const { decimals = 2, verbose = false, locale, notation } = options;
+  const unit = SPEED_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown speed variant: ${variant}`);
+  }
+  let formattedValue;
+  if (locale) {
+    const formatOptions = {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: decimals
+    };
+    if (notation) {
+      formatOptions.notation = notation;
+    }
+    formattedValue = value.toLocaleString(locale, formatOptions);
+  } else {
+    formattedValue = Number(value.toFixed(decimals)).toString();
+  }
+  const separator = unit.noSpace ? "" : " ";
+  if (verbose) {
+    const name = value === 1 ? unit.singular : unit.plural;
+    return `${formattedValue} ${name || unit.symbol}`;
+  }
+  return `${formattedValue}${separator}${unit.symbol}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(ENERGY_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/energy/format.ts
+function formatEnergy(variant, value, options = {}) {
+  const { decimals = 2, verbose = false, locale, notation } = options;
+  const unit = ENERGY_UNITS[variant];
+  if (!unit) {
+    throw new Error(`Unknown energy variant: ${variant}`);
+  }
+  let formattedValue;
+  if (locale) {
+    const formatOptions = {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: decimals
+    };
+    if (notation) {
+      formatOptions.notation = notation;
+    }
+    formattedValue = value.toLocaleString(locale, formatOptions);
+  } else {
+    formattedValue = Number(value.toFixed(decimals)).toString();
+  }
+  const separator = unit.noSpace ? "" : " ";
+  if (verbose) {
+    const name = value === 1 ? unit.singular : unit.plural;
+    return `${formattedValue} ${name || unit.symbol}`;
+  }
+  return `${formattedValue}${separator}${unit.symbol}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(POWER_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/power/format.ts
+function formatPower(variant, value, options = {}) {
+  const config = POWER_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown power unit: ${variant}`);
+  }
+  const { decimals, verbose = false, locale, notation = "standard" } = options;
+  let formattedNumber;
+  if (locale || notation !== "standard") {
+    const intlOptions = { notation };
+    if (decimals !== void 0) {
+      intlOptions.minimumFractionDigits = decimals;
+      intlOptions.maximumFractionDigits = decimals;
+    }
+    formattedNumber = new Intl.NumberFormat(locale, intlOptions).format(value);
+  } else if (decimals !== void 0) {
+    formattedNumber = value.toFixed(decimals);
+  } else {
+    formattedNumber = Number(value.toPrecision(12)).toString();
+  }
+  const unitLabel = verbose ? value === 1 ? config.singular : config.plural : config.symbol;
+  return `${formattedNumber} ${unitLabel}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(PRESSURE_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/pressure/format.ts
+function formatPressure(variant, value, options = {}) {
+  const config = PRESSURE_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown pressure unit: ${variant}`);
+  }
+  const { decimals, verbose = false, locale, notation = "standard" } = options;
+  let formattedNumber;
+  if (locale || notation !== "standard") {
+    const intlOptions = { notation };
+    if (decimals !== void 0) {
+      intlOptions.minimumFractionDigits = decimals;
+      intlOptions.maximumFractionDigits = decimals;
+    }
+    formattedNumber = new Intl.NumberFormat(locale, intlOptions).format(value);
+  } else if (decimals !== void 0) {
+    formattedNumber = value.toFixed(decimals);
+  } else {
+    formattedNumber = Number(value.toPrecision(12)).toString();
+  }
+  const unitLabel = verbose ? value === 1 ? config.singular : config.plural : config.symbol;
+  return `${formattedNumber} ${unitLabel}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(FREQUENCY_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/frequency/format.ts
+function formatFrequency(variant, value, options = {}) {
+  const config = FREQUENCY_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown frequency unit: ${variant}`);
+  }
+  const { decimals, verbose = false, locale, notation = "standard" } = options;
+  let formattedNumber;
+  if (locale || notation !== "standard") {
+    const intlOptions = { notation };
+    if (decimals !== void 0) {
+      intlOptions.minimumFractionDigits = decimals;
+      intlOptions.maximumFractionDigits = decimals;
+    }
+    formattedNumber = new Intl.NumberFormat(locale, intlOptions).format(value);
+  } else if (decimals !== void 0) {
+    formattedNumber = value.toFixed(decimals);
+  } else {
+    formattedNumber = Number(value.toPrecision(12)).toString();
+  }
+  const unitLabel = verbose ? value === 1 ? config.singular : config.plural : config.symbol;
+  return `${formattedNumber} ${unitLabel}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(ANGLE_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/angle/format.ts
+function formatAngle(variant, value, options = {}) {
+  const config = ANGLE_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown angle unit: ${variant}`);
+  }
+  const { decimals, verbose = false, locale, notation = "standard" } = options;
+  let formattedNumber;
+  if (locale || notation !== "standard") {
+    const intlOptions = { notation };
+    if (decimals !== void 0) {
+      intlOptions.minimumFractionDigits = decimals;
+      intlOptions.maximumFractionDigits = decimals;
+    }
+    formattedNumber = new Intl.NumberFormat(locale, intlOptions).format(value);
+  } else if (decimals !== void 0) {
+    formattedNumber = value.toFixed(decimals);
+  } else {
+    formattedNumber = Number(value.toPrecision(12)).toString();
+  }
+  const unitLabel = verbose ? value === 1 ? config.singular : config.plural : config.symbol;
+  const separator = config.noSpace && !verbose ? "" : " ";
+  return `${formattedNumber}${separator}${unitLabel}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(TIME_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/time/format.ts
+function formatTime(variant, value, options = {}) {
+  const config = TIME_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown time unit: ${variant}`);
+  }
+  const { decimals, verbose = false, locale, notation = "standard" } = options;
+  let formattedNumber;
+  if (locale || notation !== "standard") {
+    const intlOptions = { notation };
+    if (decimals !== void 0) {
+      intlOptions.minimumFractionDigits = decimals;
+      intlOptions.maximumFractionDigits = decimals;
+    }
+    formattedNumber = new Intl.NumberFormat(locale, intlOptions).format(value);
+  } else if (decimals !== void 0) {
+    formattedNumber = value.toFixed(decimals);
+  } else {
+    formattedNumber = Number(value.toPrecision(12)).toString();
+  }
+  const unitLabel = verbose ? value === 1 ? config.singular : config.plural : config.symbol;
+  return `${formattedNumber} ${unitLabel}`;
+}
+
+// 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"
+  }
+};
+Object.fromEntries(
+  Object.entries(DIGITAL_UNITS).map(([unit, config]) => [
+    unit,
+    config.factor ?? 1
+  ])
+);
+
+// src/roles/digital/format.ts
+function formatDigital(variant, value, options = {}) {
+  const config = DIGITAL_UNITS[variant];
+  if (!config) {
+    throw new Error(`Unknown digital unit: ${variant}`);
+  }
+  const { decimals, verbose = false, locale, notation = "standard" } = options;
+  let formattedNumber;
+  if (locale || notation !== "standard") {
+    const intlOptions = { notation };
+    if (decimals !== void 0) {
+      intlOptions.minimumFractionDigits = decimals;
+      intlOptions.maximumFractionDigits = decimals;
+    }
+    formattedNumber = new Intl.NumberFormat(locale, intlOptions).format(value);
+  } else if (decimals !== void 0) {
+    formattedNumber = value.toFixed(decimals);
+  } else {
+    formattedNumber = Number(value.toPrecision(12)).toString();
+  }
+  const unitLabel = verbose ? value === 1 ? config.singular : config.plural : config.symbol;
+  return `${formattedNumber} ${unitLabel}`;
+}
+
+// src/roles/color/types.ts
+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 toBaseColor(variant, value) {
+  switch (variant) {
+    case "hex":
+      return hexToRgba(value);
+    case "rgb_object":
+      return rgbObjectToRgba(value);
+    case "rgb_string":
+      return rgbStringToRgba(value);
+    case "hsl_object":
+      return hslObjectToRgba(value);
+    case "hsl_string":
+      return hslStringToRgba(value);
+    default:
+      throw new Error(`Unknown color variant: ${variant}`);
+  }
+}
+
+// src/roles/color/format.ts
+var DEFAULT_OPTIONS = {
+  uppercase: false,
+  includeAlpha: false,
+  compact: false
+};
+function formatAsHex(rgba, options) {
+  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");
+  let hex;
+  if (options.includeAlpha || rgba.a < 1) {
+    const a = Math.round(rgba.a * 255).toString(16).padStart(2, "0");
+    hex = `#${r}${g}${b}${a}`;
+  } else {
+    hex = `#${r}${g}${b}`;
+  }
+  if (options.compact && !options.includeAlpha && rgba.a === 1) {
+    if (r[0] === r[1] && g[0] === g[1] && b[0] === b[1]) {
+      hex = `#${r[0]}${g[0]}${b[0]}`;
+    }
+  }
+  return options.uppercase ? hex.toUpperCase() : hex.toLowerCase();
+}
+function formatAsRgbString(rgba, options) {
+  if (options.includeAlpha || rgba.a < 1) {
+    if (options.compact) {
+      return `rgba(${rgba.r},${rgba.g},${rgba.b},${rgba.a})`;
+    }
+    return `rgba(${rgba.r}, ${rgba.g}, ${rgba.b}, ${rgba.a})`;
+  }
+  if (options.compact) {
+    return `rgb(${rgba.r},${rgba.g},${rgba.b})`;
+  }
+  return `rgb(${rgba.r}, ${rgba.g}, ${rgba.b})`;
+}
+function formatAsHslString(rgba, options) {
+  const { h, s, l } = rgbToHsl(rgba.r, rgba.g, rgba.b);
+  if (options.includeAlpha || rgba.a < 1) {
+    if (options.compact) {
+      return `hsla(${h},${s}%,${l}%,${rgba.a})`;
+    }
+    return `hsla(${h}, ${s}%, ${l}%, ${rgba.a})`;
+  }
+  if (options.compact) {
+    return `hsl(${h},${s}%,${l}%)`;
+  }
+  return `hsl(${h}, ${s}%, ${l}%)`;
+}
+function formatAsRgbObject(rgba, options) {
+  return formatAsRgbString(rgba, options);
+}
+function formatAsHslObject(rgba, options) {
+  return formatAsHslString(rgba, options);
+}
+function formatColor(variant, value, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let rgba;
+  if (typeof value === "object" && value !== null && "r" in value && "g" in value && "b" in value) {
+    const obj = value;
+    rgba = {
+      r: obj.r,
+      g: obj.g,
+      b: obj.b,
+      a: obj.a ?? 1
+    };
+  } else if (typeof value === "object" && value !== null && "h" in value && "s" in value && "l" in value) {
+    rgba = toBaseColor("hsl_object", value);
+  } else if (typeof value === "string") {
+    rgba = toBaseColor(detectStringVariant(value), value);
+  } else {
+    throw new Error(`Cannot format color: ${String(value)}`);
+  }
+  switch (variant) {
+    case "hex":
+      return formatAsHex(rgba, opts);
+    case "rgb_string":
+      return formatAsRgbString(rgba, opts);
+    case "hsl_string":
+      return formatAsHslString(rgba, opts);
+    case "rgb_object":
+      return formatAsRgbObject(rgba, opts);
+    case "hsl_object":
+      return formatAsHslObject(rgba, opts);
+    default:
+      throw new Error(`Unknown color variant: ${variant}`);
+  }
+}
+function detectStringVariant(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (/^#?[0-9a-f]{3,8}$/i.test(trimmed)) {
+    return "hex";
+  }
+  if (/^rgba?\s*\(/i.test(trimmed)) {
+    return "rgb_string";
+  }
+  if (/^hsla?\s*\(/i.test(trimmed)) {
+    return "hsl_string";
+  }
+  return "hex";
+}
+
+// src/roles/date/format.ts
+function formatIso(value, options) {
+  const date = new Date(value);
+  if (isNaN(date.getTime())) {
+    return "Invalid Date";
+  }
+  if (!options || !options.dateStyle && !options.timeStyle && !options.dateOnly && !options.timeOnly) {
+    return value;
+  }
+  return formatWithIntl(date, options);
+}
+function formatTimestamp(value, options) {
+  const date = new Date(value);
+  if (isNaN(date.getTime())) {
+    return "Invalid Date";
+  }
+  if (!options || !options.dateStyle && !options.timeStyle && !options.dateOnly && !options.timeOnly) {
+    return String(value);
+  }
+  return formatWithIntl(date, options);
+}
+function formatEpoch(value, options) {
+  const date = new Date(value * 1e3);
+  if (isNaN(date.getTime())) {
+    return "Invalid Date";
+  }
+  if (!options || !options.dateStyle && !options.timeStyle && !options.dateOnly && !options.timeOnly) {
+    return String(value);
+  }
+  return formatWithIntl(date, options);
+}
+function formatDate(variant, value, options) {
+  switch (variant) {
+    case "iso":
+      return formatIso(value, options);
+    case "timestamp":
+      return formatTimestamp(value, options);
+    case "epoch":
+      return formatEpoch(value, options);
+    default:
+      return "Invalid Date";
+  }
+}
+function formatWithIntl(date, options) {
+  const locale = options.locale || "en-US";
+  const formatOptions = {};
+  if (options.timeZone) {
+    formatOptions.timeZone = options.timeZone;
+  }
+  if (options.dateOnly) {
+    formatOptions.dateStyle = options.dateStyle || "medium";
+  } else if (options.timeOnly) {
+    formatOptions.timeStyle = options.timeStyle || "medium";
+  } else {
+    if (options.dateStyle) formatOptions.dateStyle = options.dateStyle;
+    if (options.timeStyle) formatOptions.timeStyle = options.timeStyle;
+  }
+  return new Intl.DateTimeFormat(locale, formatOptions).format(date);
+}
+
+// src/roles/currency/constants.ts
+var CURRENCY_CONFIGS = {
+  // ===========================================================================
+  // Major Currencies
+  // ===========================================================================
+  USD: {
+    code: "USD",
+    symbol: "$",
+    singular: "US dollar",
+    plural: "US dollars",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ",",
+    decimalSeparator: "."
+  },
+  EUR: {
+    code: "EUR",
+    symbol: "\u20AC",
+    singular: "euro",
+    plural: "euros",
+    decimals: 2,
+    symbolFirst: false,
+    // 100 € (europeu) ou €100 (varia)
+    thousandsSeparator: ".",
+    decimalSeparator: ","
+  },
+  GBP: {
+    code: "GBP",
+    symbol: "\xA3",
+    singular: "British pound",
+    plural: "British pounds",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ",",
+    decimalSeparator: "."
+  },
+  JPY: {
+    code: "JPY",
+    symbol: "\xA5",
+    singular: "Japanese yen",
+    plural: "Japanese yen",
+    decimals: 0,
+    // Yen não tem centavos
+    symbolFirst: true,
+    thousandsSeparator: ",",
+    decimalSeparator: "."
+  },
+  CHF: {
+    code: "CHF",
+    symbol: "CHF",
+    singular: "Swiss franc",
+    plural: "Swiss francs",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: "'",
+    decimalSeparator: "."
+  },
+  CNY: {
+    code: "CNY",
+    symbol: "\xA5",
+    singular: "Chinese yuan",
+    plural: "Chinese yuan",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ",",
+    decimalSeparator: "."
+  },
+  CAD: {
+    code: "CAD",
+    symbol: "C$",
+    singular: "Canadian dollar",
+    plural: "Canadian dollars",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ",",
+    decimalSeparator: "."
+  },
+  AUD: {
+    code: "AUD",
+    symbol: "A$",
+    singular: "Australian dollar",
+    plural: "Australian dollars",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ",",
+    decimalSeparator: "."
+  },
+  // ===========================================================================
+  // Latin America
+  // ===========================================================================
+  BRL: {
+    code: "BRL",
+    symbol: "R$",
+    singular: "Brazilian real",
+    plural: "Brazilian reais",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ".",
+    decimalSeparator: ","
+  },
+  MXN: {
+    code: "MXN",
+    symbol: "$",
+    singular: "Mexican peso",
+    plural: "Mexican pesos",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ",",
+    decimalSeparator: "."
+  },
+  ARS: {
+    code: "ARS",
+    symbol: "$",
+    singular: "Argentine peso",
+    plural: "Argentine pesos",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ".",
+    decimalSeparator: ","
+  },
+  CLP: {
+    code: "CLP",
+    symbol: "$",
+    singular: "Chilean peso",
+    plural: "Chilean pesos",
+    decimals: 0,
+    // Peso chileno não tem centavos
+    symbolFirst: true,
+    thousandsSeparator: ".",
+    decimalSeparator: ","
+  },
+  COP: {
+    code: "COP",
+    symbol: "$",
+    singular: "Colombian peso",
+    plural: "Colombian pesos",
+    decimals: 0,
+    // Peso colombiano praticamente não usa centavos
+    symbolFirst: true,
+    thousandsSeparator: ".",
+    decimalSeparator: ","
+  },
+  // ===========================================================================
+  // Other Important
+  // ===========================================================================
+  INR: {
+    code: "INR",
+    symbol: "\u20B9",
+    singular: "Indian rupee",
+    plural: "Indian rupees",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ",",
+    decimalSeparator: "."
+  },
+  KRW: {
+    code: "KRW",
+    symbol: "\u20A9",
+    singular: "South Korean won",
+    plural: "South Korean won",
+    decimals: 0,
+    // Won não tem centavos
+    symbolFirst: true,
+    thousandsSeparator: ",",
+    decimalSeparator: "."
+  },
+  RUB: {
+    code: "RUB",
+    symbol: "\u20BD",
+    singular: "Russian ruble",
+    plural: "Russian rubles",
+    decimals: 2,
+    symbolFirst: false,
+    thousandsSeparator: " ",
+    decimalSeparator: ","
+  },
+  TRY: {
+    code: "TRY",
+    symbol: "\u20BA",
+    singular: "Turkish lira",
+    plural: "Turkish lira",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: ".",
+    decimalSeparator: ","
+  },
+  ZAR: {
+    code: "ZAR",
+    symbol: "R",
+    singular: "South African rand",
+    plural: "South African rand",
+    decimals: 2,
+    symbolFirst: true,
+    thousandsSeparator: " ",
+    decimalSeparator: ","
+  }
+};
+
+// src/roles/currency/format.ts
+function formatCurrency(value, options) {
+  const config = CURRENCY_CONFIGS[options.currency];
+  if (!config) {
+    throw new Error(`Unknown currency code: ${options.currency}`);
+  }
+  if (options.locale) {
+    return formatWithIntl2(value, options, config);
+  }
+  return formatManual(value, options, config);
+}
+function formatWithIntl2(value, options, config) {
+  const decimals = options.decimals ?? config.decimals;
+  const intlOptions = {
+    style: options.hideSymbol ? "decimal" : "currency",
+    currency: config.code,
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  };
+  if (options.verbose) {
+    intlOptions.currencyDisplay = "name";
+  }
+  let formatted = new Intl.NumberFormat(options.locale, intlOptions).format(
+    value
+  );
+  if (options.showPositiveSign && value > 0) {
+    formatted = "+" + formatted;
+  }
+  return formatted;
+}
+function formatManual(value, options, config) {
+  const decimals = options.decimals ?? config.decimals;
+  const isNegative = value < 0;
+  const absValue = Math.abs(value);
+  const formattedNumber = formatNumber(
+    absValue,
+    decimals,
+    config.thousandsSeparator,
+    config.decimalSeparator
+  );
+  let result = "";
+  if (isNegative) {
+    result += "-";
+  } else if (options.showPositiveSign) {
+    result += "+";
+  }
+  if (options.hideSymbol) {
+    result += formattedNumber;
+  } else if (options.verbose) {
+    const name = absValue === 1 ? config.singular : config.plural;
+    result += `${formattedNumber} ${name}`;
+  } else {
+    const symbolFirst = options.symbolFirst !== void 0 ? options.symbolFirst : config.symbolFirst;
+    if (symbolFirst) {
+      result += `${config.symbol}${formattedNumber}`;
+    } else {
+      result += `${formattedNumber} ${config.symbol}`;
+    }
+  }
+  return result;
+}
+function formatNumber(value, decimals, thousandsSeparator, decimalSeparator) {
+  const fixed = value.toFixed(decimals);
+  const [intPart, decPart] = fixed.split(".");
+  const intFormatted = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, thousandsSeparator);
+  if (decimals > 0 && decPart) {
+    return `${intFormatted}${decimalSeparator}${decPart}`;
+  }
+  return intFormatted;
+}
+
+exports.formatAngle = formatAngle;
+exports.formatArea = formatArea;
+exports.formatColor = formatColor;
+exports.formatCurrency = formatCurrency;
+exports.formatDate = formatDate;
+exports.formatDigital = formatDigital;
+exports.formatEnergy = formatEnergy;
+exports.formatFrequency = formatFrequency;
+exports.formatLength = formatLength;
+exports.formatMass = formatMass;
+exports.formatPower = formatPower;
+exports.formatPressure = formatPressure;
+exports.formatSpeed = formatSpeed;
+exports.formatTemperature = formatTemperature;
+exports.formatTime = formatTime;
+exports.formatVolume = formatVolume;
+//# sourceMappingURL=format.js.map
+//# sourceMappingURL=format.js.map