@attrx/role-morphic 0.1.0 → 0.2.0

package/dist/convert.js

@@ -0,0 +1,2244 @@
+'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/convert.ts
+var AREA_BASE = "square_meter";
+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);
+}
+function tryConvertArea(from, to, value) {
+  try {
+    const result = convertArea(from, to, value);
+    return { ok: true, value: result };
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function hasAreaVariant(variant) {
+  return variant in AREA_UNITS;
+}
+function getAreaVariants() {
+  return Object.keys(AREA_UNITS);
+}
+
+// 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/convert.ts
+var LENGTH_BASE = "meter";
+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);
+}
+function tryConvertLength(from, to, value) {
+  try {
+    const result = convertLength(from, to, value);
+    return { ok: true, value: result };
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function hasLengthVariant(variant) {
+  return variant in LENGTH_UNITS;
+}
+function getLengthVariants() {
+  return Object.keys(LENGTH_UNITS);
+}
+
+// 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/convert.ts
+var MASS_BASE = "kilogram";
+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);
+}
+function tryConvertMass(from, to, value) {
+  try {
+    const result = convertMass(from, to, value);
+    return { ok: true, value: result };
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function hasMassVariant(variant) {
+  return variant in MASS_UNITS;
+}
+function getMassVariants() {
+  return Object.keys(MASS_UNITS);
+}
+
+// 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/convert.ts
+var TEMPERATURE_BASE = "celsius";
+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);
+}
+function tryConvertTemperature(from, to, value) {
+  try {
+    const result = convertTemperature(from, to, value);
+    return { ok: true, value: result };
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function hasTemperatureVariant(variant) {
+  return variant in TEMPERATURE_UNITS;
+}
+function getTemperatureVariants() {
+  return Object.keys(TEMPERATURE_UNITS);
+}
+
+// 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/convert.ts
+var VOLUME_BASE = "liter";
+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);
+}
+function tryConvertVolume(from, to, value) {
+  try {
+    const result = convertVolume(from, to, value);
+    return { ok: true, value: result };
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function hasVolumeVariant(variant) {
+  return variant in VOLUME_UNITS;
+}
+function getVolumeVariants() {
+  return Object.keys(VOLUME_UNITS);
+}
+
+// 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/convert.ts
+var SPEED_BASE = "meter_per_second";
+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);
+}
+function tryConvertSpeed(from, to, value) {
+  try {
+    const result = convertSpeed(from, to, value);
+    return { ok: true, value: result };
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function hasSpeedVariant(variant) {
+  return variant in SPEED_UNITS;
+}
+function getSpeedVariants() {
+  return Object.keys(SPEED_UNITS);
+}
+
+// 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/convert.ts
+var ENERGY_BASE = "joule";
+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);
+}
+function tryConvertEnergy(from, to, value) {
+  try {
+    const result = convertEnergy(from, to, value);
+    return { ok: true, value: result };
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function hasEnergyVariant(variant) {
+  return variant in ENERGY_UNITS;
+}
+function getEnergyVariants() {
+  return Object.keys(ENERGY_UNITS);
+}
+
+// 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/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);
+}
+function tryConvertPower(from, to, value) {
+  try {
+    return { ok: true, value: convertPower(from, to, value) };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+function hasPowerVariant(variant) {
+  return variant in POWER_UNITS;
+}
+function getPowerVariants() {
+  return Object.keys(POWER_UNITS);
+}
+
+// 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/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);
+}
+function tryConvertPressure(from, to, value) {
+  try {
+    return { ok: true, value: convertPressure(from, to, value) };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+function hasPressureVariant(variant) {
+  return variant in PRESSURE_UNITS;
+}
+function getPressureVariants() {
+  return Object.keys(PRESSURE_UNITS);
+}
+
+// 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/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);
+}
+function tryConvertFrequency(from, to, value) {
+  try {
+    return { ok: true, value: convertFrequency(from, to, value) };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+function hasFrequencyVariant(variant) {
+  return variant in FREQUENCY_UNITS;
+}
+function getFrequencyVariants() {
+  return Object.keys(FREQUENCY_UNITS);
+}
+
+// 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/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);
+}
+function tryConvertAngle(from, to, value) {
+  try {
+    return { ok: true, value: convertAngle(from, to, value) };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+function hasAngleVariant(variant) {
+  return variant in ANGLE_UNITS;
+}
+function getAngleVariants() {
+  return Object.keys(ANGLE_UNITS);
+}
+
+// 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/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);
+}
+function tryConvertTime(from, to, value) {
+  try {
+    return { ok: true, value: convertTime(from, to, value) };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+function hasTimeVariant(variant) {
+  return variant in TIME_UNITS;
+}
+function getTimeVariants() {
+  return Object.keys(TIME_UNITS);
+}
+
+// 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/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);
+}
+function tryConvertDigital(from, to, value) {
+  try {
+    return { ok: true, value: convertDigital(from, to, value) };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+function hasDigitalVariant(variant) {
+  return variant in DIGITAL_UNITS;
+}
+function getDigitalVariants() {
+  return Object.keys(DIGITAL_UNITS);
+}
+
+// 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}`);
+  }
+}
+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}`);
+  }
+}
+function convertColor(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const rgba = toBaseColor(from, value);
+  return fromBaseColor(to, rgba);
+}
+function tryConvertColor(from, to, value) {
+  try {
+    const result = convertColor(from, to, value);
+    return { ok: true, value: result };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/roles/date/convert.ts
+function isoToBase(value) {
+  const date = new Date(value);
+  if (isNaN(date.getTime())) {
+    throw new Error(`Invalid ISO date: ${value}`);
+  }
+  return date.getTime();
+}
+function timestampToBase(value) {
+  return value;
+}
+function epochToBase(value) {
+  return value * 1e3;
+}
+function toBaseDate(variant, value) {
+  switch (variant) {
+    case "iso":
+      return isoToBase(value);
+    case "timestamp":
+      return timestampToBase(value);
+    case "epoch":
+      return epochToBase(value);
+    default:
+      throw new Error(`Unknown date variant: ${variant}`);
+  }
+}
+function baseToIso(base) {
+  const date = new Date(base);
+  if (isNaN(date.getTime())) {
+    throw new Error(`Invalid timestamp: ${base}`);
+  }
+  return date.toISOString();
+}
+function baseToTimestamp(base) {
+  return base;
+}
+function baseToEpoch(base) {
+  return Math.floor(base / 1e3);
+}
+function fromBaseDate(variant, base) {
+  switch (variant) {
+    case "iso":
+      return baseToIso(base);
+    case "timestamp":
+      return baseToTimestamp(base);
+    case "epoch":
+      return baseToEpoch(base);
+    default:
+      throw new Error(`Unknown date variant: ${variant}`);
+  }
+}
+function convertDate(from, to, value) {
+  if (from === to) {
+    return value;
+  }
+  const base = toBaseDate(from, value);
+  return fromBaseDate(to, base);
+}
+function tryConvertDate(from, to, value) {
+  try {
+    const result = convertDate(from, to, value);
+    return { ok: true, value: result };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+exports.ANGLE_BASE = ANGLE_BASE;
+exports.AREA_BASE = AREA_BASE;
+exports.DIGITAL_BASE = DIGITAL_BASE;
+exports.ENERGY_BASE = ENERGY_BASE;
+exports.FREQUENCY_BASE = FREQUENCY_BASE;
+exports.LENGTH_BASE = LENGTH_BASE;
+exports.MASS_BASE = MASS_BASE;
+exports.POWER_BASE = POWER_BASE;
+exports.PRESSURE_BASE = PRESSURE_BASE;
+exports.SPEED_BASE = SPEED_BASE;
+exports.TEMPERATURE_BASE = TEMPERATURE_BASE;
+exports.TIME_BASE = TIME_BASE;
+exports.VOLUME_BASE = VOLUME_BASE;
+exports.convertAngle = convertAngle;
+exports.convertArea = convertArea;
+exports.convertColor = convertColor;
+exports.convertDate = convertDate;
+exports.convertDigital = convertDigital;
+exports.convertEnergy = convertEnergy;
+exports.convertFrequency = convertFrequency;
+exports.convertLength = convertLength;
+exports.convertMass = convertMass;
+exports.convertPower = convertPower;
+exports.convertPressure = convertPressure;
+exports.convertSpeed = convertSpeed;
+exports.convertTemperature = convertTemperature;
+exports.convertTime = convertTime;
+exports.convertVolume = convertVolume;
+exports.fromBaseAngle = fromBaseAngle;
+exports.fromBaseArea = fromBaseArea;
+exports.fromBaseDigital = fromBaseDigital;
+exports.fromBaseEnergy = fromBaseEnergy;
+exports.fromBaseFrequency = fromBaseFrequency;
+exports.fromBaseLength = fromBaseLength;
+exports.fromBaseMass = fromBaseMass;
+exports.fromBasePower = fromBasePower;
+exports.fromBasePressure = fromBasePressure;
+exports.fromBaseSpeed = fromBaseSpeed;
+exports.fromBaseTemperature = fromBaseTemperature;
+exports.fromBaseTime = fromBaseTime;
+exports.fromBaseVolume = fromBaseVolume;
+exports.getAngleVariants = getAngleVariants;
+exports.getAreaVariants = getAreaVariants;
+exports.getDigitalVariants = getDigitalVariants;
+exports.getEnergyVariants = getEnergyVariants;
+exports.getFrequencyVariants = getFrequencyVariants;
+exports.getLengthVariants = getLengthVariants;
+exports.getMassVariants = getMassVariants;
+exports.getPowerVariants = getPowerVariants;
+exports.getPressureVariants = getPressureVariants;
+exports.getSpeedVariants = getSpeedVariants;
+exports.getTemperatureVariants = getTemperatureVariants;
+exports.getTimeVariants = getTimeVariants;
+exports.getVolumeVariants = getVolumeVariants;
+exports.hasAngleVariant = hasAngleVariant;
+exports.hasAreaVariant = hasAreaVariant;
+exports.hasDigitalVariant = hasDigitalVariant;
+exports.hasEnergyVariant = hasEnergyVariant;
+exports.hasFrequencyVariant = hasFrequencyVariant;
+exports.hasLengthVariant = hasLengthVariant;
+exports.hasMassVariant = hasMassVariant;
+exports.hasPowerVariant = hasPowerVariant;
+exports.hasPressureVariant = hasPressureVariant;
+exports.hasSpeedVariant = hasSpeedVariant;
+exports.hasTemperatureVariant = hasTemperatureVariant;
+exports.hasTimeVariant = hasTimeVariant;
+exports.hasVolumeVariant = hasVolumeVariant;
+exports.toBaseAngle = toBaseAngle;
+exports.toBaseArea = toBaseArea;
+exports.toBaseDigital = toBaseDigital;
+exports.toBaseEnergy = toBaseEnergy;
+exports.toBaseFrequency = toBaseFrequency;
+exports.toBaseLength = toBaseLength;
+exports.toBaseMass = toBaseMass;
+exports.toBasePower = toBasePower;
+exports.toBasePressure = toBasePressure;
+exports.toBaseSpeed = toBaseSpeed;
+exports.toBaseTemperature = toBaseTemperature;
+exports.toBaseTime = toBaseTime;
+exports.toBaseVolume = toBaseVolume;
+exports.tryConvertAngle = tryConvertAngle;
+exports.tryConvertArea = tryConvertArea;
+exports.tryConvertColor = tryConvertColor;
+exports.tryConvertDate = tryConvertDate;
+exports.tryConvertDigital = tryConvertDigital;
+exports.tryConvertEnergy = tryConvertEnergy;
+exports.tryConvertFrequency = tryConvertFrequency;
+exports.tryConvertLength = tryConvertLength;
+exports.tryConvertMass = tryConvertMass;
+exports.tryConvertPower = tryConvertPower;
+exports.tryConvertPressure = tryConvertPressure;
+exports.tryConvertSpeed = tryConvertSpeed;
+exports.tryConvertTemperature = tryConvertTemperature;
+exports.tryConvertTime = tryConvertTime;
+exports.tryConvertVolume = tryConvertVolume;
+//# sourceMappingURL=convert.js.map
+//# sourceMappingURL=convert.js.map