@sme.up/ketchup 9.2.0 → 9.3.0

package/dist/collection/managers/kup-math/kup-math.js

@@ -15,399 +15,399 @@ const dom = document.documentElement;
  * @module KupMath
  */
 export class KupMath {
-  /**
-   * Initializes KupMath.
-   */
-  constructor(locale) {
-    this.formulas = {
-      custom(formula, row) {
-        return customFormula(formula, row);
-      },
-      normalDistribution(average, variance, x) {
-        return normalDistributionFormula(average, variance, x);
-      },
-    };
-    this.numbers = {
-      toLocaleString(value) {
-        const maximumFractionDigits = 14;
-        if (value == null || value == '')
-          return value;
-        return Number(value).toLocaleString(this.locale, {
-          maximumFractionDigits: maximumFractionDigits,
-        });
-      },
-    };
-    this.locale = locale ? locale : KupMathLocales.en;
-    this.managedComponents = new Set();
-    this.numeral = numeral;
-    this.numeral.locale(this.locale);
-  }
-  /**
-   * Sets the locale of the numeral instance. The locales available must be tied to the KupDates locales.
-   * @param {KupMathLocales} locale - Numeraljs locale string.
-   */
-  setLocale(locale) {
-    if (!Object.values(KupMathLocales).includes(locale)) {
-      locale = KupMathLocales.en;
-      dom.ketchup.debug.logMessage('kup-math', 'Invalid locale (' + locale + ')! Defaulting to english.', KupDebugCategory.WARNING);
-    }
-    this.locale = locale;
-    this.numeral.locale(locale);
-    this.managedComponents.forEach(function (comp) {
-      if (comp.isConnected) {
-        comp.refresh();
-      }
-    });
-    document.dispatchEvent(new CustomEvent('kup-math-localechange'));
-  }
-  /**
-   * Calculates the normal distribution on a set of values.
-   * @param {string[] | number[] | String[]} values - Array of values.
-   * @param {number} precision - Number of iterations to run (points). When not specified, defaults to 201.
-   * @returns {number[][]} Returns an array of arrays containing numbers, which are the representation of the calculated normal distribution.
-   */
-  normalDistribution(values, precision) {
-    if (!precision) {
-      precision = 201;
-    }
-    const data = [];
-    let max = Math.max.apply(Math, values);
-    let min = Math.min.apply(Math, values);
-    let average = 0;
-    let variance = 0;
-    for (let index = 0; index < values.length; index++) {
-      const value = values[index];
-      average += this.numberify(value);
-    }
-    average = average / values.length;
-    for (let index = 0; index < values.length; index++) {
-      const value = values[index];
-      variance += Math.pow(this.numberify(value) - average, 2);
-    }
-    variance = variance / values.length;
-    if (!variance) {
-      variance = 0.001;
-    }
-    max = max + ((average / 100) * 50 + (variance / average) * 3);
-    min = min - ((average / 100) * 50 + (variance / average) * 3);
-    for (let i = 0; i < precision; i++) {
-      const x = ((max - min) * i) / precision + min;
-      data.push([
-        x,
-        this.formulas.normalDistribution(average, variance, x),
-      ]);
-    }
-    return data;
-  }
-  /**
-   * Formats the input number with the specified format of the currently set locale.
-   * @param {string | String | number} input - Input number which will be automatically "numberified".
-   * @param {string} format - Desired format. Defaults to '0,0.00' (i.e.: 2,000,000.51).
-   * @param {boolean} inputIsLocalized Numberifies assuming the input string is in the current KupMath locale's format.
-   * @returns {string} Formatted number.
-   */
-  format(input, format, inputIsLocalized) {
-    const n = this.numberify(input, inputIsLocalized);
-    if (!format) {
-      const positiveN = Math.abs(n);
-      const decimals = positiveN - Math.floor(positiveN);
-      if (decimals) {
-        format = '0,0.00';
-      }
-      else {
-        format = '0,0';
-      }
-    }
-    return this.numeral(n).format(format);
-  }
-  /**
-   * Create the pattern string for format a number
-   * @param {boolean} thousandPoint - show thousandPoint
-   * @param {number} decimals - number of decimals
-   * @returns {string} - formatter pattern
-   */
-  createFormatPattern(thousandPoint, decimals) {
-    var format = '0';
-    if (thousandPoint) {
-      format += ',0';
-    }
-    if (decimals && decimals > 0) {
-      format += '.';
-      for (let i = 0; i < decimals; i++) {
-        format += '0';
-      }
-    }
-    return format;
-  }
-  /**
-   * Returns the decimal separator of current browser
-   * @returns {string} current decimal separator, by locale
-   */
-  decimalSeparator() {
-    const numberWithGroupAndDecimalSeparator = 1000.1;
-    return Intl.NumberFormat(this.locale)
-      .formatToParts(numberWithGroupAndDecimalSeparator)
-      .find((part) => part.type === 'decimal').value;
-  }
-  /**
-   * Returns the group separator of current browser
-   * @returns {string} current group separator, by locale
-   */
-  groupSeparator() {
-    const numberWithGroupAndDecimalSeparator = 1000.1;
-    return Intl.NumberFormat(this.locale)
-      .formatToParts(numberWithGroupAndDecimalSeparator)
-      .find((part) => part.type === 'group').value;
-  }
-  /**
-   * Checks if an input string matches options, for desired formatted decimal number (integer digits, decimal digits)
-   * @param {string} value the input value to check
-   * @param {NumericFieldFormatOptions} options options for customize the check
-   * @returns {RegExpMatchArray} an object from applying the regular expression for check
-   */
-  matchNumericValueWithOptions(value, options) {
-    value = value.replace(getRegExpFromString(this.groupSeparator(), 'g'), '');
-    // see https://github.com/24eme/jquery-input-number-format.git
-    let found = undefined;
-    let integerPartSuffix = '+';
-    if (options.integer && options.integer > 0) {
-      integerPartSuffix = '{0,' + options.integer + '}';
-    }
-    let regexp = '^[0-9]' + integerPartSuffix;
-    if (options.allowNegative) {
-      regexp = '^-{0,1}[0-9]' + integerPartSuffix;
+    /**
+     * Initializes KupMath.
+     */
+    constructor(locale) {
+        this.formulas = {
+            custom(formula, row) {
+                return customFormula(formula, row);
+            },
+            normalDistribution(average, variance, x) {
+                return normalDistributionFormula(average, variance, x);
+            },
+        };
+        this.numbers = {
+            toLocaleString(value) {
+                const maximumFractionDigits = 14;
+                if (value == null || value == '')
+                    return value;
+                return Number(value).toLocaleString(this.locale, {
+                    maximumFractionDigits: maximumFractionDigits,
+                });
+            },
+        };
+        this.locale = locale ? locale : KupMathLocales.en;
+        this.managedComponents = new Set();
+        this.numeral = numeral;
+        this.numeral.locale(this.locale);
     }
-    if (options.decimal && options.decimal > 0) {
-      regexp +=
-        '([' +
-          this.decimalSeparator() +
-          '][0-9]{0,' +
-          options.decimal +
-          '})?';
-      let regexpObj = new RegExp(regexp + '$');
-      found = value.match(regexpObj);
-      if (!found) {
-        regexp =
-          '^[' +
-            this.decimalSeparator() +
-            '][0-9]{0,' +
-            options.decimal +
-            '}';
-        regexpObj = new RegExp(regexp + '$');
-        found = value.match(regexpObj);
-      }
-    }
-    else {
-      let regexpObj = new RegExp(regexp + '$');
-      found = value.match(regexpObj);
-    }
-    return found;
-  }
-  /**
-   * Returns a number from a non-specified input type between string, number, or String.
-   * @param {string | String | number} input - Input value to numberify.
-   * @param {boolean} inputIsLocalized - Numberifies assuming the input string is in the current KupMath locale's format.
-   * @param {string} type - type of number for calculate suffix
-   * @param {string} decFmt - decimal format for the input value.
-   * @returns {number} Resulting number or NaN (when not a number).
-   */
-  numberify(input, inputIsLocalized, type, decFmt) {
-    if (typeof input != 'number') {
-      if (type) {
-        let suffix = this.getNumericValueSuffix(type);
-        if (suffix != '') {
-          input = input.replace(getRegExpFromString(suffix, 'g'), '');
+    /**
+     * Sets the locale of the numeral instance. The locales available must be tied to the KupDates locales.
+     * @param {KupMathLocales} locale - Numeraljs locale string.
+     */
+    setLocale(locale) {
+        if (!Object.values(KupMathLocales).includes(locale)) {
+            locale = KupMathLocales.en;
+            dom.ketchup.debug.logMessage('kup-math', 'Invalid locale (' + locale + ')! Defaulting to english.', KupDebugCategory.WARNING);
         }
-      }
-      if (!decFmt) {
-        decFmt = inputIsLocalized ? this.decimalSeparator() : '.';
-      }
-      const groupSeparator = decFmt == '.' ? ',' : '.';
-      input = input.replace(getRegExpFromString(groupSeparator, 'g'), '');
-      if (decFmt != '.') {
-        input = input.replace(getRegExpFromString(decFmt, 'g'), '.');
-      }
+        this.locale = locale;
+        this.numeral.locale(locale);
+        this.managedComponents.forEach(function (comp) {
+            if (comp.isConnected) {
+                comp.refresh();
+            }
+        });
+        document.dispatchEvent(new CustomEvent('kup-math-localechange'));
     }
-    let n = NaN;
-    const locale = this.numeral.locale();
-    this.numeral.locale(KupMathLocales.en);
-    n = this.numeral(input).value();
-    this.numeral.locale(locale);
-    if (n === null) {
-      return NaN;
+    /**
+     * Calculates the normal distribution on a set of values.
+     * @param {string[] | number[] | String[]} values - Array of values.
+     * @param {number} precision - Number of iterations to run (points). When not specified, defaults to 201.
+     * @returns {number[][]} Returns an array of arrays containing numbers, which are the representation of the calculated normal distribution.
+     */
+    normalDistribution(values, precision) {
+        if (!precision) {
+            precision = 201;
+        }
+        const data = [];
+        let max = Math.max.apply(Math, values);
+        let min = Math.min.apply(Math, values);
+        let average = 0;
+        let variance = 0;
+        for (let index = 0; index < values.length; index++) {
+            const value = values[index];
+            average += this.numberify(value);
+        }
+        average = average / values.length;
+        for (let index = 0; index < values.length; index++) {
+            const value = values[index];
+            variance += Math.pow(this.numberify(value) - average, 2);
+        }
+        variance = variance / values.length;
+        if (!variance) {
+            variance = 0.001;
+        }
+        max = max + ((average / 100) * 50 + (variance / average) * 3);
+        min = min - ((average / 100) * 50 + (variance / average) * 3);
+        for (let i = 0; i < precision; i++) {
+            const x = ((max - min) * i) / precision + min;
+            data.push([
+                x,
+                this.formulas.normalDistribution(average, variance, x),
+            ]);
+        }
+        return data;
     }
-    return n;
-  }
-  /**
-   * Returns a number from a non-specified input type between string, number, or String.
-   * If value in is null, undefined or blank, returns 0
-   * @param {string} input number as string, formatted by locale US, decimal separator . (like java decimal numbers)
-   * @param {boolean} inputIsLocalized - Numberifies assuming the input string is in the current KupMath locale's format.
-   * @param {string} type - type of number for calculate suffix
-   * @returns {number} Resulting number
-   **/
-  numberifySafe(input, inputIsLocalized, type, decFmt) {
-    if (!input || input == null || input.trim() == '') {
-      input = '0';
+    /**
+     * Formats the input number with the specified format of the currently set locale.
+     * @param {string | String | number} input - Input number which will be automatically "numberified".
+     * @param {string} format - Desired format. Defaults to '0,0.00' (i.e.: 2,000,000.51).
+     * @param {boolean} inputIsLocalized Numberifies assuming the input string is in the current KupMath locale's format.
+     * @returns {string} Formatted number.
+     */
+    format(input, format, inputIsLocalized) {
+        const n = this.numberify(input, inputIsLocalized);
+        if (!format) {
+            const positiveN = Math.abs(n);
+            const decimals = positiveN - Math.floor(positiveN);
+            if (decimals) {
+                format = '0,0.00';
+            }
+            else {
+                format = '0,0';
+            }
+        }
+        return this.numeral(n).format(format);
     }
-    return this.numberify(input, inputIsLocalized, type, decFmt);
-  }
-  /**
-   * Checks if input is a valid number
-   * @param {any} value input value to check
-   * @returns {boolean} if input value is valid number
-   */
-  isNumber(value) {
-    //return typeof value === 'number';
-    return !isNaN(value);
-  }
-  /**
-   * Checks if string in input is a valid formatted number
-   * @param {string} value number as string, formatted by actual browser locale
-   * @param {string} type - type of number for calculate suffix
-   * @returns {boolean} true if number string in input is a valid number
-   */
-  isStringNumber(value, type) {
-    if (value == null || value.trim() == '') {
-      return false;
+    /**
+     * Create the pattern string for format a number
+     * @param {boolean} thousandPoint - show thousandPoint
+     * @param {number} decimals - number of decimals
+     * @returns {string} - formatter pattern
+     */
+    createFormatPattern(thousandPoint, decimals) {
+        var format = '0';
+        if (thousandPoint) {
+            format += ',0';
+        }
+        if (decimals && decimals > 0) {
+            format += '.';
+            for (let i = 0; i < decimals; i++) {
+                format += '0';
+            }
+        }
+        return format;
     }
-    let tmpStr = this.formattedStringToNumberString(value, type);
-    if (this.isNumber(tmpStr)) {
-      return true;
+    /**
+     * Returns the decimal separator of current browser
+     * @returns {string} current decimal separator, by locale
+     */
+    decimalSeparator() {
+        const numberWithGroupAndDecimalSeparator = 1000.1;
+        return Intl.NumberFormat(this.locale)
+            .formatToParts(numberWithGroupAndDecimalSeparator)
+            .find((part) => part.type === 'decimal').value;
     }
-    return false;
-  }
-  /**
-   * Gets number as string, formatted by locale US, decimal separator . (like java decimal numbers)
-   * @param {string} input number as string, formatted by actual browser locale (maybe)
-   * @param {string} type - type of number for calculate suffix
-   * @param {string} decSeparator - decimal serparator of input string
-   * @returns {string} number as string, formatted by locale US, decimal separator . (like java decimal numbers), without group separator
-   **/
-  formattedStringToNumberString(input, type, decSeparator) {
-    return numberStringToNumberString(input, type, decSeparator, this);
-    function numberStringToNumberString(input, type, decFmt, kupMath) {
-      if (!input || input == null || input.trim() == '') {
-        return '';
-      }
-      let unf = kupMath.numberifySafe(input, !decFmt || decFmt != '.', type, decFmt);
-      if (unf == null || isNaN(unf)) {
-        return input;
-      }
-      return numberToString(unf, -1, 'en-US', kupMath);
+    /**
+     * Returns the group separator of current browser
+     * @returns {string} current group separator, by locale
+     */
+    groupSeparator() {
+        const numberWithGroupAndDecimalSeparator = 1000.1;
+        return Intl.NumberFormat(this.locale)
+            .formatToParts(numberWithGroupAndDecimalSeparator)
+            .find((part) => part.type === 'group').value;
     }
-    function numberToString(input, decimals, locale, kupMath) {
-      if (input == null) {
-        input = 0;
-      }
-      if (decimals == null || decimals == -1) {
-        decimals = kupMath.countDecimals(input);
-      }
-      let n = Number(input);
-      let f = decimals > -1
-        ? {
-          minimumFractionDigits: decimals,
-          maximumFractionDigits: decimals,
-          useGrouping: false,
+    /**
+     * Checks if an input string matches options, for desired formatted decimal number (integer digits, decimal digits)
+     * @param {string} value the input value to check
+     * @param {NumericFieldFormatOptions} options options for customize the check
+     * @returns {RegExpMatchArray} an object from applying the regular expression for check
+     */
+    matchNumericValueWithOptions(value, options) {
+        value = value.replace(getRegExpFromString(this.groupSeparator(), 'g'), '');
+        // see https://github.com/24eme/jquery-input-number-format.git
+        let found = undefined;
+        let integerPartSuffix = '+';
+        if (options.integer && options.integer > 0) {
+            integerPartSuffix = '{0,' + options.integer + '}';
         }
-        : { useGrouping: false };
-      return n.toLocaleString(locale, f);
+        let regexp = '^[0-9]' + integerPartSuffix;
+        if (options.allowNegative) {
+            regexp = '^-{0,1}[0-9]' + integerPartSuffix;
+        }
+        if (options.decimal && options.decimal > 0) {
+            regexp +=
+                '([' +
+                    this.decimalSeparator() +
+                    '][0-9]{0,' +
+                    options.decimal +
+                    '})?';
+            let regexpObj = new RegExp(regexp + '$');
+            found = value.match(regexpObj);
+            if (!found) {
+                regexp =
+                    '^[' +
+                        this.decimalSeparator() +
+                        '][0-9]{0,' +
+                        options.decimal +
+                        '}';
+                regexpObj = new RegExp(regexp + '$');
+                found = value.match(regexpObj);
+            }
+        }
+        else {
+            let regexpObj = new RegExp(regexp + '$');
+            found = value.match(regexpObj);
+        }
+        return found;
     }
-  }
-  /**
-   * Gets the number of decimals for current number
-   * @param {number} value numer input
-   * @returns {number} the number of decimals
-   */
-  countDecimals(value) {
-    var _a;
-    if (Math.floor(value) === value)
-      return 0;
-    let stringValue = value.toString().split('.')[1];
-    if (stringValue) {
-      return (_a = stringValue.length) !== null && _a !== void 0 ? _a : 0;
+    /**
+     * Returns a number from a non-specified input type between string, number, or String.
+     * @param {string | String | number} input - Input value to numberify.
+     * @param {boolean} inputIsLocalized - Numberifies assuming the input string is in the current KupMath locale's format.
+     * @param {string} type - type of number for calculate suffix
+     * @param {string} decFmt - decimal format for the input value.
+     * @returns {number} Resulting number or NaN (when not a number).
+     */
+    numberify(input, inputIsLocalized, type, decFmt) {
+        if (typeof input != 'number') {
+            if (type) {
+                let suffix = this.getNumericValueSuffix(type);
+                if (suffix != '') {
+                    input = input.replace(getRegExpFromString(suffix, 'g'), '');
+                }
+            }
+            if (!decFmt) {
+                decFmt = inputIsLocalized ? this.decimalSeparator() : '.';
+            }
+            const groupSeparator = decFmt == '.' ? ',' : '.';
+            input = input.replace(getRegExpFromString(groupSeparator, 'g'), '');
+            if (decFmt != '.') {
+                input = input.replace(getRegExpFromString(decFmt, 'g'), '.');
+            }
+        }
+        let n = NaN;
+        const locale = this.numeral.locale();
+        this.numeral.locale(KupMathLocales.en);
+        n = this.numeral(input).value();
+        this.numeral.locale(locale);
+        if (n === null) {
+            return NaN;
+        }
+        return n;
     }
-    else {
-      return 0;
+    /**
+     * Returns a number from a non-specified input type between string, number, or String.
+     * If value in is null, undefined or blank, returns 0
+     * @param {string} input number as string, formatted by locale US, decimal separator . (like java decimal numbers)
+     * @param {boolean} inputIsLocalized - Numberifies assuming the input string is in the current KupMath locale's format.
+     * @param {string} type - type of number for calculate suffix
+     * @returns {number} Resulting number
+     **/
+    numberifySafe(input, inputIsLocalized, type, decFmt) {
+        if (!input || input == null || input.trim() == '') {
+            input = '0';
+        }
+        return this.numberify(input, inputIsLocalized, type, decFmt);
     }
-  }
-  /**
-   * Gets the suffix for number, by type
-   * @param {string} type - type of number for calculate suffix
-   * @returns {string} suffix for number, by type
-   **/
-  getNumericValueSuffix(type) {
-    type = type.toUpperCase();
-    let nstr = '';
-    if (type == 'P') {
-      nstr = ' %';
+    /**
+     * Checks if input is a valid number
+     * @param {any} value input value to check
+     * @returns {boolean} if input value is valid number
+     */
+    isNumber(value) {
+        //return typeof value === 'number';
+        return !isNaN(value);
     }
-    else if (type == 'VE') {
-      nstr = ' €';
+    /**
+     * Checks if string in input is a valid formatted number
+     * @param {string} value number as string, formatted by actual browser locale
+     * @param {string} type - type of number for calculate suffix
+     * @returns {boolean} true if number string in input is a valid number
+     */
+    isStringNumber(value, type) {
+        if (value == null || value.trim() == '') {
+            return false;
+        }
+        let tmpStr = this.formattedStringToNumberString(value, type);
+        if (this.isNumber(tmpStr)) {
+            return true;
+        }
+        return false;
     }
-    else if (type == 'VL') {
-      nstr = ' £';
+    /**
+     * Gets number as string, formatted by locale US, decimal separator . (like java decimal numbers)
+     * @param {string} input number as string, formatted by actual browser locale (maybe)
+     * @param {string} type - type of number for calculate suffix
+     * @param {string} decSeparator - decimal serparator of input string
+     * @returns {string} number as string, formatted by locale US, decimal separator . (like java decimal numbers), without group separator
+     **/
+    formattedStringToNumberString(input, type, decSeparator) {
+        return numberStringToNumberString(input, type, decSeparator, this);
+        function numberStringToNumberString(input, type, decFmt, kupMath) {
+            if (!input || input == null || input.trim() == '') {
+                return '';
+            }
+            let unf = kupMath.numberifySafe(input, !decFmt || decFmt != '.', type, decFmt);
+            if (unf == null || isNaN(unf)) {
+                return input;
+            }
+            return numberToString(unf, -1, 'en-US', kupMath);
+        }
+        function numberToString(input, decimals, locale, kupMath) {
+            if (input == null) {
+                input = 0;
+            }
+            if (decimals == null || decimals == -1) {
+                decimals = kupMath.countDecimals(input);
+            }
+            let n = Number(input);
+            let f = decimals > -1
+                ? {
+                    minimumFractionDigits: decimals,
+                    maximumFractionDigits: decimals,
+                    useGrouping: false,
+                }
+                : { useGrouping: false };
+            return n.toLocaleString(locale, f);
+        }
     }
-    else if (type == 'VV') {
-      nstr = ' $';
+    /**
+     * Gets the number of decimals for current number
+     * @param {number} value numer input
+     * @returns {number} the number of decimals
+     */
+    countDecimals(value) {
+        var _a;
+        if (Math.floor(value) === value)
+            return 0;
+        let stringValue = value.toString().split('.')[1];
+        if (stringValue) {
+            return (_a = stringValue.length) !== null && _a !== void 0 ? _a : 0;
+        }
+        else {
+            return 0;
+        }
     }
-    return nstr;
-  }
-  /**
-   * Gets the number as string, formatted by actual browser locale, with suffix by type
-   * @param {number} input number
-   * @param {number} decimals number of significant decimal digits for output
-   * @param {string} type - type of number for calculate suffix
-   * @returns {string} number as string, formatted by actual browser locale, with suffix by type
-   **/
-  numberToFormattedString(input, decimals, type) {
-    if (input == null || isNaN(input)) {
-      return '';
+    /**
+     * Gets the suffix for number, by type
+     * @param {string} type - type of number for calculate suffix
+     * @returns {string} suffix for number, by type
+     **/
+    getNumericValueSuffix(type) {
+        type = type.toUpperCase();
+        let nstr = '';
+        if (type == 'P') {
+            nstr = ' %';
+        }
+        else if (type == 'VE') {
+            nstr = ' €';
+        }
+        else if (type == 'VL') {
+            nstr = ' £';
+        }
+        else if (type == 'VV') {
+            nstr = ' $';
+        }
+        return nstr;
     }
-    if (decimals == null || decimals == -1) {
-      decimals = this.countDecimals(input);
+    /**
+     * Gets the number as string, formatted by actual browser locale, with suffix by type
+     * @param {number} input number
+     * @param {number} decimals number of significant decimal digits for output
+     * @param {string} type - type of number for calculate suffix
+     * @returns {string} number as string, formatted by actual browser locale, with suffix by type
+     **/
+    numberToFormattedString(input, decimals, type) {
+        if (input == null || isNaN(input)) {
+            return '';
+        }
+        if (decimals == null || decimals == -1) {
+            decimals = this.countDecimals(input);
+        }
+        let nstr = this.format(input, this.createFormatPattern(true, decimals));
+        nstr = nstr + this.getNumericValueSuffix(type);
+        return nstr;
     }
-    let nstr = this.format(input, this.createFormatPattern(true, decimals));
-    nstr = nstr + this.getNumericValueSuffix(type);
-    return nstr;
-  }
-  /**
-   * Gets the number as string, formatted by actual browser locale, with suffix by type
-   * @param {string} input number as string, formatted by locale US, decimal separator . (like java decimal numbers)
-   * @param {number} decimals number of significant decimal digits for output
-   * @param {string} type - type of number for calculate suffix
-   * @param {string} decSeparator decimal separator for output string
-   * @returns {string} number as string, formatted by actual browser locale (or using decimal separator param), with suffix by type
-   **/
-  numberStringToFormattedString(input, decimals, type, decSeparator) {
-    let value = this.numberToFormattedString(this.numberifySafe(input), decimals, type);
-    if (!decSeparator) {
-      return value;
+    /**
+     * Gets the number as string, formatted by actual browser locale, with suffix by type
+     * @param {string} input number as string, formatted by locale US, decimal separator . (like java decimal numbers)
+     * @param {number} decimals number of significant decimal digits for output
+     * @param {string} type - type of number for calculate suffix
+     * @param {string} decSeparator decimal separator for output string
+     * @returns {string} number as string, formatted by actual browser locale (or using decimal separator param), with suffix by type
+     **/
+    numberStringToFormattedString(input, decimals, type, decSeparator) {
+        let value = this.numberToFormattedString(this.numberifySafe(input), decimals, type);
+        if (!decSeparator) {
+            return value;
+        }
+        const browserDecSeparator = this.decimalSeparator();
+        if (browserDecSeparator == decSeparator) {
+            return value;
+        }
+        const browserGroupSeparator = this.groupSeparator();
+        value = value.replace(getRegExpFromString(browserGroupSeparator, 'g'), '');
+        value = value.replace(getRegExpFromString(browserDecSeparator, 'g'), decSeparator);
+        return value;
     }
-    const browserDecSeparator = this.decimalSeparator();
-    if (browserDecSeparator == decSeparator) {
-      return value;
+    /**
+     * Registers a KupComponent in KupMath, in order to be properly handled whenever the locale changes.
+     * @param {any} component - The Ketchup component to be registered.
+     */
+    register(component) {
+        this.managedComponents.add(component.rootElement ? component.rootElement : component);
     }
-    const browserGroupSeparator = this.groupSeparator();
-    value = value.replace(getRegExpFromString(browserGroupSeparator, 'g'), '');
-    value = value.replace(getRegExpFromString(browserDecSeparator, 'g'), decSeparator);
-    return value;
-  }
-  /**
-   * Registers a KupComponent in KupMath, in order to be properly handled whenever the locale changes.
-   * @param {any} component - The Ketchup component to be registered.
-   */
-  register(component) {
-    this.managedComponents.add(component.rootElement ? component.rootElement : component);
-  }
-  /**
-   * Unregisters a KupComponent, so it won't be refreshed when the locale changes.
-   *
-   * @param {any} component - The component calling this function.
-   */
-  unregister(component) {
-    if (this.managedComponents) {
-      this.managedComponents.delete(component.rootElement ? component.rootElement : component);
+    /**
+     * Unregisters a KupComponent, so it won't be refreshed when the locale changes.
+     *
+     * @param {any} component - The component calling this function.
+     */
+    unregister(component) {
+        if (this.managedComponents) {
+            this.managedComponents.delete(component.rootElement ? component.rootElement : component);
+        }
     }
-  }
 }