quantible 0.2.1 → 0.3.0

package/dist/index.cjs

@@ -295,6 +295,18 @@ var units = {
   Mbps: { singular: "megabit per second", plural: "megabits per second" },
   Gbps: { singular: "gigabit per second", plural: "gigabits per second" }
 };
+var commonSymbols = {
+  "&": " and ",
+  "@": " at ",
+  "#": " hash ",
+  "|": " pipe ",
+  ".": " dot ",
+  _: " underscore "
+};
+var abbreviationMap = {
+  "e.g.": "example given",
+  "i.e.": "that is"
+};
 var numbers = {
   ones: ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"],
   teens: ["ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"],
@@ -327,6 +339,23 @@ var currencySymbols = {
     fraction: { singular: "paisa", plural: "paise" }
   }
 };
+var trailingCurrencySymbols = {
+  "\u20A9": {
+    singular: "won",
+    plural: "won",
+    fraction: null
+  },
+  "\u20AB": {
+    singular: "dong",
+    plural: "dong",
+    fraction: null
+  },
+  "\u0E3F": {
+    singular: "baht",
+    plural: "baht",
+    fraction: { singular: "satang", plural: "satang" }
+  }
+};
 var currencyCodes = {
   USD: {
     singular: "dollar",
@@ -371,6 +400,7 @@ var currencyCodes = {
 };
 var currencies = {
   ...currencySymbols,
+  ...trailingCurrencySymbols,
   ...currencyCodes
 };
 var math = {
@@ -382,7 +412,14 @@ var math = {
   "/": "divided by",
   "\xF7": "divided by",
   ":": "divided by",
-  "^": "to the power of"
+  "^": "to the power of",
+  "=": "equals",
+  "<": "is less than",
+  ">": "is greater than",
+  "<=": "is less than or equal to",
+  ">=": "is greater than or equal to",
+  "\u2260": "is not equal to",
+  "\u2248": "is approximately equal to"
 };
 
 // src/utils/extraction/regexPatterns.ts
@@ -390,28 +427,47 @@ var sanitizeString = (str) => {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 };
 var currencySymbolsSanitized = Object.keys(currencySymbols).map((key) => sanitizeString(key)).join("|");
+var trailingCurrencySymbolsSanitized = Object.keys(trailingCurrencySymbols).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 commonSymbolsBase = Object.keys(commonSymbols).filter(
+  (symbol) => symbol !== "." && symbol !== "-" && symbol !== "_"
+);
+var commonSymbolsBaseSanitized = commonSymbolsBase.map((symbol) => sanitizeString(symbol)).join("|");
+var dotPattern = `\\.(?![0-9])(?=\\w)`;
+var underscorePattern = `_`;
+var commonSymbolsSanitized = `(?:${commonSymbolsBaseSanitized}|${dotPattern}|${underscorePattern})`;
+var operatorSymbols = Object.keys(math).sort((a, b) => b.length - a.length).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))))`
+    [
+      // 0. ABBREVIATIONS (special multi‑character sequences)
+      // Priority: Highest, to prevent mis‑matching as units or symbols
+      `(?<abbreviation>e\\.g\\.|i\\.e\\.)`,
+      // 1. COMMON SYMBOLS
+      // Priority: High
+      // Anchoring: Loose (allows matching symbols like '@' in emails or '&' in 'A&B')
+      `|(?<commonSymbol>(${commonSymbolsSanitized}))`,
+      // 2. CURRENCY MATCHING
+      // Strategy: Atomic anchoring per subtype to prevent 'loose' matches from being stolen by the 'number' group.
+      `|(?<=^|\\s)(?:(?<symbolCurrency>(?<negativeSignSymbol>-)?(?<currencySymbol>${currencySymbolsSanitized})\\s*(?<symbolInt>(?:\\d{1,3}(?:,\\d{3})*|\\d+))(?:\\.(?<symbolDec>\\d+))?)|(?<trailingSymbolCurrency>(?<negativeSignTrailing>-)?(?<trailingInt>(?:\\d{1,3}(?:,\\d{3})*|\\d+))(?:\\.(?<trailingDec>\\d+))?[ \\t]*(?<trailingCurrencySymbol>${trailingCurrencySymbolsSanitized}))|(?<codeCurrency>(?<negativeSignCode>-)?(?<codeInt>(?:\\d{1,3}(?:,\\d{3})*|\\d+))(?:\\.(?<codeDec>\\d+))?[ \\t]*(?<currencyCode>${currencyCodesSanitized})))(?=(?:\\s|$|(?:\\.(?!\\d))|[^\\d.]))`,
+      // 3. SCIENTIFIC NOTATION
+      // Target: 5e-10, 5.5E10, etc.
+      `|(?<scientific>(?<negativeSignScientific>-)?(?<scientificInt>\\d+)(?:\\.(?<scientificDec>\\d+))?(?:[eE])(?<scientificExponent>[+-]?\\d+))(?=(?:\\s|$|(?:\\.(?!\\d))|[^\\d.]))`,
+      // 4. NUMERIC UNITS
+      // Target: 5km, 10m/s^2, 10m²/s, etc.
+      `|(?<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)(?!\\s*(?:${commonSymbolsSanitized}))(?:\\^(?<unitCaretExponentPost>-?\\d+)|(?<unitSuperExponentPost>\u207B?[\xB9\xB2\xB3\u2074\u2075\u2076\u2077\u2078\u2079]))?)(?=(?:\\s|$|(?:\\.(?!\\d))|[^\\d.]))`,
+      // 5. VERSIONED NUMBERS (e.g., v2, _5, V10)
+      // Priority: Higher than generic numbers to catch specific prefixes within words/boundaries.
+      `|(?<versionedNumber>(?:v|V|_)\\d+)|(?<!\\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.]))`,
+      // 7. UNIT ONLY
+      // Target: stand-alone units (m, kg, m²)
+      `|(?<unitOnly>(?<![\\w.]|(?:${commonSymbolsSanitized})\\s+)(?<unitNameOnly>(?:${allUnits})\\b)(?!\\s*(?:${commonSymbolsSanitized}))(?:\\^(?<unitOnlyCaretExponent>-?\\d+)|(?<unitOnlySuperExponent>\u207B?[\xB9\xB2\xB3\u2074\u2075\u2076\u2077\u2078\u2079]))?(?!\\w))(?=(?:\\s|$|(?:\\.(?!\\d))|[^\\d.]))`,
+      // 7. MATHEMATICAL OPERATORS
+      // Target: standalone +, -, *, /, =, <, >, etc.
+      // Anchoring: Must be surrounded by whitespace or EOL to avoid splitting numbers/words.
+      `|(?<operator>(?:(?<=^)|(?<=\\s))(${operatorSymbols})(?=(?:\\s|$|(?:\\.(?!\\d)))))`
+    ].join("")
     // Matches mathematical operators
   ].join(""),
   "u"
@@ -425,15 +481,36 @@ function extractFirstMatch(input) {
     let matchType = Object.keys(matchedGroup)[0];
     const extractedGroup = {};
     switch (matchType) {
+      case "abbreviation":
+        extractedGroup.symbol = matchedGroup["abbreviation"];
+        break;
+      case "commonSymbol":
+        extractedGroup.symbol = matchedGroup["commonSymbol"];
+        break;
       case "symbolCurrency":
         extractedGroup.integer = matchedGroup["symbolInt"];
         extractedGroup.decimal = matchedGroup["symbolDec"];
+        if (extractedGroup.decimal && extractedGroup.decimal.length === 1) {
+          extractedGroup.decimal += "0";
+        }
         extractedGroup.negativeInt = matchedGroup["negativeSignSymbol"] !== void 0;
         extractedGroup.currency = matchedGroup["currencySymbol"];
         break;
+      case "trailingSymbolCurrency":
+        extractedGroup.integer = matchedGroup["trailingInt"];
+        extractedGroup.decimal = matchedGroup["trailingDec"];
+        if (extractedGroup.decimal && extractedGroup.decimal.length === 1) {
+          extractedGroup.decimal += "0";
+        }
+        extractedGroup.negativeInt = matchedGroup["negativeSignTrailing"] !== void 0;
+        extractedGroup.currency = matchedGroup["trailingCurrencySymbol"];
+        break;
       case "codeCurrency":
         extractedGroup.integer = matchedGroup["codeInt"];
         extractedGroup.decimal = matchedGroup["codeDec"];
+        if (extractedGroup.decimal && extractedGroup.decimal.length === 1) {
+          extractedGroup.decimal += "0";
+        }
         extractedGroup.negativeInt = matchedGroup["negativeSignCode"] !== void 0;
         extractedGroup.currency = matchedGroup["currencyCode"];
         break;
@@ -463,6 +540,12 @@ function extractFirstMatch(input) {
         extractedGroup.exponent = matchedGroup["integerSuperExponent"] || matchedGroup["integerCaretExponent"];
         extractedGroup.negativeInt = matchedGroup["negativeSignInteger"] !== void 0;
         break;
+      case "versionedNumber": {
+        const vMatch = matchedGroup["versionedNumber"];
+        extractedGroup.symbol = vMatch[0];
+        extractedGroup.integer = vMatch.slice(1);
+        break;
+      }
     }
     extractedGroup.matchType = matchType;
     extractedGroup.input = matchedGroup[matchType];
@@ -478,15 +561,13 @@ function extractAllMatches(input) {
   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
-    );
+    const lastMatchEnd = currentExtraction.index + currentExtraction.input.length;
+    remainingInput = input.substring(lastMatchEnd);
     currentExtraction = extractFirstMatch(remainingInput);
+    if (currentExtraction) {
+      currentExtraction.index += lastMatchEnd;
+    }
   }
   return results;
 }
@@ -508,7 +589,7 @@ function zeroTo999(num) {
     words += numbers.tens[Math.floor(num / 10)];
     num %= 10;
     if (num > 0) {
-      words += " " + numbers.ones[num];
+      words += "-" + numbers.ones[num];
     }
   } else if (num >= 10) {
     words += numbers.teens[num - 10];
@@ -1024,9 +1105,32 @@ var convertQuantities = {
       case "number":
         result = convertNumberToSpokenWord(extractionResult);
         break;
+      case "abbreviation": {
+        const abbrev = extractionResult.symbol;
+        result = abbreviationMap[abbrev] || abbrev;
+        break;
+      }
+      case "versionedNumber": {
+        const vNum = extractionResult;
+        const prefixChar = vNum.symbol || "";
+        const numericPart = convertNumberToSpokenWord({
+          integer: vNum.integer,
+          negativeInt: false,
+          input: vNum.integer,
+          index: vNum.index
+        });
+        result = `${prefixChar} ${numericPart}`;
+        break;
+      }
+      case "commonSymbol":
+        result = commonSymbols[extractionResult.symbol] || "";
+        break;
       case "symbolCurrency":
         result = convertCurrencyToSpokenWord(extractionResult);
         break;
+      case "trailingSymbolCurrency":
+        result = convertCurrencyToSpokenWord(extractionResult);
+        break;
       case "codeCurrency":
         result = convertCurrencyToSpokenWord(extractionResult);
         break;
@@ -1081,7 +1185,6 @@ var convertQuantities = {
     return output.replace(/\s+/g, " ").trim();
   }
 };
-console.log(convertQuantities.autoReplaceAllMatches("25 EUR"));
 
 exports.convertQuantities = convertQuantities;
 exports.extractQuantities = extractQuantities;