quantible 0.1.8-alpha → 0.1.11-alpha

package/dist/index.d.ts

@@ -1,3 +1,85 @@
+/**
+ * Represents the base structure for all extraction results,
+ * containing the input string, match type, index, and length of the extracted value.
+ */
+interface baseExtraction {
+    input: string;
+    matchType: string;
+    index: number;
+}
+/**
+ * @interface numericBaseExtraction
+ * @extends {baseExtraction}
+ * @description Represents the base structure for numeric extraction results,
+ * extending the baseExtraction with properties for integer, decimal, and negative integer indication.
+ */
+interface numericBaseExtraction extends baseExtraction {
+    integer: string;
+    decimal?: string;
+    negativeInt: boolean;
+}
+/**
+ * @interface baseCurrency
+ * @extends {numericBaseExtraction}
+ * @description Represents the structure for currency extraction results,
+ * extending the numericBaseExtraction with properties for match type (symbol or code) and currency symbol or code.
+ */
+interface baseCurrency extends numericBaseExtraction {
+    matchType: "symbolCurrency" | "codeCurrency";
+    currency: string;
+}
+/**
+ * @interface baseScientific
+ * @extends {numericBaseExtraction}
+ * @description Represents the structure for scientific notation extraction results,
+ * extending the numericBaseExtraction with properties for match type (scientific) and a mandatory exponent value.
+ */
+interface baseScientific extends numericBaseExtraction {
+    matchType: "scientific";
+    exponent: string;
+}
+/**
+ * @interface baseNumberUnit
+ * @extends {numericBaseExtraction}
+ * @description Represents the structure for quantitative unit extraction results,
+ * extending the numericBaseExtraction with properties for match type (unit), unit name, optional exponent, and optional unit exponent.
+ */
+interface baseNumberUnit extends numericBaseExtraction {
+    matchType: "unit";
+    unit: string;
+    exponent?: string;
+    unitExponent?: string;
+}
+/**
+ * @interface baseUnitOnly
+ * @extends {baseExtraction}
+ * @description Represents the structure for unit-only extraction results,
+ * extending the baseExtraction with properties for match type (unitOnly), unit name, and optional unit exponent.
+ */
+interface baseUnitOnly extends baseExtraction {
+    matchType: "unitOnly";
+    unit: string;
+    unitExponent?: string;
+}
+/**
+ * @interface baseOperator
+ * @extends {baseExtraction}
+ * @description Represents the structure for mathematical operator extraction results,
+ * extending the baseExtraction with a property for match type (operator).
+ */
+interface baseOperator extends baseExtraction {
+    matchType: "operator";
+}
+/**
+ * @interface baseNumber
+ * @extends {numericBaseExtraction}
+ * @description Represents the structure for number extraction results,
+ * extending the numericBaseExtraction with properties for match type (number) and an optional exponent.
+ */
+interface baseNumber extends numericBaseExtraction {
+    matchType: "number";
+    exponent?: string;
+}
 /**
  * @interface ExtractionResult
  * @description Represents all possible extraction results
@@ -22,7 +104,7 @@ interface ExtractionResult {
  * the type of match and the index of the match in the string.
  *
  * @param {string} input - The string to search for matches
- * @returns {patternExtraction | null} - The extracted groups and additional information, or null if no match is found
+ * @returns {ExtractionResult | null} - The extracted groups and additional information, or null if no match is found
  */
 declare function extractFirstMatch(input: string): ExtractionResult | null;
 /**
@@ -33,7 +115,7 @@ declare function extractFirstMatch(input: string): ExtractionResult | null;
  * If the input string contains no matches, an empty array is returned.
  *
  * @param {string} input - The string to search for matches
- * @returns {patternExtraction[]} - The extracted groups and additional information, or an empty array if no match is found
+ * @returns {ExtractionResult[]} - The extracted groups and additional information, or an empty array if no match is found
  */
 declare function extractAllMatches(input: string): ExtractionResult[];
 
@@ -72,12 +154,6 @@ declare const extractQuantities: {
  * @description Contains functions for converting (number || currency || unit || operator || scientific expression) data from a string or object to spoken word.
  */
 declare const 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.
-     */
     /**
      * Translates an ExtractionResult object (number || currency || unit || operator || scientific expression) into its spoken word equivalent.
      *
@@ -104,4 +180,4 @@ declare const convertQuantities: {
     autoReplaceAllMatches: (input: string) => string;
 };
 
-export { convertQuantities, extractQuantities, validateExtractionResult };
+export { type ExtractionResult, type baseCurrency, type baseNumber, type baseNumberUnit, type baseOperator, type baseScientific, type baseUnitOnly, convertQuantities, extractQuantities, validateExtractionResult };

package/dist/index.js

@@ -297,17 +297,7 @@ 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"],
-  ordinals: {
-    one: "first",
-    two: "second",
-    three: "third",
-    five: "fifth",
-    eight: "eighth",
-    nine: "ninth",
-    twelve: "twelfth"
-  }
-};
+  scales: ["", "thousand", "million", "billion", "trillion", "quadrillion", "quintillion"]};
 var currencySymbols = {
   $: {
     singular: "dollar",
@@ -471,8 +461,6 @@ function extractFirstMatch(input) {
         extractedGroup.exponent = matchedGroup["integerSuperExponent"] || matchedGroup["integerCaretExponent"];
         extractedGroup.negativeInt = matchedGroup["negativeSignInteger"] !== void 0;
         break;
-      default:
-        break;
     }
     extractedGroup.matchType = matchType;
     extractedGroup.input = matchedGroup[matchType];
@@ -655,11 +643,7 @@ function convertNumericUnitToSpokenWord(numericUnit) {
   let sentence = convertNumberToSpokenWord({
     integer,
     decimal,
-    negativeInt,
-    matchType: "number",
-    input: "",
-    index: 0
-  });
+    negativeInt});
   let spokenUnit;
   let directUnitKey = unit + (unitExponent !== void 0 ? unitExponent : "");
   let directUnit = units[directUnitKey];
@@ -702,18 +686,10 @@ function convertScientificExpressionToSpokenWord(expression) {
   let sentence = convertNumberToSpokenWord({
     integer,
     decimal,
-    negativeInt,
-    matchType: "number",
-    input: "",
-    index: 0
-  }) + " " + E + convertNumberToSpokenWord({
+    negativeInt}) + " " + E + convertNumberToSpokenWord({
     decimal: void 0,
     negativeInt: isNegativeExponent,
-    integer: toRegularInteger(isNegativeExponent ? exponent.slice(1) : exponent),
-    matchType: "number",
-    input: "",
-    index: 0
-  });
+    integer: toRegularInteger(isNegativeExponent ? exponent.slice(1) : exponent)});
   return sentence.trim();
 }
 
@@ -776,116 +752,186 @@ function validateExtractionResult(extractionResult) {
   switch (matchType) {
     case "number":
       if (!("integer" in extractionResult)) {
-        throw new Error("validateExtractionResult: For matchType 'number', ExtractionResult is missing the 'integer' property.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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).");
+        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.`);
+        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.`);
+        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.`);
+        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.`);
+        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.`);
+        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.`);
+        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.`);
+        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.`);
+        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.`);
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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).");
+        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.");
+        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).");
+        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.");
+        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.");
+        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.");
+        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).");
+        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":
@@ -893,34 +939,54 @@ function validateExtractionResult(extractionResult) {
     // 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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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.");
+        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).");
+        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:
@@ -944,12 +1010,6 @@ var extractQuantities = {
   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.
-   */
   /**
    * Translates an ExtractionResult object (number || currency || unit || operator || scientific expression) into its spoken word equivalent.
    *
@@ -980,8 +1040,6 @@ var convertQuantities = {
       case "scientific":
         result = convertScientificExpressionToSpokenWord(extractionResult);
         break;
-      default:
-        break;
     }
     return result;
   },
@@ -1021,9 +1079,7 @@ var convertQuantities = {
     return output.replace(/\s+/g, " ").trim();
   }
 };
-export {
-  convertQuantities,
-  extractQuantities,
-  validateExtractionResult
-};
+
+export { convertQuantities, extractQuantities, validateExtractionResult };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map