quantible 0.1.11-alpha → 0.1.12-alpha

package/dist/index.cjs

@@ -0,0 +1,1089 @@
+'use strict';
+
+// src/config/default.ts
+var units = {
+  // Base units
+  m: { singular: "meter", plural: "meters" },
+  "%": { singular: "percent", plural: "percent" },
+  cm: { singular: "centimeter", plural: "centimeters" },
+  mm: { singular: "millimeter", plural: "millimeters" },
+  km: { singular: "kilometer", plural: "kilometers" },
+  in: { singular: "inch", plural: "inches" },
+  ft: { singular: "foot", plural: "feet" },
+  yd: { singular: "yard", plural: "yards" },
+  mi: { singular: "mile", plural: "miles" },
+  g: { singular: "gram", plural: "grams" },
+  mg: { singular: "milligram", plural: "milligrams" },
+  kg: { singular: "kilogram", plural: "kilograms" },
+  L: { singular: "liter", plural: "liters" },
+  mL: { singular: "milliliter", plural: "milliliters" },
+  s: { singular: "second", plural: "seconds" },
+  min: { singular: "minute", plural: "minutes" },
+  h: { singular: "hour", plural: "hours" },
+  // Additional Time Units
+  d: { singular: "day", plural: "days" },
+  wk: { singular: "week", plural: "weeks" },
+  mo: { singular: "month", plural: "months" },
+  yr: { singular: "year", plural: "years" },
+  // Additional Length Units
+  \u03BCm: { singular: "micrometer", plural: "micrometers" },
+  nm: { singular: "nanometer", plural: "nanometers" },
+  nmi: { singular: "nautical mile", plural: "nautical miles" },
+  // Additional Mass Units
+  \u03BCg: { singular: "microgram", plural: "micrograms" },
+  t: { singular: "tonne", plural: "tonnes" },
+  lb: { singular: "pound", plural: "pounds" },
+  oz: { singular: "ounce", plural: "ounces" },
+  st: { singular: "stone", plural: "stones" },
+  // Volume Units
+  "cm\xB3": { singular: "cubic centimeter", plural: "cubic centimeters" },
+  gal: { singular: "gallon", plural: "gallons" },
+  pt: { singular: "pint", plural: "pints" },
+  qt: { singular: "quart", plural: "quarts" },
+  "fl oz": { singular: "fluid ounce", plural: "fluid ounces" },
+  "ft\xB3": { singular: "cubic foot", plural: "cubic feet" },
+  "in\xB3": { singular: "cubic inch", plural: "cubic inches" },
+  bbl: { singular: "barrel", plural: "barrels" },
+  // Area Units
+  "m\xB2": { singular: "square meter", plural: "square meters" },
+  "km\xB2": { singular: "square kilometer", plural: "square kilometers" },
+  "cm\xB2": { singular: "square centimeter", plural: "square centimeters" },
+  "mm\xB2": { singular: "square millimeter", plural: "square millimeters" },
+  ha: { singular: "hectare", plural: "hectares" },
+  "ft\xB2": { singular: "square foot", plural: "square feet" },
+  "in\xB2": { singular: "square inch", plural: "square inches" },
+  ac: { singular: "acre", plural: "acres" },
+  // Angle Units
+  rad: { singular: "radian", plural: "radians" },
+  deg: { singular: "degree", plural: "degrees" },
+  grad: { singular: "gradian", plural: "gradians" },
+  // Temperature Units
+  K: { singular: "kelvin", plural: "kelvins" },
+  "\xB0C": { singular: "degree Celsius", plural: "degrees Celsius" },
+  "\xB0F": { singular: "degree Fahrenheit", plural: "degrees Fahrenheit" },
+  // Speed Units
+  "m/s": { singular: "meter per second", plural: "meters per second" },
+  "m/s\xB2": {
+    singular: "meter per second squared",
+    plural: "meters per second squared"
+  },
+  "km/h": { singular: "kilometer per hour", plural: "kilometers per hour" },
+  "km/L": { singular: "kilometer per liter", plural: "kilometers per liter" },
+  mph: { singular: "mile per hour", plural: "miles per hour" },
+  "ft/s": { singular: "foot per second", plural: "feet per second" },
+  kn: { singular: "knot", plural: "knots" },
+  mach: { singular: "mach", plural: "" },
+  c: { singular: "speed of light", plural: "" },
+  // Force Units
+  N: { singular: "newton", plural: "newtons" },
+  kgf: { singular: "kilogram-force", plural: "" },
+  lbf: { singular: "pound-force", plural: "" },
+  dyn: { singular: "dyne", plural: "dynes" },
+  // Pressure Units
+  Pa: { singular: "pascal", plural: "pascals" },
+  kPa: { singular: "kilopascal", plural: "kilopascals" },
+  MPa: { singular: "megapascal", plural: "megapascals" },
+  bar: { singular: "bar", plural: "bars" },
+  atm: { singular: "atmosphere", plural: "atmospheres" },
+  mmHg: { singular: "millimeter of mercury", plural: "millimeters of mercury" },
+  inHg: { singular: "inch of mercury", plural: "inches of mercury" },
+  psi: { singular: "pound per square inch", plural: "pounds per square inch" },
+  "N/m\xB2": {
+    singular: "newton per square meter",
+    plural: "newtons per square meter"
+  },
+  "kg/m\xB2": {
+    singular: "kilogram per square meter",
+    plural: "kilograms per square meter"
+  },
+  // Energy Units
+  J: { singular: "joule", plural: "joules" },
+  kJ: { singular: "kilojoule", plural: "kilojoules" },
+  MJ: { singular: "megajoule", plural: "megajoules" },
+  cal: { singular: "calorie", plural: "calories" },
+  kcal: { singular: "kilocalorie", plural: "kilocalories" },
+  eV: { singular: "electron volt", plural: "electron volts" },
+  BTU: { singular: "British thermal unit", plural: "British thermal units" },
+  kWh: { singular: "kilowatt hour", plural: "kilowatt hours" },
+  // Power Units
+  W: { singular: "watt", plural: "watts" },
+  kW: { singular: "kilowatt", plural: "kilowatts" },
+  MW: { singular: "megawatt", plural: "megawatts" },
+  hp: { singular: "horsepower", plural: "" },
+  // Frequency Units
+  Hz: { singular: "hertz", plural: "" },
+  kHz: { singular: "kilohertz", plural: "" },
+  MHz: { singular: "megahertz", plural: "" },
+  GHz: { singular: "gigahertz", plural: "" },
+  rpm: { singular: "revolution per minute", plural: "revolutions per minute" },
+  "rad/s": { singular: "radian per second", plural: "radians per second" },
+  "deg/s": { singular: "degree per second", plural: "degrees per second" },
+  // Electrical Units
+  V: { singular: "volt", plural: "volts" },
+  mV: { singular: "millivolt", plural: "millivolts" },
+  \u03BCV: { singular: "microvolt", plural: "microvolts" },
+  kV: { singular: "kilovolt", plural: "kilovolts" },
+  A: { singular: "ampere", plural: "amperes" },
+  mA: { singular: "milliampere", plural: "milliamperes" },
+  \u03BCA: { singular: "microampere", plural: "microamperes" },
+  \u03A9: { singular: "ohm", plural: "ohms" },
+  k\u03A9: { singular: "kilohm", plural: "kilohms" },
+  M\u03A9: { singular: "megohm", plural: "megohms" },
+  F: { singular: "farad", plural: "farads" },
+  \u03BCF: { singular: "microfarad", plural: "microfarads" },
+  nF: { singular: "nanofarad", plural: "nanofarads" },
+  pF: { singular: "picofarad", plural: "picofarads" },
+  H: { singular: "henry", plural: "henries" },
+  mH: { singular: "millihenry", plural: "millihenries" },
+  \u03BCH: { singular: "microhenry", plural: "microhenries" },
+  S: { singular: "siemens", plural: "" },
+  "S/m": { singular: "siemens per meter", plural: "" },
+  "F/m": { singular: "farad per meter", plural: "farads per meter" },
+  "\u03A9\xB7m": { singular: "ohm meter", plural: "ohm meters" },
+  "V/m": { singular: "volt per meter", plural: "volts per meter" },
+  "A/m": { singular: "ampere per meter", plural: "amperes per meter" },
+  // Magnetic Units
+  T: { singular: "tesla", plural: "teslas" },
+  mT: { singular: "millitesla", plural: "milliteslas" },
+  \u03BCT: { singular: "microtesla", plural: "microteslas" },
+  G: { singular: "gauss", plural: "" },
+  Wb: { singular: "weber", plural: "webers" },
+  mWb: { singular: "milliweber", plural: "milliwebers" },
+  \u03BCWb: { singular: "microweber", plural: "microwebers" },
+  // Density Units
+  "kg/m\xB3": {
+    singular: "kilogram per cubic meter",
+    plural: "kilograms per cubic meter"
+  },
+  "g/cm\xB3": {
+    singular: "gram per cubic centimeter",
+    plural: "grams per cubic centimeter"
+  },
+  "g/mL": { singular: "gram per milliliter", plural: "grams per milliliter" },
+  "lb/ft\xB3": {
+    singular: "pound per cubic foot",
+    plural: "pounds per cubic foot"
+  },
+  "lb/in\xB3": {
+    singular: "pound per cubic inch",
+    plural: "pounds per cubic inch"
+  },
+  sg: { singular: "specific gravity", plural: "" },
+  // Volumetric Flow Units
+  "m\xB3/s": {
+    singular: "cubic meter per second",
+    plural: "cubic meters per second"
+  },
+  "L/s": { singular: "liter per second", plural: "liters per second" },
+  "L/min": { singular: "liter per minute", plural: "liters per minute" },
+  "L/h": { singular: "liter per hour", plural: "liters per hour" },
+  "gal/min": { singular: "gallon per minute", plural: "gallons per minute" },
+  "ft\xB3/s": {
+    singular: "cubic foot per second",
+    plural: "cubic feet per second"
+  },
+  "bbl/d": { singular: "barrel per day", plural: "barrels per day" },
+  // Fuel Economy Units
+  "L/100km": { singular: "liter per 100 kilometers", plural: "" },
+  mpg: { singular: "mile per gallon", plural: "miles per gallon" },
+  mpg_imp: {
+    singular: "mile per gallon imperial",
+    plural: "miles per gallon imperial"
+  },
+  "L/km": { singular: "liter per kilometer", plural: "liters per kilometer" },
+  "L/m": { singular: "liter per meter", plural: "liters per meter" },
+  // Concentration Units
+  ppm: { singular: "part per million", plural: "parts per million" },
+  ppb: { singular: "part per billion", plural: "parts per billion" },
+  ppt: { singular: "part per trillion", plural: "parts per trillion" },
+  "mol/L": { singular: "mole per liter", plural: "moles per liter" },
+  "mol/m\xB3": {
+    singular: "mole per cubic meter",
+    plural: "moles per cubic meter"
+  },
+  "mg/L": { singular: "milligram per liter", plural: "milligrams per liter" },
+  "g/L": { singular: "gram per liter", plural: "grams per liter" },
+  "mg/kg": {
+    singular: "milligram per kilogram",
+    plural: "milligrams per kilogram"
+  },
+  // Illumination Units
+  lm: { singular: "lumen", plural: "lumens" },
+  cd: { singular: "candela", plural: "candelas" },
+  lx: { singular: "lux", plural: "" },
+  "ft-cd": { singular: "foot-candle", plural: "foot-candles" },
+  // Radiation Units
+  Bq: { singular: "becquerel", plural: "becquerels" },
+  Ci: { singular: "curie", plural: "curies" },
+  Sv: { singular: "sievert", plural: "sieverts" },
+  Gy: { singular: "gray", plural: "grays" },
+  // Catalytic Activity Units
+  kat: { singular: "katal", plural: "katals" },
+  U: { singular: "enzyme unit", plural: "enzyme units" },
+  // Viscosity and Fluid Properties Units
+  "Pa\xB7s": { singular: "pascal second", plural: "pascal seconds" },
+  cP: { singular: "centipoise", plural: "" },
+  "kg/(m\xB7s)": {
+    singular: "kilogram per meter second",
+    plural: "kilograms per meter second"
+  },
+  "lb/(ft\xB7s)": {
+    singular: "pound per foot second",
+    plural: "pounds per foot second"
+  },
+  "m\xB2/s": {
+    singular: "square meter per second",
+    plural: "square meters per second"
+  },
+  St: { singular: "stokes", plural: "" },
+  cSt: { singular: "centistokes", plural: "" },
+  "N/m": { singular: "newton per meter", plural: "newtons per meter" },
+  "dyn/cm": { singular: "dyne per centimeter", plural: "dynes per centimeter" },
+  // Thermal Properties Units
+  "W/(m\xB7K)": {
+    singular: "watt per meter kelvin",
+    plural: "watts per meter kelvin"
+  },
+  "cal/(cm\xB7s\xB7\xB0C)": {
+    singular: "calorie per centimeter second degree Celsius",
+    plural: "calories per centimeter second degree Celsius"
+  },
+  "J/(kg\xB7K)": {
+    singular: "joule per kilogram kelvin",
+    plural: "joules per kilogram kelvin"
+  },
+  "cal/(g\xB7\xB0C)": {
+    singular: "calorie per gram degree Celsius",
+    plural: "calories per gram degree Celsius"
+  },
+  "1/K": { singular: "per kelvin", plural: "" },
+  "1/\xB0C": { singular: "per degree Celsius", plural: "" },
+  "W/m\xB2": {
+    singular: "watt per square meter",
+    plural: "watts per square meter"
+  },
+  "cal/(cm\xB2\xB7s)": {
+    singular: "calorie per square centimeter second",
+    plural: "calories per square centimeter second"
+  },
+  "W/(m\xB2\xB7K)": {
+    singular: "watt per square meter kelvin",
+    plural: "watts per square meter kelvin"
+  },
+  "cal/(cm\xB2\xB7s\xB7\xB0C)": {
+    singular: "calorie per square centimeter second degree Celsius",
+    plural: "calories per square centimeter second degree Celsius"
+  },
+  "K/W": { singular: "kelvin per watt", plural: "kelvins per watt" },
+  "\xB0C/W": {
+    singular: "degree Celsius per watt",
+    plural: "degrees Celsius per watt"
+  },
+  // Data Transfer and Storage Units
+  b: { singular: "bit", plural: "bits" },
+  B: { singular: "byte", plural: "bytes" },
+  kb: { singular: "kilobit", plural: "kilobits" },
+  kB: { singular: "kilobyte", plural: "kilobytes" },
+  Mb: { singular: "megabit", plural: "megabits" },
+  MB: { singular: "megabyte", plural: "megabytes" },
+  Gb: { singular: "gigabit", plural: "gigabits" },
+  GB: { singular: "gigabyte", plural: "gigabytes" },
+  Tb: { singular: "terabit", plural: "terabits" },
+  TB: { singular: "terabyte", plural: "terabytes" },
+  bps: { singular: "bit per second", plural: "bits per second" },
+  kbps: { singular: "kilobit per second", plural: "kilobits per second" },
+  Mbps: { singular: "megabit per second", plural: "megabits per second" },
+  Gbps: { singular: "gigabit per second", plural: "gigabits per second" }
+};
+var numbers = {
+  ones: ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"],
+  teens: ["ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"],
+  tens: ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"],
+  scales: ["", "thousand", "million", "billion", "trillion", "quadrillion", "quintillion"]};
+var currencySymbols = {
+  $: {
+    singular: "dollar",
+    plural: "dollars",
+    fraction: { singular: "cent", plural: "cents" }
+  },
+  "\u20AC": {
+    singular: "euro",
+    plural: "euros",
+    fraction: { singular: "cent", plural: "cents" }
+  },
+  "\xA3": {
+    singular: "pound",
+    plural: "pounds",
+    fraction: { singular: "penny", plural: "pence" }
+  },
+  "\xA5": {
+    singular: "yen",
+    plural: "yen",
+    fraction: null
+  },
+  "\u20B9": {
+    singular: "rupee",
+    plural: "rupees",
+    fraction: { singular: "paisa", plural: "paise" }
+  }
+};
+var currencyCodes = {
+  USD: {
+    singular: "dollar",
+    plural: "dollars",
+    fraction: { singular: "cent", plural: "cents" }
+  },
+  EUR: {
+    singular: "euro",
+    plural: "euros",
+    fraction: { singular: "cent", plural: "cents" }
+  },
+  GBP: {
+    singular: "pound",
+    plural: "pounds",
+    fraction: { singular: "penny", plural: "pence" }
+  },
+  JPY: {
+    singular: "yen",
+    plural: "yen",
+    fraction: null
+  },
+  INR: {
+    singular: "rupee",
+    plural: "rupees",
+    fraction: { singular: "paisa", plural: "paise" }
+  },
+  CHF: {
+    singular: "Swiss franc",
+    plural: "Swiss francs",
+    fraction: { singular: "rappen", plural: "rappen" }
+  },
+  AUD: {
+    singular: "Australian dollar",
+    plural: "Australian dollars",
+    fraction: { singular: "cent", plural: "cents" }
+  },
+  CAD: {
+    singular: "Canadian dollar",
+    plural: "Canadian dollars",
+    fraction: { singular: "cent", plural: "cents" }
+  }
+};
+var currencies = {
+  ...currencySymbols,
+  ...currencyCodes
+};
+var math = {
+  "+": "plus",
+  "-": "minus",
+  "*": "times",
+  "\xD7": "times",
+  "\xB7": "times",
+  "/": "divided by",
+  "\xF7": "divided by",
+  ":": "divided by",
+  "^": "to the power of"
+};
+
+// src/utils/extraction/regexPatterns.ts
+var sanitizeString = (str) => {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+var currencySymbolsSanitized = Object.keys(currencySymbols).map((key) => sanitizeString(key)).join("|");
+var currencyCodesSanitized = Object.keys(currencyCodes).join("|");
+var allUnits = Object.keys(units).map((key) => sanitizeString(key)).sort((a, b) => b.length - a.length).join("|");
+var operatorSymbols = Object.keys(math).map((operator) => sanitizeString(operator)).join("|");
+var regexMatches = new RegExp(
+  [
+    // Currency Matching (Highest Priority)
+    `(?<=^|\\s)(?:(?<symbolCurrency>(?<negativeSignSymbol>-)?(?<currencySymbol>${currencySymbolsSanitized})\\s*(?<symbolInt>(?:\\d{1,3}(?:,\\d{3})*|\\d+))(?:\\.(?<symbolDec>\\d+))?)|(?<codeCurrency>(?<negativeSignCode>-)?(?<codeInt>(?:\\d{1,3}(?:,\\d{3})*|\\d+))(?:\\.(?<codeDec>\\d+))?[ \\t]*(?<currencyCode>${currencyCodesSanitized})))(?=(?:\\s|$|(?:\\.(?!\\d))|[^\\d.]))`,
+    // Ensures the match is followed by whitespace, end of string, or non-numeric characters
+    // Scientific Notation 5e-10, 5e10, 5.5e10, 5.5e-10
+    `|(?<scientific>(?<negativeSignScientific>-)?(?<scientificInt>\\d+)(?:\\.(?<scientificDec>\\d+))?(?:[eE])(?<scientificExponent>[+-]?\\d+))(?=(?:\\s|$|(?:\\.(?!\\d))|[^\\d.]))`,
+    // Ensures the match is followed by whitespace, end of string, or non-numeric characters
+    // Numeric Units 5km, 10m/s, 10m/s^2, 10m/s², 10m²/s, 10m²/s²
+    `|(?<unit>(?<negativeSignUnit>-)?(?<unitInt>(?:\\d{1,3}(?:,\\d{3})*|\\d+))(?:\\.(?<unitDec>\\d+))?\\s*(?:\\^(?<unitCaretExponentPre>-?\\d+)|(?<unitSuperExponentPre>\u207B?[\xB9\xB2\xB3\u2074\u2075\u2076\u2077\u2078\u2079]))?\\s*(?<unitName>(?:${allUnits})\\b)(?:\\^(?<unitCaretExponentPost>-?\\d+)|(?<unitSuperExponentPost>\u207B?[\xB9\xB2\xB3\u2074\u2075\u2076\u2077\u2078\u2079]))?)(?=(?:\\s|$|(?:\\.(?!\\d))|[^\\d.]))`,
+    // Ensures the match is followed by whitespace, end of string, or non-numeric characters
+    // Number with optional exponent
+    `|(?<!\\w)(?<number>(?<negativeSignInteger>-)?(?<integerInt>(?:\\d{1,3}(?:,\\d{3})*|\\d+))(?:\\.(?<integerDec>\\d+))?(?:(?:\\^(?<integerCaretExponent>-?\\d+))|(?<integerSuperExponent>\u207B?[\xB9\xB2\xB3\u2074\u2075\u2076\u2077\u2078\u2079]))?)(?=(?:\\s|$|(?:\\.(?!\\d))|[^\\d.]))`,
+    // Ensures the match is followed by whitespace, end of string, or non-numeric characters
+    // Unit Only (e.g., m, kg, m², kg³)
+    `|(?<unitOnly>(?<![\\w.])(?<unitNameOnly>(?:${allUnits})\\b)(?:\\^(?<unitOnlyCaretExponent>-?\\d+)|(?<unitOnlySuperExponent>\u207B?[\xB9\xB2\xB3\u2074\u2075\u2076\u2077\u2078\u2079]))?(?!\\w))(?=(?:\\s|$|(?:\\.(?!\\d))|[^\\d.]))`,
+    // Ensures the match is followed by whitespace, end of string, or non-numeric characters
+    // Mathematical Operators
+    `|(?<operator>(?:(?<=^)|(?<=\\s))(${operatorSymbols})(?=\\s|$|(?:\\.(?!\\d))))`
+    // Matches mathematical operators
+  ].join(""),
+  "u"
+);
+
+// src/utils/extraction/patternExtractor.ts
+function extractFirstMatch(input) {
+  const match = input.match(regexMatches);
+  if (match && match.groups && match.index !== void 0) {
+    const matchedGroup = Object.fromEntries(Object.entries(match.groups).filter(([_, value]) => value !== void 0));
+    let matchType = Object.keys(matchedGroup)[0];
+    const extractedGroup = {};
+    switch (matchType) {
+      case "symbolCurrency":
+        extractedGroup.integer = matchedGroup["symbolInt"];
+        extractedGroup.decimal = matchedGroup["symbolDec"];
+        extractedGroup.negativeInt = matchedGroup["negativeSignSymbol"] !== void 0;
+        extractedGroup.currency = matchedGroup["currencySymbol"];
+        break;
+      case "codeCurrency":
+        extractedGroup.integer = matchedGroup["codeInt"];
+        extractedGroup.decimal = matchedGroup["codeDec"];
+        extractedGroup.negativeInt = matchedGroup["negativeSignCode"] !== void 0;
+        extractedGroup.currency = matchedGroup["currencyCode"];
+        break;
+      case "scientific":
+        extractedGroup.integer = matchedGroup["scientificInt"];
+        extractedGroup.decimal = matchedGroup["scientificDec"];
+        extractedGroup.negativeInt = matchedGroup["negativeSignScientific"] !== void 0;
+        extractedGroup.exponent = matchedGroup["scientificExponent"];
+        break;
+      case "unit":
+        extractedGroup.integer = matchedGroup["unitInt"];
+        extractedGroup.decimal = matchedGroup["unitDec"];
+        extractedGroup.negativeInt = matchedGroup["negativeSignUnit"] !== void 0;
+        extractedGroup.unit = matchedGroup["unitName"];
+        extractedGroup.exponent = matchedGroup["unitCaretExponentPre"] || matchedGroup["unitSuperExponentPre"];
+        extractedGroup.unitExponent = matchedGroup["unitCaretExponentPost"] || matchedGroup["unitSuperExponentPost"];
+        break;
+      case "unitOnly":
+        extractedGroup.unit = matchedGroup["unitNameOnly"];
+        extractedGroup.unitExponent = matchedGroup["unitOnlyCaretExponent"] || matchedGroup["unitOnlySuperExponent"];
+        break;
+      case "operator":
+        break;
+      case "number":
+        extractedGroup.integer = matchedGroup["integerInt"];
+        extractedGroup.decimal = matchedGroup["integerDec"];
+        extractedGroup.exponent = matchedGroup["integerSuperExponent"] || matchedGroup["integerCaretExponent"];
+        extractedGroup.negativeInt = matchedGroup["negativeSignInteger"] !== void 0;
+        break;
+    }
+    extractedGroup.matchType = matchType;
+    extractedGroup.input = matchedGroup[matchType];
+    extractedGroup.index = match.index;
+    if (matchType !== "operator" && matchType !== "scientific" && matchType !== "unitOnly")
+      extractedGroup.integer = extractedGroup.integer !== void 0 ? extractedGroup.integer.replace(/,/g, "") : "0";
+    return extractedGroup;
+  }
+  return null;
+}
+function extractAllMatches(input) {
+  const results = [];
+  let remainingInput = input;
+  let currentExtraction = extractFirstMatch(remainingInput);
+  while (currentExtraction !== null && currentExtraction.input) {
+    const remainingLength = input.length - remainingInput.length;
+    if (results.length > 0) {
+      currentExtraction.index = remainingInput.indexOf(currentExtraction.input) + remainingLength;
+    }
+    results.push(currentExtraction);
+    remainingInput = remainingInput.substring(
+      remainingInput.indexOf(currentExtraction.input) + currentExtraction.input.length
+    );
+    currentExtraction = extractFirstMatch(remainingInput);
+  }
+  return results;
+}
+
+// src/utils/stringBuilding/zeroTo999.ts
+function zeroTo999(num) {
+  if (num === 0) {
+    return "";
+  }
+  let words = "";
+  if (num >= 100) {
+    words += numbers.ones[Math.floor(num / 100)] + " hundred";
+    num %= 100;
+    if (num > 0) {
+      words += " ";
+    }
+  }
+  if (num >= 20) {
+    words += numbers.tens[Math.floor(num / 10)];
+    num %= 10;
+    if (num > 0) {
+      words += " " + numbers.ones[num];
+    }
+  } else if (num >= 10) {
+    words += numbers.teens[num - 10];
+  } else if (num > 0) {
+    words += numbers.ones[num];
+  }
+  return words;
+}
+
+// src/utils/stringBuilding/positiveInteger.ts
+function positiveInteger(num) {
+  if (typeof num !== "number" || !Number.isInteger(num) || num < 0) {
+    return "Invalid input: Please provide a non-negative integer.";
+  }
+  if (num === 0) {
+    return "zero";
+  }
+  let words = "";
+  let scaleIndex = 0;
+  while (num > 0) {
+    if (num % 1e3 !== 0) {
+      const upToHundreds = zeroTo999(num % 1e3);
+      const magnitudeScale = numbers.scales[scaleIndex] ? " " + numbers.scales[scaleIndex] : "";
+      words = upToHundreds + magnitudeScale + (words ? " " + words : "");
+    }
+    num = Math.floor(num / 1e3);
+    scaleIndex++;
+  }
+  return words.trim().replace(/\s+/g, " ");
+}
+
+// src/utils/stringBuilding/twoDigits.ts
+function twoDigit(num) {
+  if (num.trim().length !== 2) return "";
+  let parsed = parseInt(num);
+  if (parsed < 100 && parsed >= 0) return positiveInteger(parsed);
+  return "";
+}
+
+// src/utils/stringBuilding/negative.ts
+var negative = (bool) => {
+  return bool ? "negative " : "";
+};
+
+// src/converters/convertCurrencyToSpokenWord.ts
+function convertCurrencyToSpokenWord(amount) {
+  let sentence = "";
+  const { integer, decimal, negativeInt, currency } = amount;
+  let currencyConfig = currencies[currency];
+  let parsedInteger = parseInt(integer);
+  sentence += negative(negativeInt);
+  sentence += positiveInteger(parsedInteger) + " ";
+  sentence += parsedInteger < 2 ? currencyConfig.singular : currencyConfig.plural + " ";
+  if (decimal !== void 0 && currencyConfig.fraction !== null && currencyConfig.fraction !== void 0) {
+    sentence += "and ";
+    sentence += twoDigit(decimal) + " ";
+    sentence += parseInt(decimal) < 2 ? currencyConfig.fraction.singular : currencyConfig.fraction.plural;
+  }
+  return sentence.trim();
+}
+
+// src/utils/stringBuilding/perDigit.ts
+function perDigit(num) {
+  const words = [];
+  for (let i = 0; i < num.length; i++) {
+    words.push(positiveInteger(parseInt(num[i])));
+  }
+  return words.join(" ");
+}
+
+// src/utils/parseSuperscript.ts
+function toRegularInteger(superscriptString) {
+  const superscriptMap = {
+    "\u2070": "0",
+    "\xB9": "1",
+    "\xB2": "2",
+    "\xB3": "3",
+    "\u2074": "4",
+    "\u2075": "5",
+    "\u2076": "6",
+    "\u2077": "7",
+    "\u2078": "8",
+    "\u2079": "9"
+  };
+  let standardDigitString = "";
+  for (let char of superscriptString) {
+    if (superscriptMap[char]) {
+      standardDigitString += superscriptMap[char];
+    } else {
+      standardDigitString += char;
+    }
+  }
+  return standardDigitString;
+}
+
+// src/utils/stringBuilding/exponent.ts
+function exponentSpokenWord(exponent, onlyUsePowerOf = false) {
+  const isNegative = exponent.startsWith("-") || exponent.startsWith("\u207B");
+  let newExponentString = toRegularInteger(isNegative ? exponent.slice(1) : exponent);
+  if (!onlyUsePowerOf && !isNegative) {
+    if (newExponentString === "2") {
+      return "squared";
+    }
+    if (newExponentString === "3") {
+      return "cubed";
+    }
+  }
+  let res = "to the power of " + (isNegative ? "negative " : "") + positiveInteger(parseInt(newExponentString));
+  return res;
+}
+
+// src/converters/convertNumberToSpokenWord.ts
+function convertNumberToSpokenWord(num) {
+  const { integer, decimal, negativeInt, exponent } = num;
+  let sentence = negative(negativeInt);
+  sentence += positiveInteger(parseInt(integer)) + " ";
+  if (decimal !== void 0) {
+    sentence += "point ";
+    if (decimal.length === 1 || decimal.length > 2) {
+      sentence += perDigit(decimal) + " ";
+    } else {
+      sentence += twoDigit(decimal) + " ";
+    }
+  }
+  if (exponent !== void 0) {
+    sentence += exponentSpokenWord(exponent, true);
+  }
+  return sentence.trim();
+}
+
+// src/converters/convertNumericUnitToSpokenWord.ts
+function convertNumericUnitToSpokenWord(numericUnit) {
+  const { integer, decimal, unit, negativeInt, exponent, unitExponent } = numericUnit;
+  let sentence = convertNumberToSpokenWord({
+    integer,
+    decimal,
+    negativeInt});
+  let spokenUnit;
+  let directUnitKey = unit + (unitExponent !== void 0 ? unitExponent : "");
+  let directUnit = units[directUnitKey];
+  if (directUnit !== void 0) {
+    spokenUnit = directUnit;
+  } else {
+    spokenUnit = units[unit];
+  }
+  if (spokenUnit === void 0) {
+    return "";
+  }
+  let isPlural = parseFloat(integer + "." + decimal) > 1 && spokenUnit.plural;
+  let spokenNumberExponent = "";
+  let spokenUnitExponent = "";
+  if (exponent !== void 0) {
+    spokenNumberExponent = exponentSpokenWord(exponent, true);
+  }
+  if (unitExponent !== void 0 && directUnit === void 0) {
+    spokenUnitExponent = exponentSpokenWord(unitExponent);
+  }
+  sentence += " " + spokenNumberExponent + " " + (isPlural ? spokenUnit.plural : spokenUnit.singular) + " " + spokenUnitExponent;
+  sentence = sentence.trim().replace(/\s+/g, " ");
+  return sentence;
+}
+
+// src/converters/convertOperatorToSpokenWord.ts
+function convertOperatorToSpokenWord(operatorObject) {
+  const { input } = operatorObject;
+  if (input === void 0) {
+    return "";
+  }
+  return math[input];
+}
+
+// src/converters/convertScientificExpressionToSpokenWord.ts
+function convertScientificExpressionToSpokenWord(expression) {
+  const { integer, decimal, exponent, negativeInt } = expression;
+  const isNegativeExponent = exponent.startsWith("-") || exponent.startsWith("\u207B");
+  let E = "times ten to the power of ";
+  let sentence = convertNumberToSpokenWord({
+    integer,
+    decimal,
+    negativeInt}) + " " + E + convertNumberToSpokenWord({
+    decimal: void 0,
+    negativeInt: isNegativeExponent,
+    integer: toRegularInteger(isNegativeExponent ? exponent.slice(1) : exponent)});
+  return sentence.trim();
+}
+
+// src/converters/convertUnitOnlyToSpokenWord.ts
+function convertUnitOnlyToSpokenWord(unitOnlyObject) {
+  const { unit, unitExponent } = unitOnlyObject;
+  let spokenUnit;
+  spokenUnit = units[unit];
+  let result = "";
+  if (spokenUnit === void 0) {
+    return "";
+  }
+  if (unitExponent !== void 0) {
+    result = spokenUnit.singular + " " + exponentSpokenWord(unitExponent);
+  } else {
+    result = spokenUnit.singular;
+  }
+  return result;
+}
+
+// src/utils/validateExtractionResultObject.ts
+function isValidIntegerString(str, allowNegative = false) {
+  if (str === void 0) {
+    return true;
+  }
+  let regex;
+  if (allowNegative) {
+    regex = /^(?:[\u207B\u002D]?[\d\u2070-\u2079]+)$/;
+  } else {
+    regex = /^[\d\u2070-\u2079]+$/;
+  }
+  return regex.test(str);
+}
+function validateExtractionResult(extractionResult) {
+  if (!extractionResult) {
+    throw new Error("validateExtractionResult: ExtractionResult cannot be null or undefined.");
+  }
+  if (typeof extractionResult !== "object") {
+    throw new Error("validateExtractionResult: ExtractionResult must be an object.");
+  }
+  if (!("input" in extractionResult)) {
+    throw new Error("validateExtractionResult: ExtractionResult is missing the 'input' property.");
+  }
+  if (typeof extractionResult.input !== "string") {
+    throw new Error("validateExtractionResult: ExtractionResult 'input' property must be a string.");
+  }
+  if (!("matchType" in extractionResult)) {
+    throw new Error("validateExtractionResult: ExtractionResult is missing the 'matchType' property.");
+  }
+  if (typeof extractionResult.matchType !== "string") {
+    throw new Error("validateExtractionResult: ExtractionResult 'matchType' property must be a string.");
+  }
+  if (!("index" in extractionResult)) {
+    throw new Error("validateExtractionResult: ExtractionResult is missing the 'index' property.");
+  }
+  if (typeof extractionResult.index !== "number") {
+    throw new Error("validateExtractionResult: ExtractionResult 'index' property must be a number.");
+  }
+  const { matchType } = extractionResult;
+  switch (matchType) {
+    case "number":
+      if (!("integer" in extractionResult)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'number', ExtractionResult is missing the 'integer' property."
+        );
+      }
+      if (typeof extractionResult.integer !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'number', ExtractionResult 'integer' property must be a string."
+        );
+      }
+      if (!isValidIntegerString(extractionResult.integer)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'number', ExtractionResult 'integer' property must contain only integers."
+        );
+      }
+      if ("decimal" in extractionResult && extractionResult.decimal !== void 0 && typeof extractionResult.decimal !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'number', ExtractionResult 'decimal' property must be a string if present."
+        );
+      }
+      if ("decimal" in extractionResult && extractionResult.decimal !== void 0 && !isValidIntegerString(extractionResult.decimal)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'number', ExtractionResult 'decimal' property must contain only integers."
+        );
+      }
+      if (!("negativeInt" in extractionResult)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'number', ExtractionResult is missing the 'negativeInt' property."
+        );
+      }
+      if (typeof extractionResult.negativeInt !== "boolean") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'number', ExtractionResult 'negativeInt' property must be a boolean."
+        );
+      }
+      if ("exponent" in extractionResult && extractionResult.exponent !== void 0 && typeof extractionResult.exponent !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'number', ExtractionResult 'exponent' property must be a string if present."
+        );
+      }
+      if ("exponent" in extractionResult && extractionResult.exponent !== void 0 && !isValidIntegerString(extractionResult.exponent, true)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'number', ExtractionResult 'exponent' property must contain only integers or superscript integers (and their respective negative symbol - and \u207B)."
+        );
+      }
+      break;
+    case "symbolCurrency":
+    case "codeCurrency":
+      if (!("integer" in extractionResult)) {
+        throw new Error(
+          `validateExtractionResult: For matchType '${matchType}', ExtractionResult is missing the 'integer' property.`
+        );
+      }
+      if (typeof extractionResult.integer !== "string") {
+        throw new Error(
+          `validateExtractionResult: For matchType '${matchType}', ExtractionResult 'integer' property must be a string.`
+        );
+      }
+      if (!isValidIntegerString(extractionResult.integer)) {
+        throw new Error(
+          `validateExtractionResult: For matchType '${matchType}', ExtractionResult 'integer' property must contain only integers.`
+        );
+      }
+      if ("decimal" in extractionResult && extractionResult.decimal !== void 0 && typeof extractionResult.decimal !== "string") {
+        throw new Error(
+          `validateExtractionResult: For matchType '${matchType}', ExtractionResult 'decimal' property must be a string if present.`
+        );
+      }
+      if ("decimal" in extractionResult && extractionResult.decimal !== void 0 && !isValidIntegerString(extractionResult.decimal)) {
+        throw new Error(
+          `validateExtractionResult: For matchType '${matchType}', ExtractionResult 'decimal' property must contain only integers.`
+        );
+      }
+      if (!("negativeInt" in extractionResult)) {
+        throw new Error(
+          `validateExtractionResult: For matchType '${matchType}', ExtractionResult is missing the 'negativeInt' property.`
+        );
+      }
+      if (typeof extractionResult.negativeInt !== "boolean") {
+        throw new Error(
+          `validateExtractionResult: For matchType '${matchType}', ExtractionResult 'negativeInt' property must be a boolean.`
+        );
+      }
+      if (!("currency" in extractionResult)) {
+        throw new Error(
+          `validateExtractionResult: For matchType '${matchType}', ExtractionResult is missing the 'currency' property.`
+        );
+      }
+      if (typeof extractionResult.currency !== "string") {
+        throw new Error(
+          `validateExtractionResult: For matchType '${matchType}', ExtractionResult 'currency' property must be a string.`
+        );
+      }
+      break;
+    case "unit":
+      if (!("integer" in extractionResult)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult is missing the 'integer' property."
+        );
+      }
+      if (typeof extractionResult.integer !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'integer' property must be a string."
+        );
+      }
+      if (!isValidIntegerString(extractionResult.integer)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'integer' property must contain only integers."
+        );
+      }
+      if ("decimal" in extractionResult && extractionResult.decimal !== void 0 && typeof extractionResult.decimal !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'decimal' property must be a string if present."
+        );
+      }
+      if ("decimal" in extractionResult && extractionResult.decimal !== void 0 && !isValidIntegerString(extractionResult.decimal)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'decimal' property must contain only integers."
+        );
+      }
+      if (!("negativeInt" in extractionResult)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult is missing the 'negativeInt' property."
+        );
+      }
+      if (typeof extractionResult.negativeInt !== "boolean") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'negativeInt' property must be a boolean."
+        );
+      }
+      if (!("unit" in extractionResult)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult is missing the 'unit' property."
+        );
+      }
+      if (typeof extractionResult.unit !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'unit' property must be a string."
+        );
+      }
+      if ("exponent" in extractionResult && extractionResult.exponent !== void 0 && typeof extractionResult.exponent !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'exponent' property must be a string if present."
+        );
+      }
+      if ("exponent" in extractionResult && extractionResult.exponent !== void 0 && !isValidIntegerString(extractionResult.exponent, true)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'exponent' property must contain only integers or superscript integers (and their respective negative symbol - and \u207B)."
+        );
+      }
+      if ("unitExponent" in extractionResult && extractionResult.unitExponent !== void 0 && typeof extractionResult.unitExponent !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'unitExponent' property must be a string if present."
+        );
+      }
+      if ("unitExponent" in extractionResult && extractionResult.unitExponent !== void 0 && !isValidIntegerString(extractionResult.unitExponent, true)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unit', ExtractionResult 'unitExponent' property must contain only integers or superscript integers (and their respective negative symbol - and \u207B)."
+        );
+      }
+      break;
+    case "unitOnly":
+      if (!("unit" in extractionResult)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unitOnly', ExtractionResult is missing the 'unit' property."
+        );
+      }
+      if (typeof extractionResult.unit !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unitOnly', ExtractionResult 'unit' property must be a string."
+        );
+      }
+      if ("unitExponent" in extractionResult && extractionResult.unitExponent !== void 0 && typeof extractionResult.unitExponent !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unitOnly', ExtractionResult 'unitExponent' property must be a string if present."
+        );
+      }
+      if ("unitExponent" in extractionResult && extractionResult.unitExponent !== void 0 && !isValidIntegerString(extractionResult.unitExponent, true)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'unitOnly', ExtractionResult 'unitExponent' property must contain only integers or superscript integers (and their respective negative symbol - and \u207B)."
+        );
+      }
+      break;
+    case "operator":
+      break;
+    // No specific properties to validate for operator
+    case "scientific":
+      if (!("integer" in extractionResult)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult is missing the 'integer' property."
+        );
+      }
+      if (typeof extractionResult.integer !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult 'integer' property must be a string."
+        );
+      }
+      if (!isValidIntegerString(extractionResult.integer)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult 'integer' property must contain only integers."
+        );
+      }
+      if ("decimal" in extractionResult && extractionResult.decimal !== void 0 && typeof extractionResult.decimal !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult 'decimal' property must be a string if present."
+        );
+      }
+      if ("decimal" in extractionResult && extractionResult.decimal !== void 0 && !isValidIntegerString(extractionResult.decimal)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult 'decimal' property must contain only integers."
+        );
+      }
+      if (!("negativeInt" in extractionResult)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult is missing the 'negativeInt' property."
+        );
+      }
+      if (typeof extractionResult.negativeInt !== "boolean") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult 'negativeInt' property must be a boolean."
+        );
+      }
+      if (!("exponent" in extractionResult)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult is missing the 'exponent' property."
+        );
+      }
+      if (extractionResult.exponent !== void 0 && typeof extractionResult.exponent !== "string") {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult 'exponent' property must be a string."
+        );
+      }
+      if (extractionResult.exponent !== void 0 && !isValidIntegerString(extractionResult.exponent, true)) {
+        throw new Error(
+          "validateExtractionResult: For matchType 'scientific', ExtractionResult 'exponent' property must contain only integers or superscript integers (and their respective negative symbol - and \u207B)."
+        );
+      }
+      break;
+    default:
+      throw new Error(`validateExtractionResult: Unknown matchType: ${matchType}`);
+  }
+}
+
+// src/index.ts
+var extractQuantities = {
+  /**
+   * Extracts the first match (number || currency || unit || operator || scientific expression) from the input string.
+   * @param {string} input - The string to extract from.
+   * @returns {ExtractionResult | null} The extracted data or null if no match is found.
+   */
+  firstMatch: extractFirstMatch,
+  /**
+   * Extracts all matches (number || currency || unit || operator || scientific expression) from the input string.
+   * @param {string} input - The string to extract from.
+   * @returns {ExtractionResult[]} The extracted data.
+   */
+  allMatches: extractAllMatches
+};
+var convertQuantities = {
+  /**
+   * Translates an ExtractionResult object (number || currency || unit || operator || scientific expression) into its spoken word equivalent.
+   *
+   * @param {ExtractionResult} extractionResult - The ExtractionResult object to translate.
+   * @returns {string} The spoken word equivalent of the ExtractionResult.
+   */
+  translateMatch: (extractionResult) => {
+    let result = "";
+    switch (extractionResult.matchType) {
+      case "number":
+        result = convertNumberToSpokenWord(extractionResult);
+        break;
+      case "symbolCurrency":
+        result = convertCurrencyToSpokenWord(extractionResult);
+        break;
+      case "codeCurrency":
+        result = convertCurrencyToSpokenWord(extractionResult);
+        break;
+      case "unit":
+        result = convertNumericUnitToSpokenWord(extractionResult);
+        break;
+      case "unitOnly":
+        result = convertUnitOnlyToSpokenWord(extractionResult);
+        break;
+      case "operator":
+        result = convertOperatorToSpokenWord(extractionResult);
+        break;
+      case "scientific":
+        result = convertScientificExpressionToSpokenWord(extractionResult);
+        break;
+    }
+    return result;
+  },
+  /**
+   * Extracts the first match (number || currency || unit || operator || scientific expression) from the input string
+   * and translates it to its spoken word equivalent.
+   *
+   * @param {string} input - The string to extract and translate from.
+   * @returns {string} The input string with the first match replaced by its spoken word equivalent,
+   * or an empty string if no match is found.
+   */
+  autoReplaceFirstMatch: (input) => {
+    const match = extractFirstMatch(input);
+    if (!match) return "";
+    return input.replace(match.input, convertQuantities.translateMatch(match));
+  },
+  /**
+   * Extracts all matches (number || currency || unit || operator || scientific expression) from the input string
+   * and translates them to their spoken word equivalents.
+   *
+   * @param {string} input - The string to extract and translate from.
+   * @returns {string} The input string with all matches replaced by their spoken word equivalents. Returns the original string if no matches are found.
+   */
+  autoReplaceAllMatches: (input) => {
+    const matches = extractAllMatches(input);
+    if (matches.length === 0) {
+      return input;
+    }
+    let output = "";
+    let lastIndex = 0;
+    for (const match of matches) {
+      output += input.substring(lastIndex, match.index);
+      output += convertQuantities.translateMatch(match);
+      lastIndex = match.index + match.input.length;
+    }
+    output += input.substring(lastIndex);
+    return output.replace(/\s+/g, " ").trim();
+  }
+};
+
+exports.convertQuantities = convertQuantities;
+exports.extractQuantities = extractQuantities;
+exports.validateExtractionResult = validateExtractionResult;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map