@lhncbc/ucum-lhc 4.1.8 → 5.0.0

package/source/unit.js

@@ -340,6 +340,7 @@ export class Unit {
     return match ;
   }// end of fullEquals
 
+
   /**
    * This returns the value of the property named by the parameter
    * passed in.
@@ -380,9 +381,9 @@ export class Unit {
     let newNum = 0.0 ;
 
     if (this.isArbitrary_)
-      throw (new Error(`Attempt to convert arbitrary unit ${this.name_}`));
+      throw (new Error(`Attempt to convert to arbitrary unit "${this.csCode_}"`));
     if (fromUnit.isArbitrary_)
-      throw (new Error(`Attempt to convert to arbitrary unit ${fromUnit.name_}`));
+      throw (new Error(`Attempt to convert arbitrary unit "${fromUnit.csCode_}"`));
 
     // reject request if both units have dimensions that are not equal
     if (fromUnit.dim_ && this.dim_ && !(fromUnit.dim_.equals(this.dim_))) {
@@ -410,39 +411,27 @@ export class Unit {
     let fromCnv = fromUnit.cnv_ ;
     let fromMag = fromUnit.magnitude_ ;
 
-    // If the same conversion function is specified for both units, which
-    // includes neither unit having a conversion function, multiply the
-    // "from" unit's magnitude by the number passed in and then divide
-    // that result by this unit's magnitude.  Do this for units with
-    // and without dimension vectors.  PROBLEM with 2 non-commensurable
-    // units with no dimension vector or function, e.g., byte to mol
-    if (fromCnv === this.cnv_) {
-      newNum = (num * fromMag) / this.magnitude_;
+    let x;
+    if (fromCnv != null) {
+      // turn num * fromUnit.magnitude into its ratio scale equivalent,
+      // e.g., convert Celsius to Kelvin
+      let fromFunc = funcs.forName(fromCnv);
+      x = fromFunc.cnvFrom(num * fromUnit.cnvPfx_) * fromMag;
+      //x = fromFunc.cnvFrom(num * fromMag) * fromUnit.cnvPfx_;
     }
-    // else use a function to get the number to be returned
     else {
-      let x = 0.0 ;
-      if (fromCnv != null) {
-        // turn num * fromUnit.magnitude into its ratio scale equivalent,
-        // e.g., convert Celsius to Kelvin
-        let fromFunc = funcs.forName(fromCnv);
-        x = fromFunc.cnvFrom(num * fromUnit.cnvPfx_) * fromMag;
-        //x = fromFunc.cnvFrom(num * fromMag) * fromUnit.cnvPfx_;
-      }
-      else {
-        x = num * fromMag;
-      }
+      x = num * fromMag;
+    }
 
-      if (this.cnv_ != null) {
-        // turn mag * origUnit on ratio scale into a non-ratio unit,
-        // e.g. convert Kelvin to Fahrenheit
-        let toFunc = funcs.forName(this.cnv_);
-        newNum = toFunc.cnvTo(x / this.magnitude_) / this.cnvPfx_;
-      }
-      else {
-        newNum = x / this.magnitude_;
-      }
-    } // end if either unit has a conversion function
+    if (this.cnv_ != null) {
+      // turn mag * origUnit on ratio scale into a non-ratio unit,
+      // e.g. convert Kelvin to Fahrenheit
+      let toFunc = funcs.forName(this.cnv_);
+      newNum = toFunc.cnvTo(x / this.magnitude_) / this.cnvPfx_;
+    }
+    else {
+      newNum = x / this.magnitude_;
+    }
 
     return newNum;
 
@@ -666,6 +655,7 @@ export class Unit {
     else if (unit2.cnv_ != null) {
       if (!retUnit.dim_ || retUnit.dim_.isZero()) {
         retUnit.cnvPfx_ = unit2.cnvPfx_ * retUnit.magnitude_;
+        retUnit.magnitude_ = unit2.magnitude_;
         retUnit.cnv_ = unit2.cnv_ ;
       }
       else
@@ -716,8 +706,12 @@ export class Unit {
     // via an arithmetic operation.  Taint accordingly
     // if (!retUnit.isMole_)
     //   retUnit.isMole_ = unit2.isMole_ ;
-     if (!retUnit.isArbitrary_)
-       retUnit.isArbitrary_ = unit2.isArbitrary_;
+    if (!retUnit.isArbitrary_)
+      retUnit.isArbitrary_ = unit2.isArbitrary_;
+
+    // Likewise for special units
+    if (!retUnit.isSpecial_)
+      retUnit.isSpecial_ = unit2.isSpecial_;
 
     return retUnit ;
 

package/source/unitString.js

@@ -218,6 +218,7 @@ export class UnitString {
       if (intUtils_.isIntegerUnit(finalUnit) || typeof finalUnit === 'number') {
         finalUnit = new Unit({
           'csCode_': origString,
+          'ciCode_': origString,
           'magnitude_': finalUnit,
           'name_': origString
         });
@@ -1329,24 +1330,31 @@ export class UnitString {
       let tryBrackets = '[' + annoText.substring(1, annoText.length - 1) + ']';
       let mkUnitRet = this._makeUnit(tryBrackets, origString);
 
-      // If we got back a unit, assign it to the returned unit, and add
-      // a message to advise the user that brackets should enclose the code
+      // Nearly anything inside braces is valid, so we don't want to change the
+      // unit, but we can put the found unit in the message as a sort of
+      // warning.
       if (mkUnitRet[0]) {
-        retUnit = mkUnitRet[0];
-        origString = origString.replace(annoText, tryBrackets);
-        this.retMsg_.push(`${annoText} is not a valid unit expression, but ` +
-          `${tryBrackets} is.\n` + this.vcMsgStart_ +
-          `${tryBrackets} (${retUnit.name_})${this.vcMsgEnd_}`);
+        retUnit = uCode;
+        this.retMsg_.push(`${annoText} is a valid unit expression, but ` +
+          `did you mean ${tryBrackets} (${mkUnitRet[0].name_})?`);
       }
-      // Otherwise assume that this should be interpreted as a 1
       else {
         // remove error message generated for trybrackets
         if (this.retMsg_.length > msgLen) {
           this.retMsg_.pop();
         }
-        uCode = 1;
-        retUnit = 1;
       }
+
+      // This is the case where the string is only this annotation.
+      // Create and return a unit object, as we do for numeric units in
+      // parseString.
+      retUnit = new Unit({
+        'csCode_': annoText,
+        'ciCode_': annoText,
+        'magnitude_': 1,
+        'name_': annoText
+      });
+
     } // end if it's only an annotation
 
     else {
@@ -1442,7 +1450,7 @@ export class UnitString {
 
     let finalUnit = uArray[0]['un'];
     if (intUtils_.isIntegerUnit(finalUnit)) {
-      finalUnit = new Unit({'csCode_' : finalUnit,
+      finalUnit = new Unit({'csCode_' : finalUnit, 'ciCode_' : finalUnit,
         'magnitude_' : Number(finalUnit),
         'name_' : finalUnit}) ;
     }
@@ -1453,7 +1461,7 @@ export class UnitString {
     for (let u2 = 1; (u2 < uLen) && !endProcessing; u2++) {
       let nextUnit = uArray[u2]['un'];
       if (intUtils_.isIntegerUnit(nextUnit)) {
-        nextUnit = new Unit({'csCode_' : nextUnit ,
+        nextUnit = new Unit({'csCode_' : nextUnit, 'ciCode_' : nextUnit,
           'magnitude_' : Number(nextUnit),
           'name_': nextUnit});
       }

package/source/unitTables.js

@@ -97,6 +97,11 @@ class UnitTablesFactory {
      * @type integer
      */
     this.massDimIndex_ = 0;
+
+    /**
+     *  Map of indices in the dimension vector to base unit symbols.
+     */
+    this.dimVecIndexToBaseUnit_ = {};
   }
 
 
@@ -138,6 +143,15 @@ class UnitTablesFactory {
       // and that's OK here.
     }
 
+    if (theUnit.isBase_) {
+      const dimVec = theUnit.dim_.dimVec_;
+      let nonZeroIndex;
+      for (let i=0, len=dimVec.length; nonZeroIndex==undefined && i<len; ++i) {
+        if (dimVec[i] != 0)
+          nonZeroIndex = i;
+      }
+      this.dimVecIndexToBaseUnit_[nonZeroIndex] = theUnit.csCode_;
+    }
   } // end addUnit
 
 

package/source-cjs/config.js

@@ -65,14 +65,14 @@ var Ucum = {
    * displaying messages on a web site; should be blank when output is
    * to a file.
    */
-  openEmphHTML_: '<span class="emphSpan">',
+  openEmphHTML_: ' <span class="emphSpan">',
 
   /**
    * Closing HTML used to emphasize portions of error messages.  Used when
    * displaying messages on a web site; should be blank when output is
    * to a file.
    */
-  closeEmphHTML_: '</span>',
+  closeEmphHTML_: '</span> ',
 
   /**
    * Message that is displayed when annotations are included in a unit

package/source-cjs/config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../source/config.js"],"names":["Ucum","dimLen_","validOps_","codeSep_","valMsgStart_","valMsgEnd_","cnvMsgStart_","cnvMsgEnd_","openEmph_","closeEmph_","openEmphHTML_","closeEmphHTML_","bracesMsg_","needMoleWeightMsg_","csvCols_","inputKey_","specUnits_"],"mappings":";;;;;;;AAAA;;;;;;;AAQO,IAAIA,IAAI,GAAG;AAEhB;;;;;;AAMA;;AAEA;;;;;;AAMAC,EAAAA,OAAO,EAAE,CAhBO;;AAkBhB;;;;AAIAC,EAAAA,SAAS,EAAE,CAAC,GAAD,EAAM,GAAN,CAtBK;;AAyBhB;;;;AAIAC,EAAAA,QAAQ,EAAG,IA7BK;AA+BhB;AACAC,EAAAA,YAAY,EAAG,eAhCC;AAiChBC,EAAAA,UAAU,EAAG,GAjCG;AAkChBC,EAAAA,YAAY,EAAG,uBAlCC;AAmChBC,EAAAA,UAAU,EAAG,GAnCG;;AAsClB;;;;;AAKEC,EAAAA,SAAS,EAAG,KA3CI;;AA6ChB;;;;;AAKAC,EAAAA,UAAU,EAAG,KAlDG;;AAoDhB;;;;;AAKAC,EAAAA,aAAa,EAAG,yBAzDA;;AA2DhB;;;;;AAKAC,EAAAA,cAAc,EAAG,SAhED;;AAkEhB;;;;AAIAC,EAAAA,UAAU,EAAG,8DACA,6DADA,GAEA,iCAxEG;;AA0EhB;;;;;AAKAC,EAAAA,kBAAkB,EAAG,0DACA,uDADA,GAEA,8CAjFL;;AAmFhB;;;;AAIAC,EAAAA,QAAQ,EAAG;AACT,2BAAwB,SADf;AAET,sBAAmB,gBAFV;AAGT,sBAAmB,OAHV;AAIT,gBAAa,WAJJ;AAKT,cAAW,SALF;AAMT,gBAAa,WANJ;AAOT,gBAAa;AAPJ,GAvFK;;AAiGhB;;;AAGAC,EAAAA,SAAS,EAAG,qBApGI;;AAsGhB;;;;;;;AAOCC,EAAAA,UAAU,EAAG;AAAE,gBAAa,gBAAf;AACE,uBAAoB;AADtB;AA7GE,CAAX","sourcesContent":["/*\n * This defines the namespace for the UCUM classes and provides\n * a place for the definition of global variables and constants.\n *\n * The javascript for this UCUM implementation uses syntax as\n * defined by the ECMAScript 6 standard\n */\n\nexport var Ucum = {\n\n  /**\n   *  Flag indicating whether or not we're using case sensitive labels\n   *  I don't think we need this.  I think we're just going with\n   *  case sensitive, per Clem.   Gunther's code has this flag, but I\n   *  am removing it, at least for now.  lm, 6/2016\n   */\n  //caseSensitive_: true ,\n\n  /**\n   *  The number of elements in a Dimension array.   Currently this\n   *  is set as a configuration variable, but when we get to the point\n   *  of loading the unit definitions from a file, this value will be\n   *  set from that.\n   */\n  dimLen_: 7,\n\n  /**\n   *  The characters used as valid operators in a UCUM unit expression,\n   *  where '.' is for multiplication and '/' is for division.\n   */\n  validOps_: ['.', '/'],\n\n\n  /**\n   * The string used to separate a unit code and unit name when they\n   * are displayed together\n   */\n  codeSep_ : ': ',\n\n  // Message text variations for validation methods and conversion methods\n  valMsgStart_ : 'Did you mean ',\n  valMsgEnd_ : '?' ,\n  cnvMsgStart_ : 'We assumed you meant ',\n  cnvMsgEnd_ : '.',\n\n\n/**\n   * Default opening string used to emphasize portions of error messages.\n   * Used when NOT displaying messages on a web site, i.e., for output\n   * from the library methods or to a file.\n   */\n  openEmph_ : ' ->',\n\n  /**\n   * Default closing string used to emphasize portions of error messages.\n   * Used when NOT displaying messages on a web site, i.e., for output\n   * from the library methods or to a file.\n   */\n  closeEmph_ : '<- ' ,\n\n  /**\n   * Opening HTML used to emphasize portions of error messages.  Used when\n   * displaying messages on a web site; should be blank when output is\n   * to a file.\n   */\n  openEmphHTML_ : '<span class=\"emphSpan\">',\n\n  /**\n   * Closing HTML used to emphasize portions of error messages.  Used when\n   * displaying messages on a web site; should be blank when output is\n   * to a file.\n   */\n  closeEmphHTML_ : '</span>' ,\n\n  /**\n   * Message that is displayed when annotations are included in a unit\n   * string, to let the user know how they are interpreted.\n   */\n  bracesMsg_ : 'FYI - annotations (text in curly braces {}) are ignored, ' +\n               'except that an annotation without a leading symbol implies ' +\n               'the default unit 1 (the unity).',\n\n  /**\n   * Message that is displayed or returned when a conversion is requested\n   * for two units where (only) a mass<->moles conversion is appropriate\n   * but no molecular weight was specified.\n   */\n  needMoleWeightMsg_ : 'Did you wish to convert between mass and moles?  The ' +\n                       'molecular weight of the substance represented by the ' +\n                       'units is required to perform the conversion.',\n\n  /**\n   * Hash that matches unit column names to names used in the csv file\n   * that is submitted to the data updater.\n   */\n  csvCols_ : {\n    'case-sensitive code' : 'csCode_',\n    'LOINC property' : 'loincProperty_',\n    'name (display)' : 'name_',\n    'synonyms' : 'synonyms_',\n    'source' : 'source_',\n    'category' : 'category_',\n    'Guidance' : 'guidance_'\n  } ,\n\n  /**\n   * Name of the column in the csv file that serves as the key\n   */\n  inputKey_ : 'case-sensitive code' ,\n\n  /**\n   * Special codes that contain operators within brackets.  The operator\n   * within these codes causes them to parse incorrectly if they are preceded\n   * by a prefix, because the parsing algorithm splits them up on the operator.\n   * So we use this object to identify them and substitute placeholders to\n   * avoid that.\n   */\n   specUnits_ : { 'B[10.nV]' : 'specialUnitOne',\n                  '[m/s2/Hz^(1/2)]' : 'specialUnitTwo'}\n} ;\n\n\n"],"file":"config.js"}
+{"version":3,"sources":["../source/config.js"],"names":["Ucum","dimLen_","validOps_","codeSep_","valMsgStart_","valMsgEnd_","cnvMsgStart_","cnvMsgEnd_","openEmph_","closeEmph_","openEmphHTML_","closeEmphHTML_","bracesMsg_","needMoleWeightMsg_","csvCols_","inputKey_","specUnits_"],"mappings":";;;;;;;AAAA;;;;;;;AAQO,IAAIA,IAAI,GAAG;AAEhB;;;;;;AAMA;;AAEA;;;;;;AAMAC,EAAAA,OAAO,EAAE,CAhBO;;AAmBhB;;;;AAIAC,EAAAA,SAAS,EAAE,CAAC,GAAD,EAAM,GAAN,CAvBK;;AA0BhB;;;;AAIAC,EAAAA,QAAQ,EAAG,IA9BK;AAgChB;AACAC,EAAAA,YAAY,EAAG,eAjCC;AAkChBC,EAAAA,UAAU,EAAG,GAlCG;AAmChBC,EAAAA,YAAY,EAAG,uBAnCC;AAoChBC,EAAAA,UAAU,EAAG,GApCG;;AAuClB;;;;;AAKEC,EAAAA,SAAS,EAAG,KA5CI;;AA8ChB;;;;;AAKAC,EAAAA,UAAU,EAAG,KAnDG;;AAqDhB;;;;;AAKAC,EAAAA,aAAa,EAAG,0BA1DA;;AA4DhB;;;;;AAKAC,EAAAA,cAAc,EAAG,UAjED;;AAmEhB;;;;AAIAC,EAAAA,UAAU,EAAG,8DACA,6DADA,GAEA,iCAzEG;;AA2EhB;;;;;AAKAC,EAAAA,kBAAkB,EAAG,0DACA,uDADA,GAEA,8CAlFL;;AAoFhB;;;;AAIAC,EAAAA,QAAQ,EAAG;AACT,2BAAwB,SADf;AAET,sBAAmB,gBAFV;AAGT,sBAAmB,OAHV;AAIT,gBAAa,WAJJ;AAKT,cAAW,SALF;AAMT,gBAAa,WANJ;AAOT,gBAAa;AAPJ,GAxFK;;AAkGhB;;;AAGAC,EAAAA,SAAS,EAAG,qBArGI;;AAuGhB;;;;;;;AAOCC,EAAAA,UAAU,EAAG;AAAE,gBAAa,gBAAf;AACE,uBAAoB;AADtB;AA9GE,CAAX","sourcesContent":["/*\n * This defines the namespace for the UCUM classes and provides\n * a place for the definition of global variables and constants.\n *\n * The javascript for this UCUM implementation uses syntax as\n * defined by the ECMAScript 6 standard\n */\n\nexport var Ucum = {\n\n  /**\n   *  Flag indicating whether or not we're using case sensitive labels\n   *  I don't think we need this.  I think we're just going with\n   *  case sensitive, per Clem.   Gunther's code has this flag, but I\n   *  am removing it, at least for now.  lm, 6/2016\n   */\n  //caseSensitive_: true ,\n\n  /**\n   *  The number of elements in a Dimension array.   Currently this\n   *  is set as a configuration variable, but when we get to the point\n   *  of loading the unit definitions from a file, this value will be\n   *  set from that.\n   */\n  dimLen_: 7,\n\n\n  /**\n   *  The characters used as valid operators in a UCUM unit expression,\n   *  where '.' is for multiplication and '/' is for division.\n   */\n  validOps_: ['.', '/'],\n\n\n  /**\n   * The string used to separate a unit code and unit name when they\n   * are displayed together\n   */\n  codeSep_ : ': ',\n\n  // Message text variations for validation methods and conversion methods\n  valMsgStart_ : 'Did you mean ',\n  valMsgEnd_ : '?' ,\n  cnvMsgStart_ : 'We assumed you meant ',\n  cnvMsgEnd_ : '.',\n\n\n/**\n   * Default opening string used to emphasize portions of error messages.\n   * Used when NOT displaying messages on a web site, i.e., for output\n   * from the library methods or to a file.\n   */\n  openEmph_ : ' ->',\n\n  /**\n   * Default closing string used to emphasize portions of error messages.\n   * Used when NOT displaying messages on a web site, i.e., for output\n   * from the library methods or to a file.\n   */\n  closeEmph_ : '<- ' ,\n\n  /**\n   * Opening HTML used to emphasize portions of error messages.  Used when\n   * displaying messages on a web site; should be blank when output is\n   * to a file.\n   */\n  openEmphHTML_ : ' <span class=\"emphSpan\">',\n\n  /**\n   * Closing HTML used to emphasize portions of error messages.  Used when\n   * displaying messages on a web site; should be blank when output is\n   * to a file.\n   */\n  closeEmphHTML_ : '</span> ' ,\n\n  /**\n   * Message that is displayed when annotations are included in a unit\n   * string, to let the user know how they are interpreted.\n   */\n  bracesMsg_ : 'FYI - annotations (text in curly braces {}) are ignored, ' +\n               'except that an annotation without a leading symbol implies ' +\n               'the default unit 1 (the unity).',\n\n  /**\n   * Message that is displayed or returned when a conversion is requested\n   * for two units where (only) a mass<->moles conversion is appropriate\n   * but no molecular weight was specified.\n   */\n  needMoleWeightMsg_ : 'Did you wish to convert between mass and moles?  The ' +\n                       'molecular weight of the substance represented by the ' +\n                       'units is required to perform the conversion.',\n\n  /**\n   * Hash that matches unit column names to names used in the csv file\n   * that is submitted to the data updater.\n   */\n  csvCols_ : {\n    'case-sensitive code' : 'csCode_',\n    'LOINC property' : 'loincProperty_',\n    'name (display)' : 'name_',\n    'synonyms' : 'synonyms_',\n    'source' : 'source_',\n    'category' : 'category_',\n    'Guidance' : 'guidance_'\n  } ,\n\n  /**\n   * Name of the column in the csv file that serves as the key\n   */\n  inputKey_ : 'case-sensitive code' ,\n\n  /**\n   * Special codes that contain operators within brackets.  The operator\n   * within these codes causes them to parse incorrectly if they are preceded\n   * by a prefix, because the parsing algorithm splits them up on the operator.\n   * So we use this object to identify them and substitute placeholders to\n   * avoid that.\n   */\n   specUnits_ : { 'B[10.nV]' : 'specialUnitOne',\n                  '[m/s2/Hz^(1/2)]' : 'specialUnitTwo'}\n} ;\n\n\n"],"file":"config.js"}

package/source-cjs/ucumLhcUtils.js

@@ -134,24 +134,17 @@ class UcumLhcUtils {
     if (valConv === undefined) valConv = 'validate';
     let resp = this.getSpecifiedUnit(uStr, valConv, suggest);
     let theUnit = resp['unit'];
-    let retObj = {};
-
-    if (!theUnit) {
-      retObj = {
-        'status': !resp['origString'] || resp['origString'] === null ? 'error' : 'invalid',
-        'ucumCode': null
-      };
-    } else {
-      retObj = {
-        'status': resp['origString'] === uStr ? 'valid' : 'invalid',
-        'ucumCode': resp['origString'],
-        'unit': {
-          'code': theUnit.csCode_,
-          'name': theUnit.name_,
-          'guidance': theUnit.guidance_
-        }
-      };
-    }
+    let retObj = !theUnit ? {
+      'ucumCode': null
+    } : {
+      'ucumCode': resp['origString'],
+      'unit': {
+        'code': theUnit.csCode_,
+        'name': theUnit.name_,
+        'guidance': theUnit.guidance_
+      }
+    };
+    retObj.status = resp.status;
 
     if (resp['suggestions']) {
       retObj['suggestions'] = resp['suggestions'];
@@ -239,10 +232,7 @@ class UcumLhcUtils {
       returnObj['msg'].push('No "from" unit expression specified.');
     }
 
-    if (fromVal === null || isNaN(fromVal) || typeof fromVal !== 'number' && !intUtils_.isNumericString(fromVal)) {
-      returnObj['status'] = 'error';
-      returnObj['msg'].push('No "from" value, or an invalid "from" value, ' + 'was specified.');
-    }
+    this._checkFromVal(fromVal, returnObj);
 
     if (toUnitCode) {
       toUnitCode = toUnitCode.trim();
@@ -333,6 +323,114 @@ class UcumLhcUtils {
     return returnObj;
   } // end convertUnitTo
 
+  /**
+   *  Converts the given unit string into its base units, their exponents, and
+   *  a magnitude, and returns that data.
+   * @param fromUnit the unit string to be converted to base units information
+   * @param fromVal the number of "from" units to be converted
+   * @returns an object with the properties:
+   *  'status' indicates whether the result succeeded.  The value will be one of:
+   *    'succeeded':  the conversion was successfully calculated (which can be
+   *      true even if it was already in base units);
+   *    'invalid':  fromUnit is not a valid UCUM code;
+   *    'failed':  the conversion could not be made (e.g., if it is an "arbitrary" unit);
+   *    'error':  if an error occurred (an input or programming error)
+   *  'msg': an array of one or more messages, if the string is invalid or
+   *        an error occurred, indicating the problem, or a suggestion of a
+   *        substitution such as the substitution of 'G' for 'Gauss', or
+   *        an empty array if no messages were generated.  There can also be a
+   *        message that is just informational or warning.
+   *  'magnitude': the new value when fromVal units of fromUnits is expressed in the base units.
+   *  'fromUnitIsSpecial': whether the input unit fromUnit is a "special unit"
+   *         as defined in UCUM.  This means there is some function applied to convert
+   *         between fromUnit and the base units, so the returned magnitude is likely not
+   *         useful as a scale factor for other conversions (i.e., it only has validity
+   *         and usefulness for the input values that produced it).
+   *  'unitToExp': a map of base units in uStr to their exponent
+   */
+
+
+  convertToBaseUnits(fromUnit, fromVal) {
+    let retObj = {};
+
+    this._checkFromVal(fromVal, retObj);
+
+    if (!retObj.status) {
+      // could be set to 'error' by _checkFromVal
+      let inputUnitLookup = this.getSpecifiedUnit(fromUnit, 'validate');
+      retObj = {
+        status: inputUnitLookup.status == 'valid' ? 'succeeded' : inputUnitLookup.status
+      };
+      let unit = inputUnitLookup.unit;
+      retObj.msg = inputUnitLookup.retMsg || [];
+
+      if (!unit) {
+        if (inputUnitLookup.retMsg?.length == 0) retObj.msg.push('Could not find unit information for ' + fromUnit);
+      } else if (unit.isArbitrary_) {
+        retObj.msg.push('Arbitrary units cannot be converted to base units or other units.');
+        retObj.status = 'failed';
+      } else if (retObj.status == 'succeeded') {
+        let unitToExp = {};
+        let dimVec = unit.dim_?.dimVec_;
+        let baseUnitString = '1';
+
+        if (dimVec) {
+          let dimVecIndexToBaseUnit = UnitTables.getInstance().dimVecIndexToBaseUnit_;
+
+          for (let i = 0, len = dimVec.length; i < len; ++i) {
+            let exp = dimVec[i];
+
+            if (exp) {
+              unitToExp[dimVecIndexToBaseUnit[i]] = exp;
+              baseUnitString += '.' + dimVecIndexToBaseUnit[i] + exp;
+            }
+          }
+        } // The unit might have a conversion function, which has to be applied; we
+        // cannot just assume unit_.magnitude_ is the magnitude in base units.
+
+
+        let retUnitLookup = this.getSpecifiedUnit(baseUnitString, 'validate'); // There should not be any error in retUnitLookup, unless there is a bug.
+
+        let retUnit = retUnitLookup.unit;
+
+        if (retUnitLookup.status !== 'valid') {
+          retObj.msg.push('Unable construct base unit string; tried ' + baseUnitString);
+          retObj.status = 'error';
+        } else {
+          try {
+            retObj.magnitude = retUnit.convertFrom(fromVal, unit);
+          } catch (e) {
+            retObj.msg.push(e.toString());
+            retObj.status = 'error';
+          }
+
+          if (retObj.status == 'succeeded') {
+            retObj.unitToExp = unitToExp;
+            retObj.fromUnitIsSpecial = unit.isSpecial_;
+          }
+        }
+      }
+    }
+
+    return retObj;
+  }
+  /**
+   *  Checks the given value as to whether it is suitable as a "from" value in a
+   *  unit conversion.  If it is not, the responseObj will have its status set
+   *  to 'error' and a message added.
+   * @param fromVal The value to check
+   * @param responseObj the object that will be updated if the value is not
+   *  usable.
+   */
+
+
+  _checkFromVal(fromVal, responseObj) {
+    if (fromVal === null || isNaN(fromVal) || typeof fromVal !== 'number' && !intUtils_.isNumericString(fromVal)) {
+      responseObj.status = 'error';
+      if (!responseObj.msg) responseObj.msg = [];
+      responseObj.msg.push('No "from" value, or an invalid "from" value, ' + 'was specified.');
+    }
+  }
   /**
    * This method accepts a term and looks for units that include it as
    * a synonym - or that include the term in its name.
@@ -377,13 +475,18 @@ class UcumLhcUtils {
    *  true indicates suggestions are wanted; false indicates they are not,
    *  and is the default if the parameter is not specified;
    * @returns a hash containing:
+   *   'status' will be 'valid' (uName is a valid UCUM code), 'invalid'
+   *     (the uStr is not a valid UCUM code, and substitutions or
+   *     suggestions may or may not be returned, depending on what was
+   *     requested and found); or 'error' (an input or programming error
+   *     occurred);
    *   'unit' the unit object (or null if there were problems creating the
    *     unit);
    *   'origString' the possibly updated unit string passed in;
    *   'retMsg' an array of user messages (informational, error or warning) if
    *     any were generated (IF any were generated, otherwise will be an
    *     empty array); and
-   *  'suggestions' is an array of 1 or more hash objects.  Each hash
+   *   'suggestions' is an array of 1 or more hash objects.  Each hash
    *     contains three elements:
    *       'msg' which is a message indicating what unit expression the
    *          suggestions are for;
@@ -429,8 +532,18 @@ class UcumLhcUtils {
       } // end if the unit was not found as a unit name
 
     } // end if a unit expression was specified
+    // Set the status field
 
 
+    if (!retObj.unit) {
+      // No unit was found; check whether origString has a value
+      retObj.status = !retObj.origString ? 'error' : 'invalid';
+    } else {
+      // Check whether substitutions were made to the unit string in order to
+      // find the unit
+      retObj.status = retObj.origString === uName ? 'valid' : 'invalid';
+    }
+
     return retObj;
   } // end getSpecifiedUnit
 

package/source-cjs/ucumLhcUtils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../source/ucumLhcUtils.js"],"names":["Ucum","require","UnitTables","UnitString","UcumLhcUtils","constructor","getInstance","unitsCount","ucumJsonDefs","loadJsonDefs","uStrParser_","useHTMLInMessages","use","undefined","useBraceMsgForEachString","validateUnitString","uStr","suggest","valConv","resp","getSpecifiedUnit","theUnit","retObj","csCode_","name_","guidance_","convertUnitTo","fromUnitCode","fromVal","toUnitCode","molecularWeight","returnObj","trim","push","isNaN","intUtils_","isNumericString","fromUnit","parseResp","concat","toUnit","convertFrom","moleExp_","Error","isMoleMassCommensurable","convertMolToMass","convertMassToMol","err","message","needMoleWeightMsg_","checkSynonyms","theSyn","getSynonyms","uName","utab","getUnitByCode","parseString","console","log","unshift","commensurablesList","fromName","retMsg","commUnits","length","dimVec","fromDim","getProperty","getUnitsByDimension"],"mappings":";;;;;;;AAOA;;AAIA;;;;;;AAXA;;;;;;AAMA,IAAIA,IAAI,GAAGC,OAAO,CAAC,aAAD,CAAP,CAAuBD,IAAlC;;AAEA,IAAIE,UAAU,GAAGD,OAAO,CAAC,iBAAD,CAAP,CAA2BC,UAA5C;;AACA,IAAIC,UAAU,GAAGF,OAAO,CAAC,iBAAD,CAAP,CAA2BE,UAA5C;;AAIA;;;AAGO,MAAMC,YAAN,CAAmB;AAExB;;;;;AAKAC,EAAAA,WAAW,GAAG;AAEV,QAAIH,UAAU,CAACI,WAAX,GAAyBC,UAAzB,OAA0C,CAA9C,EAAiD;AAE/C;AACAC,iCAAaC,YAAb;AACD,KANS,CAQV;AACA;;;AACA,SAAKC,WAAL,GAAmBP,UAAU,CAACG,WAAX,EAAnB;AAEH,GAnBuB,CAmBtB;;AAGF;;;;;;;;;;AAQAK,EAAAA,iBAAiB,CAACC,GAAD,EAAM;AACrB,QAAIA,GAAG,KAAKC,SAAZ,EACED,GAAG,GAAG,IAAN;AACF,SAAKF,WAAL,CAAiBC,iBAAjB,CAAmCC,GAAnC;AACD;AAGD;;;;;;;;;;;AASAE,EAAAA,wBAAwB,CAACF,GAAD,EAAM;AAC5B,QAAIA,GAAG,KAAKC,SAAZ,EACED,GAAG,GAAG,IAAN;AACF,SAAKF,WAAL,CAAiBI,wBAAjB,CAA0CF,GAA1C;AACD;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDAG,EAAAA,kBAAkB,CAACC,IAAD,EAAOC,OAAP,EAAgBC,OAAhB,EAAyB;AAEzC,QAAID,OAAO,KAAKJ,SAAhB,EACEI,OAAO,GAAG,KAAV;AAEF,QAAIC,OAAO,KAAKL,SAAhB,EACEK,OAAO,GAAG,UAAV;AAEF,QAAIC,IAAI,GAAG,KAAKC,gBAAL,CAAsBJ,IAAtB,EAA4BE,OAA5B,EAAqCD,OAArC,CAAX;AACA,QAAII,OAAO,GAAGF,IAAI,CAAC,MAAD,CAAlB;AACA,QAAIG,MAAM,GAAG,EAAb;;AACA,QAAI,CAACD,OAAL,EAAc;AACZC,MAAAA,MAAM,GAAG;AAAC,kBAAW,CAACH,IAAI,CAAC,YAAD,CAAL,IAAuBA,IAAI,CAAC,YAAD,CAAJ,KAAuB,IAA/C,GACC,OADD,GACW,SADtB;AAEC,oBAAY;AAFb,OAAT;AAGD,KAJD,MAKK;AACHG,MAAAA,MAAM,GAAG;AAAC,kBAAUH,IAAI,CAAC,YAAD,CAAJ,KAAuBH,IAAvB,GAA8B,OAA9B,GAAuC,SAAlD;AACC,oBAAYG,IAAI,CAAC,YAAD,CADjB;AAEC,gBAAQ;AAAC,kBAAQE,OAAO,CAACE,OAAjB;AACC,kBAAQF,OAAO,CAACG,KADjB;AAEC,sBAAYH,OAAO,CAACI;AAFrB;AAFT,OAAT;AAKD;;AACD,QAAIN,IAAI,CAAC,aAAD,CAAR,EAAyB;AACvBG,MAAAA,MAAM,CAAC,aAAD,CAAN,GAAwBH,IAAI,CAAC,aAAD,CAA5B;AACD;;AACDG,IAAAA,MAAM,CAAC,KAAD,CAAN,GAAgBH,IAAI,CAAC,QAAD,CAApB;AACA,WAAOG,MAAP;AAED,GAvIuB,CAuItB;;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DAI,EAAAA,aAAa,CAACC,YAAD,EAAeC,OAAf,EAAwBC,UAAxB,EAAoCZ,OAApC,EAA6Ca,eAA7C,EAA8D;AACzE,QAAIb,OAAO,KAAKJ,SAAhB,EACEI,OAAO,GAAG,KAAV;AAEF,QAAIa,eAAe,KAAKjB,SAAxB,EACEiB,eAAe,GAAG,IAAlB;AAEF,QAAIC,SAAS,GAAG;AAAC,gBAAW,QAAZ;AACC,eAAU,IADX;AAEC,aAAQ;AAFT,KAAhB;;AAIA,QAAIJ,YAAJ,EAAkB;AAChBA,MAAAA,YAAY,GAAGA,YAAY,CAACK,IAAb,EAAf;AACD;;AACD,QAAI,CAACL,YAAD,IAAiBA,YAAY,IAAI,EAArC,EAAyC;AACvCI,MAAAA,SAAS,CAAC,QAAD,CAAT,GAAsB,OAAtB;AACAA,MAAAA,SAAS,CAAC,KAAD,CAAT,CAAiBE,IAAjB,CAAsB,sCAAtB;AACD;;AACD,QAAIL,OAAO,KAAK,IAAZ,IAAoBM,KAAK,CAACN,OAAD,CAAzB,IAAuC,OAAOA,OAAP,KAAmB,QAAnB,IACvC,CAACO,SAAS,CAACC,eAAV,CAA0BR,OAA1B,CADL,EAC0C;AACxCG,MAAAA,SAAS,CAAC,QAAD,CAAT,GAAsB,OAAtB;AACAA,MAAAA,SAAS,CAAC,KAAD,CAAT,CAAiBE,IAAjB,CAAsB,kDACH,gBADnB;AAED;;AACD,QAAIJ,UAAJ,EAAgB;AACdA,MAAAA,UAAU,GAAGA,UAAU,CAACG,IAAX,EAAb;AACD;;AACD,QAAI,CAACH,UAAD,IAAeA,UAAU,IAAI,EAAjC,EAAqC;AACnCE,MAAAA,SAAS,CAAC,QAAD,CAAT,GAAsB,OAAtB;AACAA,MAAAA,SAAS,CAAC,KAAD,CAAT,CAAiBE,IAAjB,CAAsB,oCAAtB;AACD;;AACD,QAAIF,SAAS,CAAC,QAAD,CAAT,KAAwB,OAA5B,EAAqC;AACnC,UAAI;AACF,YAAIM,QAAQ,GAAG,IAAf;AAEA,YAAIC,SAAS,GAAG,KAAKlB,gBAAL,CAAsBO,YAAtB,EAAoC,SAApC,EAA+CV,OAA/C,CAAhB;AACAoB,QAAAA,QAAQ,GAAGC,SAAS,CAAC,MAAD,CAApB;AACA,YAAIA,SAAS,CAAC,QAAD,CAAb,EACEP,SAAS,CAAC,KAAD,CAAT,GAAmBA,SAAS,CAAC,KAAD,CAAT,CAAiBQ,MAAjB,CAAwBD,SAAS,CAAC,QAAD,CAAjC,CAAnB;;AACF,YAAIA,SAAS,CAAC,aAAD,CAAb,EAA8B;AAC5BP,UAAAA,SAAS,CAAC,aAAD,CAAT,GAA2B,EAA3B;AACAA,UAAAA,SAAS,CAAC,aAAD,CAAT,CAAyB,MAAzB,IAAmCO,SAAS,CAAC,aAAD,CAA5C;AACD;;AACD,YAAI,CAACD,QAAL,EAAe;AACbN,UAAAA,SAAS,CAAC,KAAD,CAAT,CAAiBE,IAAjB,CAAuB,6BAA4BN,YAAa,IAA1C,GACnB,sCADH;AAED;;AAED,YAAIa,MAAM,GAAG,IAAb;AACAF,QAAAA,SAAS,GAAG,KAAKlB,gBAAL,CAAsBS,UAAtB,EAAkC,SAAlC,EAA6CZ,OAA7C,CAAZ;AACAuB,QAAAA,MAAM,GAAGF,SAAS,CAAC,MAAD,CAAlB;AACA,YAAIA,SAAS,CAAC,QAAD,CAAb,EACEP,SAAS,CAAC,KAAD,CAAT,GAAmBA,SAAS,CAAC,KAAD,CAAT,CAAiBQ,MAAjB,CAAwBD,SAAS,CAAC,QAAD,CAAjC,CAAnB;;AACF,YAAIA,SAAS,CAAC,aAAD,CAAb,EAA8B;AAC5B,cAAI,CAACP,SAAS,CAAC,aAAD,CAAd,EACEA,SAAS,CAAC,aAAD,CAAT,GAA2B,EAA3B;AACFA,UAAAA,SAAS,CAAC,aAAD,CAAT,CAAyB,IAAzB,IAAiCO,SAAS,CAAC,aAAD,CAA1C;AACD;;AACD,YAAI,CAACE,MAAL,EAAa;AACXT,UAAAA,SAAS,CAAC,KAAD,CAAT,CAAiBE,IAAjB,CAAuB,6BAA4BJ,UAAW,IAAxC,GACC,sCADvB;AAED;;AAED,YAAIQ,QAAQ,IAAIG,MAAhB,EAAwB;AACtB,cAAI;AACF;AACA,gBAAI,CAACV,eAAL,EAAsB;AACpBC,cAAAA,SAAS,CAAC,OAAD,CAAT,GAAqBS,MAAM,CAACC,WAAP,CAAmBb,OAAnB,EAA4BS,QAA5B,CAArB;AACD,aAFD,MAGK;AACH,kBAAIA,QAAQ,CAACK,QAAT,KAAsB,CAAtB,IAA2BF,MAAM,CAACE,QAAP,KAAoB,CAAnD,EAAsD;AACpD,sBAAM,IAAIC,KAAJ,CAAU,sCACd,4DADc,GAEd,iDAFI,CAAN;AAGD;;AACD,kBAAIN,QAAQ,CAACK,QAAT,KAAsB,CAAtB,IAA2BF,MAAM,CAACE,QAAP,KAAoB,CAAnD,EAAsD;AACpD,sBAAM,IAAIC,KAAJ,CAAU,sCACd,yDADc,GAEd,2DAFI,CAAN;AAGD;;AACD,kBAAI,CAACN,QAAQ,CAACO,uBAAT,CAAiCJ,MAAjC,CAAL,EAA+C;AAC7C,sBAAM,IAAIG,KAAJ,CAAW,WAAUhB,YAAa,aAAxB,GACb,gBAAeE,UAAW,GADvB,CAAN;AAED,eAdE,CAgBH;AACA;;;AACA,kBAAIQ,QAAQ,CAACK,QAAT,KAAsB,CAA1B,EAA6B;AAC3BX,gBAAAA,SAAS,CAAC,OAAD,CAAT,GACEM,QAAQ,CAACQ,gBAAT,CAA0BjB,OAA1B,EAAmCY,MAAnC,EAA2CV,eAA3C,CADF;AAED,eAHD,CAIA;AACA;AALA,mBAMK;AACHC,kBAAAA,SAAS,CAAC,OAAD,CAAT,GACEM,QAAQ,CAACS,gBAAT,CAA0BlB,OAA1B,EAAmCY,MAAnC,EAA2CV,eAA3C,CADF;AAED;AACF,aAjCC,CAiCA;AAEF;AACA;;;AACAC,YAAAA,SAAS,CAAC,QAAD,CAAT,GAAsB,WAAtB;AACAA,YAAAA,SAAS,CAAC,UAAD,CAAT,GAAwBM,QAAxB;AACAN,YAAAA,SAAS,CAAC,QAAD,CAAT,GAAsBS,MAAtB;AACD,WAxCD,CAyCA,OAAOO,GAAP,EAAY;AACVhB,YAAAA,SAAS,CAAC,QAAD,CAAT,GAAsB,QAAtB;AACAA,YAAAA,SAAS,CAAC,KAAD,CAAT,CAAiBE,IAAjB,CAAsBc,GAAG,CAACC,OAA1B;AACD;AAGF,SA/EC,CA+EC;;AACJ,OAhFD,CAiFA,OAAOD,GAAP,EAAY;AACV,YAAIA,GAAG,CAACC,OAAJ,IAAehD,IAAI,CAACiD,kBAAxB,EACElB,SAAS,CAAC,QAAD,CAAT,GAAsB,QAAtB,CADF,KAGEA,SAAS,CAAC,QAAD,CAAT,GAAsB,OAAtB;AACFA,QAAAA,SAAS,CAAC,KAAD,CAAT,CAAiBE,IAAjB,CAAsBc,GAAG,CAACC,OAA1B;AACD;AACF;;AAED,WAAOjB,SAAP;AAED,GAhUuB,CAgUtB;;AAGF;;;;;;;;;;;;;;;;;AAeAmB,EAAAA,aAAa,CAACC,MAAD,EAAS;AACpB,QAAI7B,MAAM,GAAG,EAAb;;AACA,QAAI6B,MAAM,KAAKtC,SAAX,IAAwBsC,MAAM,KAAK,IAAvC,EAA6C;AAC3C7B,MAAAA,MAAM,CAAC,QAAD,CAAN,GAAmB,OAAnB;AACAA,MAAAA,MAAM,CAAC,KAAD,CAAN,GAAgB,uCAAhB;AACD,KAHD,MAIK;AACHA,MAAAA,MAAM,GAAGa,SAAS,CAACiB,WAAV,CAAsBD,MAAtB,CAAT;AACD,KARmB,CAQlB;;;AAEF,WAAO7B,MAAP;AAED,GA9VuB,CA8VtB;;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BAF,EAAAA,gBAAgB,CAACiC,KAAD,EAAQnC,OAAR,EAAiBD,OAAjB,EAA0B;AAExC,QAAIA,OAAO,KAAKJ,SAAhB,EACEI,OAAO,GAAG,KAAV;AAEF,QAAIK,MAAM,GAAG,EAAb;AACAA,IAAAA,MAAM,CAAC,QAAD,CAAN,GAAmB,EAAnB;;AAEA,QAAI,CAAC+B,KAAL,EAAY;AACV/B,MAAAA,MAAM,CAAC,QAAD,CAAN,CAAiBW,IAAjB,CAAsB,2BAAtB;AACD,KAFD,MAGK;AACH,UAAIqB,IAAI,GAAGpD,UAAU,CAACI,WAAX,EAAX;AACA+C,MAAAA,KAAK,GAAGA,KAAK,CAACrB,IAAN,EAAR,CAFG,CAIH;AACA;;AACA,UAAIX,OAAO,GAAGiC,IAAI,CAACC,aAAL,CAAmBF,KAAnB,CAAd,CANG,CAQH;AACA;;AACA,UAAIhC,OAAJ,EAAa;AACXC,QAAAA,MAAM,CAAC,MAAD,CAAN,GAAiBD,OAAjB;AACAC,QAAAA,MAAM,CAAC,YAAD,CAAN,GAAuB+B,KAAvB;AACD,OAHD,MAIK;AACH,YAAI;AACF,cAAIlC,IAAI,GAAG,KAAKT,WAAL,CAAiB8C,WAAjB,CAA6BH,KAA7B,EAAoCnC,OAApC,EAA6CD,OAA7C,CAAX;AACAK,UAAAA,MAAM,CAAC,MAAD,CAAN,GAAiBH,IAAI,CAAC,CAAD,CAArB;AACAG,UAAAA,MAAM,CAAC,YAAD,CAAN,GAAuBH,IAAI,CAAC,CAAD,CAA3B;AACA,cAAIA,IAAI,CAAC,CAAD,CAAR,EACEG,MAAM,CAAC,QAAD,CAAN,GAAmBH,IAAI,CAAC,CAAD,CAAvB;AACFG,UAAAA,MAAM,CAAC,aAAD,CAAN,GAAwBH,IAAI,CAAC,CAAD,CAA5B;AACD,SAPD,CAQA,OAAO4B,GAAP,EAAY;AACVU,UAAAA,OAAO,CAACC,GAAR,CAAa,kCAAiCL,KAAM,GAAxC,GACV,uCADU,GACgCN,GAAG,CAACC,OADhD;AAEE1B,UAAAA,MAAM,CAAC,QAAD,CAAN,CAAiBqC,OAAjB,CAA0B,GAAEN,KAAM,yBAAT,GACC,GAAEN,GAAG,CAACC,OAAQ,EADxC;AAEH;AACF,OA7BE,CA6BD;;AACH,KAzCuC,CAyCtC;;;AAEF,WAAO1B,MAAP;AAED,GA7auB,CA6atB;;AAGF;;;;;;;;;;;;AAUAsC,EAAAA,kBAAkB,CAACC,QAAD,EAAW;AAE3B,QAAIC,MAAM,GAAG,EAAb;AACA,QAAIC,SAAS,GAAG,IAAhB;AACA,QAAIzB,SAAS,GAAG,KAAKlB,gBAAL,CAAsByC,QAAtB,EAAgC,UAAhC,EAA4C,KAA5C,CAAhB;AACA,QAAIxB,QAAQ,GAAGC,SAAS,CAAC,MAAD,CAAxB;AACA,QAAIA,SAAS,CAAC,QAAD,CAAT,CAAoB0B,MAApB,GAA6B,CAAjC,EACEF,MAAM,GAAGxB,SAAS,CAAC,QAAD,CAAlB;;AACF,QAAI,CAACD,QAAL,EAAe;AACbyB,MAAAA,MAAM,CAAC7B,IAAP,CAAa,uBAAsB4B,QAAS,GAA5C;AACD,KAFD,MAGK;AACH,UAAII,MAAM,GAAG,IAAb;AACA,UAAIC,OAAO,GAAG7B,QAAQ,CAAC8B,WAAT,CAAqB,MAArB,CAAd;;AACA,UAAI,CAACD,OAAL,EAAc;AACZJ,QAAAA,MAAM,CAAC7B,IAAP,CAAY,2CAA2C4B,QAAvD;AACD,OAFD,MAGK;AACH,YAAI;AACFI,UAAAA,MAAM,GAAGC,OAAO,CAACC,WAAR,CAAoB,SAApB,CAAT;AACD,SAFD,CAGA,OAAOpB,GAAP,EAAY;AACVe,UAAAA,MAAM,CAAC7B,IAAP,CAAYc,GAAG,CAACC,OAAhB;AACA,cAAID,GAAG,CAACC,OAAJ,KACF,qDADF,EAEEiB,MAAM,GAAG,IAAT;AACH;;AACD,YAAIA,MAAJ,EAAY;AACV,cAAIX,IAAI,GAAGpD,UAAU,CAACI,WAAX,EAAX;AACAyD,UAAAA,SAAS,GAAGT,IAAI,CAACc,mBAAL,CAAyBH,MAAzB,CAAZ;AACD;AACF,OApBE,CAoBD;;AACH,KAhC0B,CAgCzB;;;AACF,WAAO,CAACF,SAAD,EAAaD,MAAb,CAAP;AACD,GA5duB,CA4dtB;;;AA5dsB,C,CA8dxB;;AAGF;;;;;;;;;;;;;;;;;;AAcA1D,YAAY,CAACE,WAAb,GAA2B,YAAU;AACnC,SAAO,IAAIF,YAAJ,EAAP;AACD,CAFD","sourcesContent":["/**\n * This class provides a single point of access to the LHC UCUM utilities\n *\n * @author Lee Mericle\n *\n */\nvar Ucum = require('./config.js').Ucum;\nimport {ucumJsonDefs} from './ucumJsonDefs.js';\nvar UnitTables = require('./unitTables.js').UnitTables;\nvar UnitString = require('./unitString.js').UnitString;\n\nimport * as intUtils_ from \"./ucumInternalUtils.js\";\n\n/**\n * UCUM external utilities class\n */\nexport class UcumLhcUtils {\n\n  /**\n   * Constructor.  This loads the json prefix and unit definitions if\n   * they haven't been loaded already and creates itself as a singleton object.\n   *\n   */\n  constructor() {\n\n      if (UnitTables.getInstance().unitsCount() === 0) {\n\n        // Load the prefix and unit objects\n        ucumJsonDefs.loadJsonDefs();\n      }\n\n      // Get the UnitString parser that will be used with this instance\n      // of the LHC Utilities\n      this.uStrParser_ = UnitString.getInstance();\n\n  } // end constructor\n\n\n  /**\n   * This method calls the useHTMLInMessages method on the UnitString\n   * object.  It should be called by web applications that use\n   * these utilities.\n   *\n   * @param use flag indicating whether or not to use the braces message;\n   *  defaults to true\n   */\n  useHTMLInMessages(use) {\n    if (use === undefined)\n      use = true ;\n    this.uStrParser_.useHTMLInMessages(use);\n  }\n\n\n  /**\n   * This method calls the useBraceMsgForEachString method on the UnitString\n   * object.  It should be called by web applications where unit\n   * strings are validated individually (as opposed to validating a whole\n   * file of unit strings).\n   *\n   * @param use flag indicating whether or not to use the braces message;\n   *  defaults to true\n   */\n  useBraceMsgForEachString(use) {\n    if (use === undefined)\n      use = true ;\n    this.uStrParser_.useBraceMsgForEachString(use);\n  }\n\n\n  /**\n   * This method validates a unit string.  It first checks to see if the\n   * string passed in is a unit code that is found in the unit codes table.\n   * If it is not found it parses the string to see if it resolves to a\n   * valid unit string.\n   *\n   * If a valid unit cannot be found, the string is tested for some common\n   * errors, such as missing brackets or a missing multiplication operator.\n   * If found, the error is reported in the messages array that is returned.\n   *\n   * If a valid unit cannot be found and an error cannot be discerned, this\n   * may return, if requested, a list of suggested units in the messages\n   * array that is returned.  Suggestions are based on matching the expression\n   * with unit names and synonyms.\n   *\n   * @param uStr the string to be validated\n   * @param suggest a boolean to indicate whether or not suggestions are\n   *  requested for a string that cannot be resolved to a valid unit;\n   *  true indicates suggestions are wanted; false indicates they are not,\n   *  and is the default if the parameter is not specified;\n   * @param valConv a string indicating if this validation request was initiated\n   *  by a validation task ('validate') or a conversion task ('convert'),\n   *  used only for the demo code, and the default is 'Validator' if the\n   *  parameter is not specified;\n   * @returns an object with five properties:\n   *  'status' will be 'valid' (the uStr is a valid UCUM code), 'invalid'\n   *     (the uStr is not a valid UCUM code, and substitutions or\n   *     suggestions may or may not be returned, depending on what was\n   *     requested and found); or 'error' (an input or programming error\n   *     occurred);\n   *  'ucumCode' the valid ucum code, which may differ from what was passed\n   *    in (e.g., if 'Gauss' is passed in, this will contain 'G') OR null if\n   *    the string was flagged as invalid or an error occurred;\n   *  'msg' is an array of one or more messages, if the string is invalid or\n   *        an error occurred, indicating the problem, or an explanation of a\n   *        substitution such as the substitution of 'G' for 'Gauss', or\n   *        an empty array if no messages were generated;\n   *  'unit' which is null if no unit is found, or a hash for a unit found:\n   *    'code' is the unit's ucum code (G in the above example;\n   *    'name' is the unit's name (Gauss in the above example); and\n   *    'guidance' is the unit's guidance/description data; and\n   *  'suggestions' if suggestions were requested and found, this is an array\n   *     of one or more hash objects.  Each hash contains three elements:\n   *     'msg' which is a message indicating what part of the uStr input\n   *        parameter the suggestions are for;\n   *     'invalidUnit' which is the unit expression the suggestions are\n   *        for; and\n   *     'units' which is an array of data for each suggested unit found.\n   *        Each array will contain the unit code, the unit name and the\n   *        unit guidance (if any).\n   *     If no suggestions were requested and found, this property is not\n   *     returned.\n   */\n  validateUnitString(uStr, suggest, valConv) {\n\n    if (suggest === undefined)\n      suggest = false ;\n\n    if (valConv === undefined)\n      valConv = 'validate' ;\n\n    let resp = this.getSpecifiedUnit(uStr, valConv, suggest);\n    let theUnit = resp['unit'];\n    let retObj = {};\n    if (!theUnit) {\n      retObj = {'status': (!resp['origString'] || resp['origString'] === null) ?\n                           'error' : 'invalid',\n                'ucumCode': null};\n    }\n    else {\n      retObj = {'status': resp['origString'] === uStr ? 'valid': 'invalid',\n                'ucumCode': resp['origString'],\n                'unit': {'code': theUnit.csCode_,\n                         'name': theUnit.name_,\n                         'guidance': theUnit.guidance_ }};\n    }\n    if (resp['suggestions']) {\n      retObj['suggestions'] = resp['suggestions'];\n    }\n    retObj['msg'] = resp['retMsg'];\n    return retObj;\n\n  } // end validateUnitString\n\n\n  /**\n   * This method converts one unit to another\n   *\n   * @param fromUnitCode the unit code/expression/string of the unit to be converted\n   * @param fromVal the number of \"from\" units to be converted to \"to\" units\n   * @param toUnitCode the unit code/expression/string of the unit that the from\n   *  field is to be converted to\n   * @param suggest a boolean to indicate whether or not suggestions are\n   *  requested for a string that cannot be resolved to a valid unit;\n   *  true indicates suggestions are wanted; false indicates they are not,\n   *  and is the default if the parameter is not specified;\n   * @param molecularWeight the molecular weight of the substance in question\n   *  when a conversion is being requested from mass to moles and vice versa.\n   *  This is required when one of the units represents a value in moles.  It is\n   *  ignored if neither unit includes a measurement in moles.\n   * @returns a hash with six elements:\n   *  'status' that will be: 'succeeded' if the conversion was successfully\n   *     calculated; 'failed' if the conversion could not be made, e.g., if\n   *     the units are not commensurable; or 'error' if an error occurred;\n   *  'toVal' the numeric value indicating the conversion amount, or null\n   *     if the conversion failed (e.g., if the units are not commensurable);\n   *  'msg' is an array message, if the string is invalid or an error occurred,\n   *        indicating the problem, or an explanation of a substitution such as\n   *        the substitution of 'G' for 'Gauss', or an empty array if no\n   *        messages were generated;\n   *  'suggestions' if suggestions were requested and found, this is a hash\n   *     that contains at most two elements:\n   *     'from' which, if the fromUnitCode input parameter or one or more of\n   *       its components could not be found, is an array one or more hash\n   *       objects.  Each hash contains three elements:\n   *         'msg' which is a message indicating what unit expression the\n   *            suggestions are for;\n   *         'invalidUnit' which is the unit expression the suggestions\n   *            are for; and\n   *         'units' which is an array of data for each suggested unit found.\n   *            Each array will contain the unit code, the unit name and the\n   *            unit guidance (if any).\n   *       If no suggestions were found for the fromUnitCode this element\n   *       will not be included.\n   *     'to' which, if the \"to\" unit expression or one or more of its\n   *       components could not be found, is an array one or more hash objects.  Each hash\n   *       contains three elements:\n   *         'msg' which is a message indicating what toUnitCode input\n   *            parameter the suggestions are for;\n   *         'invalidUnit' which is the unit expression the suggestions\n   *            are for; and\n   *         'units' which is an array of data for each suggested unit found.\n   *            Each array will contain the unit code, the unit name and the\n   *            unit guidance (if any).\n   *       If no suggestions were found for the toUnitCode this element\n   *       will not be included.\n   *    No 'suggestions' element will be included in the returned hash\n   *    object if none were found, whether or not they were requested.\n   *  'fromUnit' the unit object for the fromUnitCode passed in; returned\n   *     in case it's needed for additional data from the object; and\n   *  'toUnit' the unit object for the toUnitCode passed in; returned\n   *     in case it's needed for additional data from the object.\n   */\n  convertUnitTo(fromUnitCode, fromVal, toUnitCode, suggest, molecularWeight) {\n    if (suggest === undefined)\n      suggest = false ;\n\n    if (molecularWeight === undefined)\n      molecularWeight = null ;\n\n    let returnObj = {'status' : 'failed',\n                     'toVal' : null,\n                     'msg' : []} ;\n\n    if (fromUnitCode) {\n      fromUnitCode = fromUnitCode.trim();\n    }\n    if (!fromUnitCode || fromUnitCode == '') {\n      returnObj['status'] = 'error';\n      returnObj['msg'].push('No \"from\" unit expression specified.');\n    }\n    if (fromVal === null || isNaN(fromVal) || (typeof fromVal !== 'number' &&\n        !intUtils_.isNumericString(fromVal))) {\n      returnObj['status'] = 'error';\n      returnObj['msg'].push('No \"from\" value, or an invalid \"from\" value, ' +\n                         'was specified.');\n    }\n    if (toUnitCode) {\n      toUnitCode = toUnitCode.trim();\n    }\n    if (!toUnitCode || toUnitCode == '') {\n      returnObj['status'] = 'error';\n      returnObj['msg'].push('No \"to\" unit expression specified.');\n    }\n    if (returnObj['status'] !== 'error') {\n      try {\n        let fromUnit = null;\n\n        let parseResp = this.getSpecifiedUnit(fromUnitCode, 'convert', suggest);\n        fromUnit = parseResp['unit'];\n        if (parseResp['retMsg'])\n          returnObj['msg'] = returnObj['msg'].concat(parseResp['retMsg']);\n        if (parseResp['suggestions']) {\n          returnObj['suggestions'] = {};\n          returnObj['suggestions']['from'] = parseResp['suggestions'];\n        }\n        if (!fromUnit) {\n          returnObj['msg'].push(`Unable to find a unit for ${fromUnitCode}, ` +\n            `so no conversion could be performed.`);\n        }\n\n        let toUnit = null;\n        parseResp = this.getSpecifiedUnit(toUnitCode, 'convert', suggest);\n        toUnit = parseResp['unit'];\n        if (parseResp['retMsg'])\n          returnObj['msg'] = returnObj['msg'].concat(parseResp['retMsg']);\n        if (parseResp['suggestions']) {\n          if (!returnObj['suggestions'])\n            returnObj['suggestions'] = {} ;\n          returnObj['suggestions']['to'] = parseResp['suggestions'];\n        }\n        if (!toUnit) {\n          returnObj['msg'].push(`Unable to find a unit for ${toUnitCode}, ` +\n                                `so no conversion could be performed.`);\n        }\n\n        if (fromUnit && toUnit) {\n          try {\n            // if no molecular weight was specified perform a normal conversion\n            if (!molecularWeight) {\n              returnObj['toVal'] = toUnit.convertFrom(fromVal, fromUnit);\n            }\n            else {\n              if (fromUnit.moleExp_ !== 0 && toUnit.moleExp_ !== 0) {\n                throw(new Error('A molecular weight was specified ' +\n                  'but a mass <-> mole conversion cannot be executed for two ' +\n                  'mole-based units.  No conversion was attempted.'));\n              }\n              if (fromUnit.moleExp_ === 0 && toUnit.moleExp_ === 0) {\n                throw(new Error('A molecular weight was specified ' +\n                  'but a mass <-> mole conversion cannot be executed when ' +\n                  'neither unit is mole-based.  No conversion was attempted.'));\n              }\n              if (!fromUnit.isMoleMassCommensurable(toUnit)) {\n                throw(new Error(`Sorry.  ${fromUnitCode} cannot be ` +\n                  `converted to ${toUnitCode}.`));\n              }\n\n              // if the \"from\" unit is a mole-based unit, assume a mole to mass\n              // request\n              if (fromUnit.moleExp_ !== 0) {\n                returnObj['toVal'] =\n                  fromUnit.convertMolToMass(fromVal, toUnit, molecularWeight);\n              }\n              // else the \"to\" unit must be the mole-based unit, so assume a\n              // mass to mole request\n              else {\n                returnObj['toVal'] =\n                  fromUnit.convertMassToMol(fromVal, toUnit, molecularWeight);\n              }\n            } // end if a molecular weight was specified\n\n            // if an error hasn't been thrown - either from convertFrom or here,\n            // set the return object to show success\n            returnObj['status'] = 'succeeded';\n            returnObj['fromUnit'] = fromUnit;\n            returnObj['toUnit'] = toUnit;\n          }\n          catch (err) {\n            returnObj['status'] = 'failed';\n            returnObj['msg'].push(err.message);\n          }\n\n\n        }  // end if we have the from and to units\n      }\n      catch (err) {\n        if (err.message == Ucum.needMoleWeightMsg_)\n          returnObj['status'] = 'failed';\n        else\n          returnObj['status'] = 'error';\n        returnObj['msg'].push(err.message);\n      }\n    }\n\n    return returnObj ;\n\n  } // end convertUnitTo\n\n\n  /**\n   * This method accepts a term and looks for units that include it as\n   * a synonym - or that include the term in its name.\n   *\n   * @param theSyn the term to search for\n   * @returns a hash with up to three elements:\n   *  'status' contains the status of the request, which can be 'error',\n   *    'failed' or succeeded';\n   *  'msg' which contains a message for an error or if no units were found; and\n   *  'units' which is an array that contains one hash for each unit found:\n   *    'code' is the unit's csCode_\n   *    'name' is the unit's name_\n   *    'guidance' is the unit's guidance_\n   *\n   */\n  checkSynonyms(theSyn) {\n    let retObj = {} ;\n    if (theSyn === undefined || theSyn === null) {\n      retObj['status'] = 'error';\n      retObj['msg'] = 'No term specified for synonym search.'\n    }\n    else {\n      retObj = intUtils_.getSynonyms(theSyn);\n    } // end if a search synonym was supplied\n\n    return retObj ;\n\n  } // end checkSynonyms\n\n\n  /**\n   * This method parses a unit string to get (or try to get) the unit\n   * represented by the string.  It returns an error message if no string was specified\n   * or if any errors were encountered trying to get the unit.\n   *\n   * @param uName the expression/string representing the unit\n   * @param valConv indicates what type of request this is for - a request to\n   *  validate (pass in 'validate') or a request to convert (pass in 'convert')\n   * @param suggest a boolean to indicate whether or not suggestions are\n   *  requested for a string that cannot be resolved to a valid unit;\n   *  true indicates suggestions are wanted; false indicates they are not,\n   *  and is the default if the parameter is not specified;\n   * @returns a hash containing:\n   *   'unit' the unit object (or null if there were problems creating the\n   *     unit);\n   *   'origString' the possibly updated unit string passed in;\n   *   'retMsg' an array of user messages (informational, error or warning) if\n   *     any were generated (IF any were generated, otherwise will be an\n   *     empty array); and\n   *  'suggestions' is an array of 1 or more hash objects.  Each hash\n   *     contains three elements:\n   *       'msg' which is a message indicating what unit expression the\n   *          suggestions are for;\n   *       'invalidUnit' which is the unit expression the suggestions are\n   *          for; and\n   *       'units' which is an array of data for each suggested unit found.\n   *          Each array will contain the unit code, the unit name and the\n   *          unit guidance (if any).\n   *   The return hash will not contain a suggestions array if a valid unit\n   *   was found or if suggestions were not requested and found.\n   */\n  getSpecifiedUnit(uName, valConv, suggest) {\n\n    if (suggest === undefined)\n      suggest = false ;\n\n    let retObj = {};\n    retObj['retMsg'] = [];\n\n    if (!uName) {\n      retObj['retMsg'].push('No unit string specified.');\n    }\n    else {\n      let utab = UnitTables.getInstance();\n      uName = uName.trim();\n\n      // go ahead and just try using the name as the code.  This may or may not\n      // work, but if it does, it cuts out a lot of parsing.\n      let theUnit = utab.getUnitByCode(uName);\n\n      // If we found it, set the returned unit string to what was passed in;\n      // otherwise try parsing as a unit string\n      if (theUnit) {\n        retObj['unit'] = theUnit ;\n        retObj['origString'] = uName;\n      }\n      else {\n        try {\n          let resp = this.uStrParser_.parseString(uName, valConv, suggest);\n          retObj['unit'] = resp[0];\n          retObj['origString'] = resp[1];\n          if (resp[2])\n            retObj['retMsg'] = resp[2];\n          retObj['suggestions'] = resp[3];\n        }\n        catch (err) {\n          console.log(`Unit requested for unit string ${uName}.` +\n            'request unsuccessful; error thrown = ' + err.message);\n            retObj['retMsg'].unshift(`${uName} is not a valid unit.  ` +\n                                     `${err.message}`);\n        }\n      } // end if the unit was not found as a unit name\n    } // end if a unit expression was specified\n\n    return retObj;\n\n  } // end getSpecifiedUnit\n\n\n  /**\n   * This method retrieves a list of units commensurable, i.e., that can be\n   * converted from and to, a specified unit.  Returns an error if the \"from\"\n   * unit cannot be found.\n   *\n   * @param fromName the name/unit string of the \"from\" unit\n   * @returns an array containing two elements;\n   *   first element is the list of commensurable units if any were found\n   *   second element is an error message if the \"from\" unit is not found\n   */\n  commensurablesList(fromName) {\n\n    let retMsg = [];\n    let commUnits = null ;\n    let parseResp = this.getSpecifiedUnit(fromName, 'validate', false);\n    let fromUnit = parseResp['unit'];\n    if (parseResp['retMsg'].length > 0)\n      retMsg = parseResp['retMsg'] ;\n    if (!fromUnit) {\n      retMsg.push(`Could not find unit ${fromName}.`);\n    }\n    else {\n      let dimVec = null ;\n      let fromDim = fromUnit.getProperty('dim_');\n      if (!fromDim) {\n        retMsg.push('No commensurable units were found for ' + fromName) ;\n      }\n      else {\n        try {\n          dimVec = fromDim.getProperty('dimVec_');\n        }\n        catch (err) {\n          retMsg.push(err.message);\n          if (err.message ===\n            \"Dimension does not have requested property(dimVec_)\")\n            dimVec = null;\n        }\n        if (dimVec) {\n          let utab = UnitTables.getInstance();\n          commUnits = utab.getUnitsByDimension(dimVec);\n        }\n      } // end if the from unit has a dimension vector\n    } // end if we found a \"from\" unit\n    return [commUnits , retMsg];\n  } // end commensurablesList\n\n} // end UcumLhcUtils class\n\n\n/**\n *  This function exists ONLY until the original UcumLhcUtils constructor\n *  is called for the first time.  It's defined here in case getInstance\n *  is called before the constructor.   This calls the constructor.\n *\n *  The constructor redefines the getInstance function to return the\n *  singleton UcumLhcUtils object.  This is based on the UnitTables singleton\n *  implementation; see more detail in the UnitTables constructor description.\n *\n *  NO LONGER TRUE - not implemented as a singleton.  This method retained to\n *  avoid problems with calls to it that exist throughout the code.\n *\n *  @return the (formerly singleton) UcumLhcUtils object.\n */\nUcumLhcUtils.getInstance = function(){\n  return new UcumLhcUtils();\n} ;\n\n\n\n\n"],"file":"ucumLhcUtils.js"}
+{"version":3,"sources":["../source/ucumLhcUtils.js"],"names":["Ucum","require","UnitTables","UnitString","UcumLhcUtils","constructor","getInstance","unitsCount","ucumJsonDefs","loadJsonDefs","uStrParser_","useHTMLInMessages","use","undefined","useBraceMsgForEachString","validateUnitString","uStr","suggest","valConv","resp","getSpecifiedUnit","theUnit","retObj","csCode_","name_","guidance_","status","convertUnitTo","fromUnitCode","fromVal","toUnitCode","molecularWeight","returnObj","trim","push","_checkFromVal","fromUnit","parseResp","concat","toUnit","convertFrom","moleExp_","Error","isMoleMassCommensurable","convertMolToMass","convertMassToMol","err","message","needMoleWeightMsg_","convertToBaseUnits","inputUnitLookup","unit","msg","retMsg","length","isArbitrary_","unitToExp","dimVec","dim_","dimVec_","baseUnitString","dimVecIndexToBaseUnit","dimVecIndexToBaseUnit_","i","len","exp","retUnitLookup","retUnit","magnitude","e","toString","fromUnitIsSpecial","isSpecial_","responseObj","isNaN","intUtils_","isNumericString","checkSynonyms","theSyn","getSynonyms","uName","utab","getUnitByCode","parseString","console","log","unshift","origString","commensurablesList","fromName","commUnits","fromDim","getProperty","getUnitsByDimension"],"mappings":"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","sourcesContent":["/**\n * This class provides a single point of access to the LHC UCUM utilities\n *\n * @author Lee Mericle\n *\n */\nvar Ucum = require('./config.js').Ucum;\nimport {ucumJsonDefs} from './ucumJsonDefs.js';\nvar UnitTables = require('./unitTables.js').UnitTables;\nvar UnitString = require('./unitString.js').UnitString;\n\nimport * as intUtils_ from \"./ucumInternalUtils.js\";\n\n/**\n * UCUM external utilities class\n */\nexport class UcumLhcUtils {\n\n  /**\n   * Constructor.  This loads the json prefix and unit definitions if\n   * they haven't been loaded already and creates itself as a singleton object.\n   *\n   */\n  constructor() {\n\n      if (UnitTables.getInstance().unitsCount() === 0) {\n\n        // Load the prefix and unit objects\n        ucumJsonDefs.loadJsonDefs();\n      }\n\n      // Get the UnitString parser that will be used with this instance\n      // of the LHC Utilities\n      this.uStrParser_ = UnitString.getInstance();\n\n  } // end constructor\n\n\n  /**\n   * This method calls the useHTMLInMessages method on the UnitString\n   * object.  It should be called by web applications that use\n   * these utilities.\n   *\n   * @param use flag indicating whether or not to use the braces message;\n   *  defaults to true\n   */\n  useHTMLInMessages(use) {\n    if (use === undefined)\n      use = true ;\n    this.uStrParser_.useHTMLInMessages(use);\n  }\n\n\n  /**\n   * This method calls the useBraceMsgForEachString method on the UnitString\n   * object.  It should be called by web applications where unit\n   * strings are validated individually (as opposed to validating a whole\n   * file of unit strings).\n   *\n   * @param use flag indicating whether or not to use the braces message;\n   *  defaults to true\n   */\n  useBraceMsgForEachString(use) {\n    if (use === undefined)\n      use = true ;\n    this.uStrParser_.useBraceMsgForEachString(use);\n  }\n\n\n  /**\n   * This method validates a unit string.  It first checks to see if the\n   * string passed in is a unit code that is found in the unit codes table.\n   * If it is not found it parses the string to see if it resolves to a\n   * valid unit string.\n   *\n   * If a valid unit cannot be found, the string is tested for some common\n   * errors, such as missing brackets or a missing multiplication operator.\n   * If found, the error is reported in the messages array that is returned.\n   *\n   * If a valid unit cannot be found and an error cannot be discerned, this\n   * may return, if requested, a list of suggested units in the messages\n   * array that is returned.  Suggestions are based on matching the expression\n   * with unit names and synonyms.\n   *\n   * @param uStr the string to be validated\n   * @param suggest a boolean to indicate whether or not suggestions are\n   *  requested for a string that cannot be resolved to a valid unit;\n   *  true indicates suggestions are wanted; false indicates they are not,\n   *  and is the default if the parameter is not specified;\n   * @param valConv a string indicating if this validation request was initiated\n   *  by a validation task ('validate') or a conversion task ('convert'),\n   *  used only for the demo code, and the default is 'Validator' if the\n   *  parameter is not specified;\n   * @returns an object with five properties:\n   *  'status' will be 'valid' (the uStr is a valid UCUM code), 'invalid'\n   *     (the uStr is not a valid UCUM code, and substitutions or\n   *     suggestions may or may not be returned, depending on what was\n   *     requested and found); or 'error' (an input or programming error\n   *     occurred);\n   *  'ucumCode' the valid ucum code, which may differ from what was passed\n   *    in (e.g., if 'Gauss' is passed in, this will contain 'G') OR null if\n   *    the string was flagged as invalid or an error occurred;\n   *  'msg' is an array of one or more messages, if the string is invalid or\n   *        an error occurred, indicating the problem, or an explanation of a\n   *        substitution such as the substitution of 'G' for 'Gauss', or\n   *        an empty array if no messages were generated;\n   *  'unit' which is null if no unit is found, or a hash for a unit found:\n   *    'code' is the unit's ucum code (G in the above example;\n   *    'name' is the unit's name (Gauss in the above example); and\n   *    'guidance' is the unit's guidance/description data; and\n   *  'suggestions' if suggestions were requested and found, this is an array\n   *     of one or more hash objects.  Each hash contains three elements:\n   *     'msg' which is a message indicating what part of the uStr input\n   *        parameter the suggestions are for;\n   *     'invalidUnit' which is the unit expression the suggestions are\n   *        for; and\n   *     'units' which is an array of data for each suggested unit found.\n   *        Each array will contain the unit code, the unit name and the\n   *        unit guidance (if any).\n   *     If no suggestions were requested and found, this property is not\n   *     returned.\n   */\n  validateUnitString(uStr, suggest, valConv) {\n\n    if (suggest === undefined)\n      suggest = false ;\n\n    if (valConv === undefined)\n      valConv = 'validate' ;\n\n    let resp = this.getSpecifiedUnit(uStr, valConv, suggest);\n    let theUnit = resp['unit'];\n    let retObj = !theUnit ? {'ucumCode': null} :\n      {'ucumCode': resp['origString'],\n       'unit': {'code': theUnit.csCode_,\n                'name': theUnit.name_,\n                'guidance': theUnit.guidance_ }};\n    retObj.status = resp.status;\n    if (resp['suggestions']) {\n      retObj['suggestions'] = resp['suggestions'];\n    }\n    retObj['msg'] = resp['retMsg'];\n    return retObj;\n\n  } // end validateUnitString\n\n\n  /**\n   * This method converts one unit to another\n   *\n   * @param fromUnitCode the unit code/expression/string of the unit to be converted\n   * @param fromVal the number of \"from\" units to be converted to \"to\" units\n   * @param toUnitCode the unit code/expression/string of the unit that the from\n   *  field is to be converted to\n   * @param suggest a boolean to indicate whether or not suggestions are\n   *  requested for a string that cannot be resolved to a valid unit;\n   *  true indicates suggestions are wanted; false indicates they are not,\n   *  and is the default if the parameter is not specified;\n   * @param molecularWeight the molecular weight of the substance in question\n   *  when a conversion is being requested from mass to moles and vice versa.\n   *  This is required when one of the units represents a value in moles.  It is\n   *  ignored if neither unit includes a measurement in moles.\n   * @returns a hash with six elements:\n   *  'status' that will be: 'succeeded' if the conversion was successfully\n   *     calculated; 'failed' if the conversion could not be made, e.g., if\n   *     the units are not commensurable; or 'error' if an error occurred;\n   *  'toVal' the numeric value indicating the conversion amount, or null\n   *     if the conversion failed (e.g., if the units are not commensurable);\n   *  'msg' is an array message, if the string is invalid or an error occurred,\n   *        indicating the problem, or an explanation of a substitution such as\n   *        the substitution of 'G' for 'Gauss', or an empty array if no\n   *        messages were generated;\n   *  'suggestions' if suggestions were requested and found, this is a hash\n   *     that contains at most two elements:\n   *     'from' which, if the fromUnitCode input parameter or one or more of\n   *       its components could not be found, is an array one or more hash\n   *       objects.  Each hash contains three elements:\n   *         'msg' which is a message indicating what unit expression the\n   *            suggestions are for;\n   *         'invalidUnit' which is the unit expression the suggestions\n   *            are for; and\n   *         'units' which is an array of data for each suggested unit found.\n   *            Each array will contain the unit code, the unit name and the\n   *            unit guidance (if any).\n   *       If no suggestions were found for the fromUnitCode this element\n   *       will not be included.\n   *     'to' which, if the \"to\" unit expression or one or more of its\n   *       components could not be found, is an array one or more hash objects.  Each hash\n   *       contains three elements:\n   *         'msg' which is a message indicating what toUnitCode input\n   *            parameter the suggestions are for;\n   *         'invalidUnit' which is the unit expression the suggestions\n   *            are for; and\n   *         'units' which is an array of data for each suggested unit found.\n   *            Each array will contain the unit code, the unit name and the\n   *            unit guidance (if any).\n   *       If no suggestions were found for the toUnitCode this element\n   *       will not be included.\n   *    No 'suggestions' element will be included in the returned hash\n   *    object if none were found, whether or not they were requested.\n   *  'fromUnit' the unit object for the fromUnitCode passed in; returned\n   *     in case it's needed for additional data from the object; and\n   *  'toUnit' the unit object for the toUnitCode passed in; returned\n   *     in case it's needed for additional data from the object.\n   */\n  convertUnitTo(fromUnitCode, fromVal, toUnitCode, suggest, molecularWeight) {\n    if (suggest === undefined)\n      suggest = false ;\n\n    if (molecularWeight === undefined)\n      molecularWeight = null ;\n\n    let returnObj = {'status' : 'failed',\n                     'toVal' : null,\n                     'msg' : []} ;\n\n    if (fromUnitCode) {\n      fromUnitCode = fromUnitCode.trim();\n    }\n    if (!fromUnitCode || fromUnitCode == '') {\n      returnObj['status'] = 'error';\n      returnObj['msg'].push('No \"from\" unit expression specified.');\n    }\n    this._checkFromVal(fromVal, returnObj);\n    if (toUnitCode) {\n      toUnitCode = toUnitCode.trim();\n    }\n    if (!toUnitCode || toUnitCode == '') {\n      returnObj['status'] = 'error';\n      returnObj['msg'].push('No \"to\" unit expression specified.');\n    }\n    if (returnObj['status'] !== 'error') {\n      try {\n        let fromUnit = null;\n\n        let parseResp = this.getSpecifiedUnit(fromUnitCode, 'convert', suggest);\n        fromUnit = parseResp['unit'];\n        if (parseResp['retMsg'])\n          returnObj['msg'] = returnObj['msg'].concat(parseResp['retMsg']);\n        if (parseResp['suggestions']) {\n          returnObj['suggestions'] = {};\n          returnObj['suggestions']['from'] = parseResp['suggestions'];\n        }\n        if (!fromUnit) {\n          returnObj['msg'].push(`Unable to find a unit for ${fromUnitCode}, ` +\n            `so no conversion could be performed.`);\n        }\n\n        let toUnit = null;\n        parseResp = this.getSpecifiedUnit(toUnitCode, 'convert', suggest);\n        toUnit = parseResp['unit'];\n        if (parseResp['retMsg'])\n          returnObj['msg'] = returnObj['msg'].concat(parseResp['retMsg']);\n        if (parseResp['suggestions']) {\n          if (!returnObj['suggestions'])\n            returnObj['suggestions'] = {} ;\n          returnObj['suggestions']['to'] = parseResp['suggestions'];\n        }\n        if (!toUnit) {\n          returnObj['msg'].push(`Unable to find a unit for ${toUnitCode}, ` +\n                                `so no conversion could be performed.`);\n        }\n\n        if (fromUnit && toUnit) {\n          try {\n            // if no molecular weight was specified perform a normal conversion\n            if (!molecularWeight) {\n              returnObj['toVal'] = toUnit.convertFrom(fromVal, fromUnit);\n            }\n            else {\n              if (fromUnit.moleExp_ !== 0 && toUnit.moleExp_ !== 0) {\n                throw(new Error('A molecular weight was specified ' +\n                  'but a mass <-> mole conversion cannot be executed for two ' +\n                  'mole-based units.  No conversion was attempted.'));\n              }\n              if (fromUnit.moleExp_ === 0 && toUnit.moleExp_ === 0) {\n                throw(new Error('A molecular weight was specified ' +\n                  'but a mass <-> mole conversion cannot be executed when ' +\n                  'neither unit is mole-based.  No conversion was attempted.'));\n              }\n              if (!fromUnit.isMoleMassCommensurable(toUnit)) {\n                throw(new Error(`Sorry.  ${fromUnitCode} cannot be ` +\n                  `converted to ${toUnitCode}.`));\n              }\n\n              // if the \"from\" unit is a mole-based unit, assume a mole to mass\n              // request\n              if (fromUnit.moleExp_ !== 0) {\n                returnObj['toVal'] =\n                  fromUnit.convertMolToMass(fromVal, toUnit, molecularWeight);\n              }\n              // else the \"to\" unit must be the mole-based unit, so assume a\n              // mass to mole request\n              else {\n                returnObj['toVal'] =\n                  fromUnit.convertMassToMol(fromVal, toUnit, molecularWeight);\n              }\n            } // end if a molecular weight was specified\n\n            // if an error hasn't been thrown - either from convertFrom or here,\n            // set the return object to show success\n            returnObj['status'] = 'succeeded';\n            returnObj['fromUnit'] = fromUnit;\n            returnObj['toUnit'] = toUnit;\n          }\n          catch (err) {\n            returnObj['status'] = 'failed';\n            returnObj['msg'].push(err.message);\n          }\n\n\n        }  // end if we have the from and to units\n      }\n      catch (err) {\n        if (err.message == Ucum.needMoleWeightMsg_)\n          returnObj['status'] = 'failed';\n        else\n          returnObj['status'] = 'error';\n        returnObj['msg'].push(err.message);\n      }\n    }\n\n    return returnObj ;\n\n  } // end convertUnitTo\n\n\n  /**\n   *  Converts the given unit string into its base units, their exponents, and\n   *  a magnitude, and returns that data.\n   * @param fromUnit the unit string to be converted to base units information\n   * @param fromVal the number of \"from\" units to be converted\n   * @returns an object with the properties:\n   *  'status' indicates whether the result succeeded.  The value will be one of:\n   *    'succeeded':  the conversion was successfully calculated (which can be\n   *      true even if it was already in base units);\n   *    'invalid':  fromUnit is not a valid UCUM code;\n   *    'failed':  the conversion could not be made (e.g., if it is an \"arbitrary\" unit);\n   *    'error':  if an error occurred (an input or programming error)\n   *  'msg': an array of one or more messages, if the string is invalid or\n   *        an error occurred, indicating the problem, or a suggestion of a\n   *        substitution such as the substitution of 'G' for 'Gauss', or\n   *        an empty array if no messages were generated.  There can also be a\n   *        message that is just informational or warning.\n   *  'magnitude': the new value when fromVal units of fromUnits is expressed in the base units.\n   *  'fromUnitIsSpecial': whether the input unit fromUnit is a \"special unit\"\n   *         as defined in UCUM.  This means there is some function applied to convert\n   *         between fromUnit and the base units, so the returned magnitude is likely not\n   *         useful as a scale factor for other conversions (i.e., it only has validity\n   *         and usefulness for the input values that produced it).\n   *  'unitToExp': a map of base units in uStr to their exponent\n   */\n  convertToBaseUnits(fromUnit, fromVal) {\n    let retObj = {};\n    this._checkFromVal(fromVal, retObj);\n    if (!retObj.status) { // could be set to 'error' by _checkFromVal\n      let inputUnitLookup = this.getSpecifiedUnit(fromUnit, 'validate');\n      retObj = {status: inputUnitLookup.status == 'valid' ? 'succeeded' : inputUnitLookup.status};\n      let unit = inputUnitLookup.unit;\n      retObj.msg = inputUnitLookup.retMsg || [];\n      if (!unit) {\n        if (inputUnitLookup.retMsg?.length == 0)\n          retObj.msg.push('Could not find unit information for '+fromUnit);\n      }\n      else if (unit.isArbitrary_) {\n        retObj.msg.push('Arbitrary units cannot be converted to base units or other units.');\n        retObj.status = 'failed';\n      }\n      else if (retObj.status == 'succeeded') {\n        let unitToExp = {};\n        let dimVec = unit.dim_?.dimVec_\n        let baseUnitString = '1';\n        if (dimVec) {\n          let dimVecIndexToBaseUnit = UnitTables.getInstance().dimVecIndexToBaseUnit_;\n          for (let i=0, len=dimVec.length; i<len; ++i) {\n            let exp = dimVec[i];\n            if (exp) {\n              unitToExp[dimVecIndexToBaseUnit[i]] = exp;\n              baseUnitString += '.' + dimVecIndexToBaseUnit[i] + exp;\n            }\n          }\n        }\n\n        // The unit might have a conversion function, which has to be applied; we\n        // cannot just assume unit_.magnitude_ is the magnitude in base units.\n        let retUnitLookup = this.getSpecifiedUnit(baseUnitString, 'validate');\n        // There should not be any error in retUnitLookup, unless there is a bug.\n        let retUnit = retUnitLookup.unit;\n        if (retUnitLookup.status !== 'valid') {\n          retObj.msg.push('Unable construct base unit string; tried '+baseUnitString);\n          retObj.status = 'error';\n        }\n        else {\n          try {\n            retObj.magnitude = retUnit.convertFrom(fromVal, unit);\n          }\n          catch (e) {\n            retObj.msg.push(e.toString());\n            retObj.status = 'error';\n          }\n          if (retObj.status == 'succeeded') {\n            retObj.unitToExp = unitToExp;\n            retObj.fromUnitIsSpecial = unit.isSpecial_;\n          }\n        }\n      }\n    }\n    return retObj;\n  }\n\n\n  /**\n   *  Checks the given value as to whether it is suitable as a \"from\" value in a\n   *  unit conversion.  If it is not, the responseObj will have its status set\n   *  to 'error' and a message added.\n   * @param fromVal The value to check\n   * @param responseObj the object that will be updated if the value is not\n   *  usable.\n   */\n  _checkFromVal(fromVal, responseObj) {\n    if (fromVal === null || isNaN(fromVal) || (typeof fromVal !== 'number' &&\n        !intUtils_.isNumericString(fromVal))) {\n      responseObj.status = 'error';\n      if (!responseObj.msg)\n        responseObj.msg = [];\n      responseObj.msg.push('No \"from\" value, or an invalid \"from\" value, ' +\n                         'was specified.');\n    }\n  }\n\n\n  /**\n   * This method accepts a term and looks for units that include it as\n   * a synonym - or that include the term in its name.\n   *\n   * @param theSyn the term to search for\n   * @returns a hash with up to three elements:\n   *  'status' contains the status of the request, which can be 'error',\n   *    'failed' or succeeded';\n   *  'msg' which contains a message for an error or if no units were found; and\n   *  'units' which is an array that contains one hash for each unit found:\n   *    'code' is the unit's csCode_\n   *    'name' is the unit's name_\n   *    'guidance' is the unit's guidance_\n   *\n   */\n  checkSynonyms(theSyn) {\n    let retObj = {} ;\n    if (theSyn === undefined || theSyn === null) {\n      retObj['status'] = 'error';\n      retObj['msg'] = 'No term specified for synonym search.'\n    }\n    else {\n      retObj = intUtils_.getSynonyms(theSyn);\n    } // end if a search synonym was supplied\n\n    return retObj ;\n\n  } // end checkSynonyms\n\n\n  /**\n   * This method parses a unit string to get (or try to get) the unit\n   * represented by the string.  It returns an error message if no string was specified\n   * or if any errors were encountered trying to get the unit.\n   *\n   * @param uName the expression/string representing the unit\n   * @param valConv indicates what type of request this is for - a request to\n   *  validate (pass in 'validate') or a request to convert (pass in 'convert')\n   * @param suggest a boolean to indicate whether or not suggestions are\n   *  requested for a string that cannot be resolved to a valid unit;\n   *  true indicates suggestions are wanted; false indicates they are not,\n   *  and is the default if the parameter is not specified;\n   * @returns a hash containing:\n   *   'status' will be 'valid' (uName is a valid UCUM code), 'invalid'\n   *     (the uStr is not a valid UCUM code, and substitutions or\n   *     suggestions may or may not be returned, depending on what was\n   *     requested and found); or 'error' (an input or programming error\n   *     occurred);\n   *   'unit' the unit object (or null if there were problems creating the\n   *     unit);\n   *   'origString' the possibly updated unit string passed in;\n   *   'retMsg' an array of user messages (informational, error or warning) if\n   *     any were generated (IF any were generated, otherwise will be an\n   *     empty array); and\n   *   'suggestions' is an array of 1 or more hash objects.  Each hash\n   *     contains three elements:\n   *       'msg' which is a message indicating what unit expression the\n   *          suggestions are for;\n   *       'invalidUnit' which is the unit expression the suggestions are\n   *          for; and\n   *       'units' which is an array of data for each suggested unit found.\n   *          Each array will contain the unit code, the unit name and the\n   *          unit guidance (if any).\n   *   The return hash will not contain a suggestions array if a valid unit\n   *   was found or if suggestions were not requested and found.\n   */\n  getSpecifiedUnit(uName, valConv, suggest) {\n\n    if (suggest === undefined)\n      suggest = false ;\n\n    let retObj = {};\n    retObj['retMsg'] = [];\n\n    if (!uName) {\n      retObj['retMsg'].push('No unit string specified.');\n    }\n    else {\n      let utab = UnitTables.getInstance();\n      uName = uName.trim();\n\n      // go ahead and just try using the name as the code.  This may or may not\n      // work, but if it does, it cuts out a lot of parsing.\n      let theUnit = utab.getUnitByCode(uName);\n\n      // If we found it, set the returned unit string to what was passed in;\n      // otherwise try parsing as a unit string\n      if (theUnit) {\n        retObj['unit'] = theUnit ;\n        retObj['origString'] = uName;\n      }\n      else {\n        try {\n          let resp = this.uStrParser_.parseString(uName, valConv, suggest);\n          retObj['unit'] = resp[0];\n          retObj['origString'] = resp[1];\n          if (resp[2])\n            retObj['retMsg'] = resp[2];\n          retObj['suggestions'] = resp[3];\n        }\n        catch (err) {\n          console.log(`Unit requested for unit string ${uName}.` +\n            'request unsuccessful; error thrown = ' + err.message);\n            retObj['retMsg'].unshift(`${uName} is not a valid unit.  ` +\n                                     `${err.message}`);\n        }\n      } // end if the unit was not found as a unit name\n    } // end if a unit expression was specified\n\n    // Set the status field\n    if (!retObj.unit) {\n      // No unit was found; check whether origString has a value\n      retObj.status = !retObj.origString ? 'error' : 'invalid';\n    }\n    else {\n      // Check whether substitutions were made to the unit string in order to\n      // find the unit\n      retObj.status = retObj.origString === uName ? 'valid': 'invalid';\n    }\n\n    return retObj;\n\n  } // end getSpecifiedUnit\n\n\n  /**\n   * This method retrieves a list of units commensurable, i.e., that can be\n   * converted from and to, a specified unit.  Returns an error if the \"from\"\n   * unit cannot be found.\n   *\n   * @param fromName the name/unit string of the \"from\" unit\n   * @returns an array containing two elements;\n   *   first element is the list of commensurable units if any were found\n   *   second element is an error message if the \"from\" unit is not found\n   */\n  commensurablesList(fromName) {\n\n    let retMsg = [];\n    let commUnits = null ;\n    let parseResp = this.getSpecifiedUnit(fromName, 'validate', false);\n    let fromUnit = parseResp['unit'];\n    if (parseResp['retMsg'].length > 0)\n      retMsg = parseResp['retMsg'] ;\n    if (!fromUnit) {\n      retMsg.push(`Could not find unit ${fromName}.`);\n    }\n    else {\n      let dimVec = null ;\n      let fromDim = fromUnit.getProperty('dim_');\n      if (!fromDim) {\n        retMsg.push('No commensurable units were found for ' + fromName) ;\n      }\n      else {\n        try {\n          dimVec = fromDim.getProperty('dimVec_');\n        }\n        catch (err) {\n          retMsg.push(err.message);\n          if (err.message ===\n            \"Dimension does not have requested property(dimVec_)\")\n            dimVec = null;\n        }\n        if (dimVec) {\n          let utab = UnitTables.getInstance();\n          commUnits = utab.getUnitsByDimension(dimVec);\n        }\n      } // end if the from unit has a dimension vector\n    } // end if we found a \"from\" unit\n    return [commUnits , retMsg];\n  } // end commensurablesList\n\n} // end UcumLhcUtils class\n\n\n/**\n *  This function exists ONLY until the original UcumLhcUtils constructor\n *  is called for the first time.  It's defined here in case getInstance\n *  is called before the constructor.   This calls the constructor.\n *\n *  The constructor redefines the getInstance function to return the\n *  singleton UcumLhcUtils object.  This is based on the UnitTables singleton\n *  implementation; see more detail in the UnitTables constructor description.\n *\n *  NO LONGER TRUE - not implemented as a singleton.  This method retained to\n *  avoid problems with calls to it that exist throughout the code.\n *\n *  @return the (formerly singleton) UcumLhcUtils object.\n */\nUcumLhcUtils.getInstance = function(){\n  return new UcumLhcUtils();\n} ;\n"],"file":"ucumLhcUtils.js"}