@itwin/core-quantity 4.8.0-dev.9 → 4.9.0-dev.1

package/lib/esm/Parser.d.ts

@@ -13,7 +13,8 @@ export declare enum ParseError {
     UnitLabelSuppliedButNotMatched = 3,
     UnknownUnit = 4,
     UnableToConvertParseTokensToQuantity = 5,
-    InvalidParserSpec = 6
+    InvalidParserSpec = 6,
+    MathematicOperationFoundButIsNotAllowed = 7
 }
 /** Parse error result from [[Parser.parseToQuantityValue]] or [[Parser.parseToQuantityValue]].
  * @beta
@@ -33,6 +34,10 @@ export interface ParsedQuantity {
     /** The magnitude of the parsed quantity. */
     value: number;
 }
+declare enum Operator {
+    addition = "+",
+    subtraction = "-"
+}
 /**
  * Defines Results of parsing a string input by a user into its desired value type
  * @beta
@@ -42,8 +47,9 @@ export type QuantityParseResult = ParsedQuantity | ParseQuantityError;
  * @beta
  */
 declare class ParseToken {
-    value: number | string;
-    constructor(value: string | number);
+    value: number | string | Operator;
+    isOperator: boolean;
+    constructor(value: string | number | Operator);
     get isString(): boolean;
     get isNumber(): boolean;
 }
@@ -62,7 +68,15 @@ export declare class Parser {
      * @param quantitySpecification The quantity string to ba parsed.
      */
     static parseQuantitySpecification(quantitySpecification: string, format: Format): ParseToken[];
+    private static isMathematicOperation;
     private static lookupUnitByLabel;
+    /**
+     * Get the output unit and all the conversion specs required to parse a given list of tokens.
+     */
+    private static getRequiredUnitsConversionsToParseTokens;
+    /**
+     * Get the units information asynchronously, then convert the tokens into quantity using the synchronous tokens -> value.
+     */
     private static createQuantityFromParseTokens;
     /** Async method to generate a Quantity given a string that represents a quantity value and likely a unit label.
      *  @param inString A string that contains text represent a quantity.
@@ -72,11 +86,18 @@ export declare class Parser {
     static parseIntoQuantity(inString: string, format: Format, unitsProvider: UnitsProvider, altUnitLabelsProvider?: AlternateUnitLabelsProvider): Promise<QuantityProps>;
     /** method to get the Unit Conversion given a unit label */
     private static tryFindUnitConversion;
+    /**
+     * Get what the unit conversion is for a unitless value.
+     */
+    private static getDefaultUnitConversion;
+    private static getNextTokenPair;
+    /**
+     * Accumulate the given list of tokens into a single quantity value. Formatting the tokens along the way.
+     */
     private static getQuantityValueFromParseTokens;
     /** Method to generate a Quantity given a string that represents a quantity value.
      *  @param inString A string that contains text represent a quantity.
      *  @param parserSpec unit label if not explicitly defined by user. Must have matching entry in supplied array of unitsConversions.
-     *  @param defaultValue default value to return if parsing is un successful
      */
     static parseQuantityString(inString: string, parserSpec: ParserSpec): QuantityParseResult;
     /** Method to generate a Quantity given a string that represents a quantity value and likely a unit label.

package/lib/esm/Parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Parser.d.ts","sourceRoot":"","sources":["../../src/Parser.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,OAAO,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,aAAa,EAAuB,kBAAkB,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACjK,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C;;GAEG;AACH,oBAAY,UAAU;IACpB,2BAA2B,IAAI;IAC/B,0BAA0B,IAAA;IAC1B,8BAA8B,IAAA;IAC9B,WAAW,IAAA;IACX,oCAAoC,IAAA;IACpC,iBAAiB,IAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,EAAE,EAAE,KAAK,CAAC;IACV,uDAAuD;IACvD,KAAK,EAAE,UAAU,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,uDAAuD;IACvD,EAAE,EAAE,IAAI,CAAC;IACT,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,kBAAkB,CAAC;AAEtE;;GAEG;AACH,cAAM,UAAU;IACP,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;gBAElB,KAAK,EAAE,MAAM,GAAG,MAAM;IAOlC,IAAW,QAAQ,IAAI,OAAO,CAA2C;IACzE,IAAW,QAAQ,IAAI,OAAO,CAA2C;CAC1E;AA+BD;;GAEG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAC,IAAI,CAAS;WAEd,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,IAAI,cAAc;WAInE,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,IAAI,kBAAkB;IAIjF,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAoBzC,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAyChC,OAAO,CAAC,MAAM,CAAC,OAAO;IAItB,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAIxC;;OAEG;WACW,0BAA0B,CAAC,qBAAqB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,EAAE;mBA6IhF,iBAAiB;mBA6BjB,6BAA6B;IAkElD;;;;OAIG;WACiB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,qBAAqB,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,aAAa,CAAC;IAQlL,2DAA2D;IAC3D,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAyCpC,OAAO,CAAC,MAAM,CAAC,+BAA+B;IAmE9C;;;;OAIG;WACW,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,mBAAmB;IAIhG;;;;OAIG;WACW,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,GAAG,mBAAmB;IA+BjI,+HAA+H;WAC3G,gCAAgC,CAAC,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,SAAS,EAAE,qBAAqB,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IA4B1L,+HAA+H;WAC3G,yBAAyB,CAAC,aAAa,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,EAAE,qBAAqB,CAAC,EAAE,2BAA2B,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;CAgDhO"}
+{"version":3,"file":"Parser.d.ts","sourceRoot":"","sources":["../../src/Parser.ts"],"names":[],"mappings":"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"}

package/lib/esm/Parser.js

@@ -19,18 +19,35 @@ export var ParseError;
     ParseError[ParseError["UnknownUnit"] = 4] = "UnknownUnit";
     ParseError[ParseError["UnableToConvertParseTokensToQuantity"] = 5] = "UnableToConvertParseTokensToQuantity";
     ParseError[ParseError["InvalidParserSpec"] = 6] = "InvalidParserSpec";
+    ParseError[ParseError["MathematicOperationFoundButIsNotAllowed"] = 7] = "MathematicOperationFoundButIsNotAllowed";
 })(ParseError || (ParseError = {}));
+var Operator;
+(function (Operator) {
+    Operator["addition"] = "+";
+    Operator["subtraction"] = "-";
+})(Operator || (Operator = {}));
+function isOperator(char) {
+    if (typeof char === "number") {
+        // Convert the charcode to string.
+        char = String.fromCharCode(char);
+    }
+    return Object.values(Operator).includes(char);
+}
 /** A ParseToken holds either a numeric or string token extracted from a string that represents a quantity value.
  * @beta
  */
 class ParseToken {
     constructor(value) {
-        if (typeof value === "string")
+        this.isOperator = false;
+        if (typeof value === "string") {
             this.value = value.trim();
-        else
+            this.isOperator = isOperator(this.value);
+        }
+        else {
             this.value = value;
+        }
     }
-    get isString() { return typeof this.value === "string"; }
+    get isString() { return !this.isOperator && typeof this.value === "string"; }
     get isNumber() { return typeof this.value === "number"; }
 }
 /** A ScientificToken holds an index and string representing the exponent.
@@ -137,6 +154,7 @@ export class Parser {
         let processingNumber = false;
         let wipToken = "";
         let signToken = "";
+        let isStationSeparatorAdded = false;
         let uomSeparatorToIgnore = 0;
         let fractionDashCode = 0;
         const skipCodes = [format.thousandSeparator.charCodeAt(0)];
@@ -222,9 +240,17 @@ export class Parser {
                             }
                         }
                     }
-                    // ignore any codes in skipCodes
-                    if (skipCodes.findIndex((ref) => ref === charCode) !== -1)
+                    if (format.type === FormatType.Station && charCode === format.stationSeparator.charCodeAt(0)) {
+                        if (!isStationSeparatorAdded) {
+                            isStationSeparatorAdded = true;
+                            continue;
+                        }
+                        isStationSeparatorAdded = false;
+                    }
+                    else if (skipCodes.findIndex((ref) => ref === charCode) !== -1) {
+                        // ignore any codes in skipCodes
                         continue;
+                    }
                     if (signToken.length > 0) {
                         wipToken = signToken + wipToken;
                         signToken = "";
@@ -232,12 +258,24 @@ export class Parser {
                     tokens.push(new ParseToken(parseFloat(wipToken)));
                     wipToken = (i < str.length) ? str[i] : "";
                     processingNumber = false;
+                    if (wipToken.length === 1 && isOperator(wipToken)) {
+                        tokens.push(new ParseToken(wipToken)); // Push operator token.
+                        wipToken = "";
+                    }
                 }
                 else {
                     // not processing a number
-                    if ((charCode === QuantityConstants.CHAR_PLUS || charCode === QuantityConstants.CHAR_MINUS)) {
-                        if (0 === tokens.length) // sign token only needed for left most value
-                            signToken = str[i];
+                    if (isOperator(charCode)) {
+                        if (wipToken.length > 0) {
+                            // There is a token is progress, process it now, before adding the new operator token.
+                            tokens.push(new ParseToken(wipToken));
+                            wipToken = "";
+                        }
+                        tokens.push(new ParseToken(str[i])); // Push an Operator Token in the list.
+                        continue;
+                    }
+                    if (wipToken.length === 0 && charCode === QuantityConstants.CHAR_SPACE) {
+                        // Dont add space when the wip token is empty.
                         continue;
                     }
                     wipToken = wipToken.concat(str[i]);
@@ -258,6 +296,17 @@ export class Parser {
         }
         return tokens;
     }
+    static isMathematicOperation(tokens) {
+        if (tokens.length > 1) {
+            // The loop starts at one because the first token can be a operator without it being maths. Ex: "-5FT"
+            for (let i = 1; i < tokens.length; i++) {
+                if (tokens[i].isOperator)
+                    // Operator found, it's a math operation.
+                    return true;
+            }
+        }
+        return false;
+    }
     static async lookupUnitByLabel(unitLabel, format, unitsProvider, altUnitLabelsProvider) {
         const defaultUnit = format.units && format.units.length > 0 ? format.units[0][0] : undefined;
         const labelToFind = unitLabel.toLowerCase();
@@ -282,69 +331,53 @@ export class Parser {
             foundUnit = await unitsProvider.findUnit(unitLabel, defaultUnit ? defaultUnit.phenomenon : undefined);
         return foundUnit;
     }
-    static async createQuantityFromParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider) {
-        let defaultUnit = format.units && format.units.length > 0 ? format.units[0][0] : undefined;
-        // common case where single value is supplied
-        if (tokens.length === 1) {
-            if (tokens[0].isNumber) {
-                return new Quantity(defaultUnit, tokens[0].value);
+    /**
+     * Get the output unit and all the conversion specs required to parse a given list of tokens.
+     */
+    static async getRequiredUnitsConversionsToParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider) {
+        let outUnit = (format.units && format.units.length > 0 ? format.units[0][0] : undefined);
+        const unitConversions = [];
+        const uniqueUnitLabels = [...new Set(tokens.filter((token) => token.isString).map((token) => token.value))];
+        for (const label of uniqueUnitLabels) {
+            const unitProps = await this.lookupUnitByLabel(label, format, unitsProvider, altUnitLabelsProvider);
+            if (!outUnit) {
+                // No default unit, assume that the first unit found is the desired output unit.
+                outUnit = unitProps;
             }
-            else {
-                const unit = await this.lookupUnitByLabel(tokens[0].value, format, unitsProvider, altUnitLabelsProvider);
-                return new Quantity(unit);
+            let spec = unitConversions.find((specB) => specB.name === unitProps.name);
+            if (spec) {
+                // Already in the list, just add the label.
+                spec.parseLabels?.push(label.toLocaleLowerCase());
             }
-        }
-        // common case where single value and single label are supplied
-        if (tokens.length === 2) {
-            // unit specification comes before value (like currency)
-            if (tokens[1].isNumber && tokens[0].isString) {
-                tokens = [tokens[1], tokens[0]];
-            }
-            if (tokens[0].isNumber && tokens[1].isString) {
-                const unit = await this.lookupUnitByLabel(tokens[1].value, format, unitsProvider, altUnitLabelsProvider);
-                if (undefined === defaultUnit)
-                    defaultUnit = unit;
-                if (defaultUnit && defaultUnit.name === unit.name) {
-                    return new Quantity(defaultUnit, tokens[0].value);
-                }
-                else if (defaultUnit) {
-                    const conversion = await unitsProvider.getConversion(unit, defaultUnit);
-                    const mag = ((tokens[0].value * conversion.factor)) + conversion.offset;
-                    return new Quantity(defaultUnit, mag);
+            else {
+                // Add new conversion to the list.
+                const conversion = await unitsProvider.getConversion(unitProps, outUnit);
+                if (conversion) {
+                    spec = {
+                        conversion,
+                        label: unitProps.label,
+                        system: unitProps.system,
+                        name: unitProps.name,
+                        parseLabels: [label.toLocaleLowerCase()],
+                    };
+                    unitConversions.push(spec);
                 }
             }
         }
-        // common case where there are multiple value/label pairs
-        if (tokens.length % 2 === 0) {
-            let mag = 0.0;
-            for (let i = 0; i < tokens.length; i = i + 2) {
-                if (tokens[i].isNumber && tokens[i + 1].isString) {
-                    const value = tokens[i].value;
-                    const unit = await this.lookupUnitByLabel(tokens[i + 1].value, format, unitsProvider, altUnitLabelsProvider);
-                    if (undefined === defaultUnit)
-                        defaultUnit = unit;
-                    if (0 === i) {
-                        if (defaultUnit.name === unit.name)
-                            mag = value;
-                        else {
-                            const conversion = await unitsProvider.getConversion(unit, defaultUnit);
-                            mag = ((value * conversion.factor)) + conversion.offset;
-                        }
-                    }
-                    else {
-                        if (defaultUnit) {
-                            const conversion = await unitsProvider.getConversion(unit, defaultUnit);
-                            if (mag < 0.0)
-                                mag = mag - ((value * conversion.factor)) + conversion.offset;
-                            else
-                                mag = mag + ((value * conversion.factor)) + conversion.offset;
-                        }
-                    }
-                }
+        return { outUnit, specs: unitConversions };
+    }
+    /**
+     * Get the units information asynchronously, then convert the tokens into quantity using the synchronous tokens -> value.
+     */
+    static async createQuantityFromParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider) {
+        const unitConversionInfos = await this.getRequiredUnitsConversionsToParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider);
+        if (unitConversionInfos.outUnit) {
+            const value = Parser.getQuantityValueFromParseTokens(tokens, format, unitConversionInfos.specs, await unitsProvider.getConversion(unitConversionInfos.outUnit, unitConversionInfos.outUnit));
+            if (value.ok) {
+                return new Quantity(unitConversionInfos.outUnit, value.value);
             }
-            return new Quantity(defaultUnit, mag);
         }
-        return new Quantity(defaultUnit);
+        return new Quantity();
     }
     /** Async method to generate a Quantity given a string that represents a quantity value and likely a unit label.
      *  @param inString A string that contains text represent a quantity.
@@ -353,7 +386,7 @@ export class Parser {
      */
     static async parseIntoQuantity(inString, format, unitsProvider, altUnitLabelsProvider) {
         const tokens = Parser.parseQuantitySpecification(inString, format);
-        if (tokens.length === 0)
+        if (tokens.length === 0 || (!format.allowMathematicOperations && Parser.isMathematicOperation(tokens)))
             return new Quantity();
         return Parser.createQuantityFromParseTokens(tokens, format, unitsProvider, altUnitLabelsProvider);
     }
@@ -396,75 +429,106 @@ export class Parser {
         }
         return undefined;
     }
-    static getQuantityValueFromParseTokens(tokens, format, unitsConversions) {
-        const defaultUnit = format.units && format.units.length > 0 ? format.units[0][0] : undefined;
-        // common case where single value is supplied
-        if (tokens.length === 1) {
-            if (tokens[0].isNumber) {
-                if (defaultUnit) {
-                    const conversion = Parser.tryFindUnitConversion(defaultUnit.label, unitsConversions, defaultUnit);
-                    if (conversion) {
-                        const value = tokens[0].value * conversion.factor + conversion.offset;
-                        return { ok: true, value };
-                    }
-                }
-                else {
-                    // if no conversion or no defaultUnit, just return parsed number
-                    return { ok: true, value: tokens[0].value };
-                }
+    /**
+     * Get what the unit conversion is for a unitless value.
+     */
+    static getDefaultUnitConversion(tokens, unitsConversions, defaultUnit) {
+        let unitConversion = defaultUnit ? Parser.tryFindUnitConversion(defaultUnit.label, unitsConversions, defaultUnit) : undefined;
+        if (!unitConversion) {
+            // No default unit conversion, take the first valid unit.
+            const uniqueUnitLabels = [...new Set(tokens.filter((token) => token.isString).map((token) => token.value))];
+            for (const label of uniqueUnitLabels) {
+                unitConversion = Parser.tryFindUnitConversion(label, unitsConversions, defaultUnit);
+                if (unitConversion !== undefined)
+                    return unitConversion;
+            }
+        }
+        return unitConversion;
+    }
+    // Get the next token pair to parse into a quantity.
+    static getNextTokenPair(index, tokens) {
+        if (index >= tokens.length)
+            return;
+        // 6 possible combination of token pair.
+        // Stringified to ease comparison later.
+        const validCombinations = [
+            JSON.stringify(["string"]), // ['FT']
+            JSON.stringify(["string", "number"]), // ['$', 5] unit specification comes before value (like currency)
+            JSON.stringify(["number"]), // [5]
+            JSON.stringify(["number", "string"]), // [5, 'FT']
+            JSON.stringify(["operator", "number"]), // ['-', 5]
+            JSON.stringify(["operator", "number", "string"]), // ['-', 5, 'FT']
+        ];
+        // Push up to 3 tokens in the list, if the length allows it.
+        const maxNbrTokensInThePair = Math.min(tokens.length - index, 3);
+        const tokenPair = tokens.slice(index, index + maxNbrTokensInThePair);
+        const currentCombination = tokenPair.map((token) => token.isOperator ? "operator" : (token.isNumber ? "number" : "string"));
+        // Check if the token pair is valid. If not, try again by removing the last token util empty.
+        // Ex: ['5', 'FT', '7'] invalid => ['5', 'FT'] valid returned
+        for (let i = currentCombination.length - 1; i >= 0; i--) {
+            if (validCombinations.includes(JSON.stringify(currentCombination))) {
+                break;
             }
             else {
-                // only the unit label was specified so assume magnitude of 1
-                const conversion = Parser.tryFindUnitConversion(tokens[0].value, unitsConversions, defaultUnit);
-                if (undefined !== conversion)
-                    return { ok: true, value: conversion.factor + conversion.offset };
-                else
-                    return { ok: false, error: ParseError.NoValueOrUnitFoundInString };
+                currentCombination.pop();
+                tokenPair.pop();
             }
         }
-        // common case where single value and single label are supplied
-        if (tokens.length === 2) {
+        return tokenPair.length > 0 ? tokenPair : undefined;
+    }
+    /**
+     * Accumulate the given list of tokens into a single quantity value. Formatting the tokens along the way.
+     */
+    static getQuantityValueFromParseTokens(tokens, format, unitsConversions, defaultUnitConversion) {
+        const defaultUnit = format.units && format.units.length > 0 ? format.units[0][0] : undefined;
+        defaultUnitConversion = defaultUnitConversion ? defaultUnitConversion : Parser.getDefaultUnitConversion(tokens, unitsConversions, defaultUnit);
+        let tokenPair;
+        let increment = 1;
+        let mag = 0.0;
+        // The sign is saved outside from the loop for cases like this. '-1m 50cm 10mm + 2m 30cm 40mm' => -1.51m + 2.34m
+        let sign = 1;
+        for (let i = 0; i < tokens.length; i = i + increment) {
+            tokenPair = this.getNextTokenPair(i, tokens);
+            if (!tokenPair || tokenPair.length === 0) {
+                return { ok: false, error: ParseError.UnableToConvertParseTokensToQuantity };
+            }
+            increment = tokenPair.length;
+            // Keep the sign so its applied to the next tokens.
+            if (tokenPair[0].isOperator) {
+                sign = tokenPair[0].value === Operator.addition ? 1 : -1;
+                tokenPair.shift();
+            }
             // unit specification comes before value (like currency)
-            if (tokens[1].isNumber && tokens[0].isString) {
-                tokens = [tokens[1], tokens[0]];
+            if (tokenPair.length === 2 && tokenPair[0].isString) {
+                // Invert it so the currency sign comes second.
+                tokenPair = [tokenPair[1], tokenPair[0]];
             }
-            if (tokens[0].isNumber && tokens[1].isString) {
-                let conversion = Parser.tryFindUnitConversion(tokens[1].value, unitsConversions, defaultUnit);
-                // if no conversion, ignore value in second token. If we have defaultUnit, use it.
-                if (!conversion && defaultUnit) {
-                    conversion = Parser.tryFindUnitConversion(defaultUnit.label, unitsConversions, defaultUnit);
+            if (tokenPair[0].isNumber) {
+                let value = sign * tokenPair[0].value;
+                let conversion;
+                if (tokenPair.length === 2 && tokenPair[1].isString) {
+                    conversion = Parser.tryFindUnitConversion(tokenPair[1].value, unitsConversions, defaultUnit);
                 }
+                conversion = conversion ? conversion : defaultUnitConversion;
                 if (conversion) {
-                    const value = tokens[0].value * conversion.factor + conversion.offset;
-                    return { ok: true, value };
+                    value = (value * conversion.factor) + conversion.offset;
                 }
-                // if no conversion, just return parsed number and ignore value in second token
-                return { ok: true, value: tokens[0].value };
+                mag = mag + value;
             }
-        }
-        // common case where there are multiple value/label pairs
-        if (tokens.length % 2 === 0) {
-            let mag = 0.0;
-            for (let i = 0; i < tokens.length; i = i + 2) {
-                if (tokens[i].isNumber && tokens[i + 1].isString) {
-                    const value = tokens[i].value;
-                    const conversion = Parser.tryFindUnitConversion(tokens[i + 1].value, unitsConversions, defaultUnit);
-                    if (conversion) {
-                        if (mag < 0.0)
-                            mag = mag - ((value * conversion.factor)) + conversion.offset;
-                        else
-                            mag = mag + ((value * conversion.factor)) + conversion.offset;
-                    }
+            else {
+                // only the unit label was specified so assume magnitude of 0
+                const conversion = Parser.tryFindUnitConversion(tokenPair[0].value, unitsConversions, defaultUnit);
+                if (conversion === undefined) {
+                    // Unknown unit label
+                    return { ok: false, error: ParseError.NoValueOrUnitFoundInString };
                 }
             }
-            return { ok: true, value: mag };
         }
-        return { ok: false, error: ParseError.UnableToConvertParseTokensToQuantity };
+        return { ok: true, value: mag };
     }
     /** Method to generate a Quantity given a string that represents a quantity value.
      *  @param inString A string that contains text represent a quantity.
      *  @param parserSpec unit label if not explicitly defined by user. Must have matching entry in supplied array of unitsConversions.
-     *  @param defaultValue default value to return if parsing is un successful
      */
     static parseQuantityString(inString, parserSpec) {
         return Parser.parseToQuantityValue(inString, parserSpec.format, parserSpec.unitConversions);
@@ -490,6 +554,9 @@ export class Parser {
         const tokens = Parser.parseQuantitySpecification(inString, format);
         if (tokens.length === 0)
             return { ok: false, error: ParseError.UnableToGenerateParseTokens };
+        if (!format.allowMathematicOperations && Parser.isMathematicOperation(tokens)) {
+            return { ok: false, error: ParseError.MathematicOperationFoundButIsNotAllowed };
+        }
         if (Parser._log) {
             // eslint-disable-next-line no-console
             console.log(`Parse tokens`);