@sankhyalabs/core 1.0.42 → 1.0.45

package/dist/utils/MaskFormatter.js

@@ -1,276 +1,276 @@
-/**
- * `MaskFormatter` é usado para formatar strings. Seu comportamento
- * é controlado pela formato do atributo `mask` que especifica quais
- * caracteres são válidos e onde devem estar posicionados, intercalando-os
- * com eventuais caracteres literais expressados no padrão informado.
- * Sua implementação é inspirada pela implementação em Java do [MaskFormatter](https://docs.oracle.com/javase/7/docs/api/javax/swing/text/MaskFormatter.html).
- *
- * Para o padrão da máscara podem ser usados os seguintes caracteres especiais:
- *
- * | Caractere | Comportamento                                                                                               |
- * |:---------:|-------------------------------------------------------------------------------------------------------------|
- * | #         | Qualquer número                                                                                             |
- * | '         | "Escapa" o caractere que vem na sequência. Útil quando desejamos converter um caractere especial em literal.|
- * | U         | Qualquer letra. Transforma letras maiúsculas em maiúsculas.                                                 |
- * | L         | Qualquer letra. Transforma letras maiúsculas em minúsculas.                                                 |
- * | A         | Qualquer letra ou número.                                                                                   |
- * | ?         | Qualquer letra. Preserva maiúsculas e minúsculas.                                                           |
- * | *         | Qualquer caractere.                                                                                         |
- *
- * Os demais caracteres presentes no padrão serão tratados como literais, isto é,
- * serão apenas inseridos naquela posição.
- *
- * Quando o o valor a ser formatado é menor que a máscara um 'placeHolder'
- * será inserido em cada posição ausente, completando a formatação.
- * Por padrão será usado um espaço em branco como 'placeHolder' mas
- * esse valor pode ser alterado.
- *
- * For por exemplo:
- * '''
- *    const formatter: MaskFormatter = new MaskFormatter("###-####");
- *    formatter.placeholder = '_';
- *    console.log(formatter.format("123"));
- * '''
- * resultaria na string '123-____'.
- *
- * ##Veja mais alguns exemplos:
- * |Padrão          |Máscara           |Entrada       |Saída             |
- * |----------------|------------------|--------------|------------------|
- * |Telefone        |(##) ####-####    |3432192515    |(34) 3219-2515    |
- * |CPF             |###.###.###-##    |12345678901   |123.456.789-01    |
- * |CNPJ            |##.###.###/####-##|12345678901234|12.345.678/9012-34|
- * |CEP             |##.###-###        |12345678      |12.345-678        |
- * |PLACA (veículo) |UUU-####          |abc1234       |ABC-1234          |
- * |Cor RGB         |'#AAAAAA          |00000F0       |#0000F0           |
- *
- */
-export class MaskFormatter {
-    constructor(mask) {
-        this._mask = '';
-        this._maskChars = new Array();
-        /**
-         * Determina qual caractere será usado dos caracteres não presentes no valor
-         * ou seja, aqueles que o usuário ainda não informou. Por padrão usamos um espaço
-         */
-        this.placeholder = ' ';
-        this.mask = mask;
-    }
-    /**
-     * Setter para mask. Trata-se do padrão que se espera ao formatar o texto.
-     */
-    set mask(mask) {
-        this._mask = mask;
-        this.updateInternalMask();
-    }
-    /**
-     * Getter para mask
-     *
-     * @return A última máscara informada.
-     */
-    get mask() {
-        return this._mask;
-    }
-    /**
-     * Formata a string passada baseada na máscara definda pelo atributo mask.
-     *
-     * @param value Valor a ser formatado
-     * @return O valor processado de acordo com o padrão
-     */
-    format(value) {
-        let result = '';
-        const index = [0];
-        let counter = 0;
-        const maxCounter = this._maskChars.length;
-        while (counter < maxCounter) {
-            result = this._maskChars[counter].append(result, value, index);
-            counter++;
-        }
-        return result;
-    }
-    /**
-     * Preparamos a formatação internamente de acordo com o padrão.
-     */
-    updateInternalMask() {
-        this._maskChars.length = 0;
-        if (this.mask != null) {
-            let counter = 0;
-            const maxCounter = this.mask.length;
-            while (counter < maxCounter) {
-                let maskChar = this.mask.charAt(counter);
-                switch (maskChar) {
-                    case MaskFormatter.DIGIT_KEY:
-                        this._maskChars.push(new MaskFormatter.DigitMaskCharacter(this, maskChar));
-                        break;
-                    case MaskFormatter.LITERAL_KEY:
-                        if (++counter < maxCounter) {
-                            maskChar = this.mask.charAt(counter);
-                            this._maskChars.push(new MaskFormatter.LiteralCharacter(this, maskChar));
-                        }
-                        break;
-                    case MaskFormatter.UPPERCASE_KEY:
-                        this._maskChars.push(new MaskFormatter.UpperCaseCharacter(this, maskChar));
-                        break;
-                    case MaskFormatter.LOWERCASE_KEY:
-                        this._maskChars.push(new MaskFormatter.LowerCaseCharacter(this, maskChar));
-                        break;
-                    case MaskFormatter.ALPHA_NUMERIC_KEY:
-                        this._maskChars.push(new MaskFormatter.AlphaNumericCharacter(this, maskChar));
-                        break;
-                    case MaskFormatter.CHARACTER_KEY:
-                        this._maskChars.push(new MaskFormatter.CharCharacter(this, maskChar));
-                        break;
-                    case MaskFormatter.ANYTHING_KEY:
-                        this._maskChars.push(new MaskFormatter.MaskCharacter(this, maskChar));
-                        break;
-                    default:
-                        this._maskChars.push(new MaskFormatter.LiteralCharacter(this, maskChar));
-                        break;
-                }
-                counter++;
-            }
-        }
-    }
-}
-MaskFormatter.DIGIT_KEY = "#";
-MaskFormatter.LITERAL_KEY = "'";
-MaskFormatter.UPPERCASE_KEY = "U";
-MaskFormatter.LOWERCASE_KEY = "L";
-MaskFormatter.ALPHA_NUMERIC_KEY = "A";
-MaskFormatter.CHARACTER_KEY = "?";
-MaskFormatter.ANYTHING_KEY = "*";
-//
-// Classes internas usadas para representar a máscara.
-//
-MaskFormatter.MaskCharacter = class {
-    constructor(maskFormatter, type) {
-        this.maskFormatter = maskFormatter;
-        this.type = type;
-    }
-    /**
-     * Cada subclasse deve sobrescrever o retornando true, caso represente
-     * um caractere literal. Por padrão o retorno é false.
-     */
-    isLiteral() {
-        return false;
-    }
-    /**
-     * Returns true if <code>aChar</code> is a valid reprensentation of
-     * the receiver. The default implementation returns true if the
-     * receiver represents a literal character and <code>getChar</code>
-     * == aChar. Otherwise, this will return true is <code>aChar</code>
-     * is contained in the valid characters and not contained
-     * in the invalid characters.
-     */
-    isValidCharacter(aChar) {
-        if (this.isLiteral()) {
-            return (this.getChar(aChar) == aChar);
-        }
-        aChar = this.getChar(aChar);
-        return true;
-    }
-    /**
-     * Returns the character to insert for <code>aChar</code>. The
-     * default implementation returns <code>aChar</code>. Subclasses
-     * that wish to do some sort of mapping, perhaps lower case to upper
-     * case should override this and do the necessary mapping.
-     */
-    getChar(aChar) {
-        return aChar;
-    }
-    /**
-     * Appends the necessary character in <code>formatting</code> at
-     * <code>index</code> to <code>buff</code>.
-     */
-    append(result, formatting, index) {
-        const inString = index[0] < formatting.length;
-        const aChar = inString ? formatting.charAt(index[0]) : '';
-        if (this.isLiteral()) {
-            const literal = this.getChar(aChar);
-            result += literal;
-            if (literal === aChar) {
-                index[0] = index[0] + 1;
-            }
-        }
-        else if (index[0] >= formatting.length) {
-            result += this.maskFormatter.placeholder;
-            index[0] = index[0] + 1;
-        }
-        else if (this.isValidCharacter(aChar)) {
-            result += this.getChar(aChar);
-            index[0] = index[0] + 1;
-        }
-        else {
-            throw new Error(`Valor inválido: "${aChar}". Na posição ${index[0] + 1} espera-se ${this.getFormatMessage()}.`);
-        }
-        return result;
-    }
-    getFormatMessage() {
-        let message;
-        switch (this.type) {
-            case MaskFormatter.UPPERCASE_KEY:
-            case MaskFormatter.LOWERCASE_KEY:
-            case MaskFormatter.CHARACTER_KEY:
-                message = 'uma letra';
-                break;
-            case MaskFormatter.DIGIT_KEY:
-                message = 'um número';
-                break;
-            case MaskFormatter.ALPHA_NUMERIC_KEY:
-                message = 'uma letra ou um número';
-                break;
-            default:
-                message = '';
-        }
-        return message;
-    }
-};
-MaskFormatter.LiteralCharacter = class extends MaskFormatter.MaskCharacter {
-    constructor(maskFormatter, fixedChar) {
-        super(maskFormatter, fixedChar);
-        this._fixedChar = fixedChar;
-    }
-    isLiteral() {
-        return true;
-    }
-    getChar(aChar) {
-        aChar;
-        return this._fixedChar;
-    }
-};
-MaskFormatter.DigitMaskCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        return (this.isDigit(aChar) && super.isValidCharacter(aChar));
-    }
-    isDigit(char) {
-        return char >= '0' && char <= '9';
-    }
-};
-MaskFormatter.UpperCaseCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
-    }
-    getChar(aChar) {
-        return aChar.toUpperCase();
-    }
-};
-MaskFormatter.LowerCaseCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
-    }
-    getChar(aChar) {
-        return aChar.toLocaleLowerCase();
-    }
-};
-MaskFormatter.AlphaNumericCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
-        return (/[a-z0-9]/i.test(aChar)) && super.isValidCharacter(aChar);
-    }
-};
-MaskFormatter.CharCharacter = class extends MaskFormatter.MaskCharacter {
-    isValidCharacter(aChar) {
-        //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
-        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
-    }
-};
+/**
+ * `MaskFormatter` é usado para formatar strings. Seu comportamento
+ * é controlado pela formato do atributo `mask` que especifica quais
+ * caracteres são válidos e onde devem estar posicionados, intercalando-os
+ * com eventuais caracteres literais expressados no padrão informado.
+ * Sua implementação é inspirada pela implementação em Java do [MaskFormatter](https://docs.oracle.com/javase/7/docs/api/javax/swing/text/MaskFormatter.html).
+ *
+ * Para o padrão da máscara podem ser usados os seguintes caracteres especiais:
+ *
+ * | Caractere | Comportamento                                                                                               |
+ * |:---------:|-------------------------------------------------------------------------------------------------------------|
+ * | #         | Qualquer número                                                                                             |
+ * | '         | "Escapa" o caractere que vem na sequência. Útil quando desejamos converter um caractere especial em literal.|
+ * | U         | Qualquer letra. Transforma letras maiúsculas em maiúsculas.                                                 |
+ * | L         | Qualquer letra. Transforma letras maiúsculas em minúsculas.                                                 |
+ * | A         | Qualquer letra ou número.                                                                                   |
+ * | ?         | Qualquer letra. Preserva maiúsculas e minúsculas.                                                           |
+ * | *         | Qualquer caractere.                                                                                         |
+ *
+ * Os demais caracteres presentes no padrão serão tratados como literais, isto é,
+ * serão apenas inseridos naquela posição.
+ *
+ * Quando o o valor a ser formatado é menor que a máscara um 'placeHolder'
+ * será inserido em cada posição ausente, completando a formatação.
+ * Por padrão será usado um espaço em branco como 'placeHolder' mas
+ * esse valor pode ser alterado.
+ *
+ * For por exemplo:
+ * '''
+ *    const formatter: MaskFormatter = new MaskFormatter("###-####");
+ *    formatter.placeholder = '_';
+ *    console.log(formatter.format("123"));
+ * '''
+ * resultaria na string '123-____'.
+ *
+ * ##Veja mais alguns exemplos:
+ * |Padrão          |Máscara           |Entrada       |Saída             |
+ * |----------------|------------------|--------------|------------------|
+ * |Telefone        |(##) ####-####    |3432192515    |(34) 3219-2515    |
+ * |CPF             |###.###.###-##    |12345678901   |123.456.789-01    |
+ * |CNPJ            |##.###.###/####-##|12345678901234|12.345.678/9012-34|
+ * |CEP             |##.###-###        |12345678      |12.345-678        |
+ * |PLACA (veículo) |UUU-####          |abc1234       |ABC-1234          |
+ * |Cor RGB         |'#AAAAAA          |00000F0       |#0000F0           |
+ *
+ */
+export class MaskFormatter {
+    constructor(mask) {
+        this._mask = '';
+        this._maskChars = new Array();
+        /**
+         * Determina qual caractere será usado dos caracteres não presentes no valor
+         * ou seja, aqueles que o usuário ainda não informou. Por padrão usamos um espaço
+         */
+        this.placeholder = ' ';
+        this.mask = mask;
+    }
+    /**
+     * Setter para mask. Trata-se do padrão que se espera ao formatar o texto.
+     */
+    set mask(mask) {
+        this._mask = mask;
+        this.updateInternalMask();
+    }
+    /**
+     * Getter para mask
+     *
+     * @return A última máscara informada.
+     */
+    get mask() {
+        return this._mask;
+    }
+    /**
+     * Formata a string passada baseada na máscara definda pelo atributo mask.
+     *
+     * @param value Valor a ser formatado
+     * @return O valor processado de acordo com o padrão
+     */
+    format(value) {
+        let result = '';
+        const index = [0];
+        let counter = 0;
+        const maxCounter = this._maskChars.length;
+        while (counter < maxCounter) {
+            result = this._maskChars[counter].append(result, value, index);
+            counter++;
+        }
+        return result;
+    }
+    /**
+     * Preparamos a formatação internamente de acordo com o padrão.
+     */
+    updateInternalMask() {
+        this._maskChars.length = 0;
+        if (this.mask != null) {
+            let counter = 0;
+            const maxCounter = this.mask.length;
+            while (counter < maxCounter) {
+                let maskChar = this.mask.charAt(counter);
+                switch (maskChar) {
+                    case MaskFormatter.DIGIT_KEY:
+                        this._maskChars.push(new MaskFormatter.DigitMaskCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.LITERAL_KEY:
+                        if (++counter < maxCounter) {
+                            maskChar = this.mask.charAt(counter);
+                            this._maskChars.push(new MaskFormatter.LiteralCharacter(this, maskChar));
+                        }
+                        break;
+                    case MaskFormatter.UPPERCASE_KEY:
+                        this._maskChars.push(new MaskFormatter.UpperCaseCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.LOWERCASE_KEY:
+                        this._maskChars.push(new MaskFormatter.LowerCaseCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.ALPHA_NUMERIC_KEY:
+                        this._maskChars.push(new MaskFormatter.AlphaNumericCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.CHARACTER_KEY:
+                        this._maskChars.push(new MaskFormatter.CharCharacter(this, maskChar));
+                        break;
+                    case MaskFormatter.ANYTHING_KEY:
+                        this._maskChars.push(new MaskFormatter.MaskCharacter(this, maskChar));
+                        break;
+                    default:
+                        this._maskChars.push(new MaskFormatter.LiteralCharacter(this, maskChar));
+                        break;
+                }
+                counter++;
+            }
+        }
+    }
+}
+MaskFormatter.DIGIT_KEY = "#";
+MaskFormatter.LITERAL_KEY = "'";
+MaskFormatter.UPPERCASE_KEY = "U";
+MaskFormatter.LOWERCASE_KEY = "L";
+MaskFormatter.ALPHA_NUMERIC_KEY = "A";
+MaskFormatter.CHARACTER_KEY = "?";
+MaskFormatter.ANYTHING_KEY = "*";
+//
+// Classes internas usadas para representar a máscara.
+//
+MaskFormatter.MaskCharacter = class {
+    constructor(maskFormatter, type) {
+        this.maskFormatter = maskFormatter;
+        this.type = type;
+    }
+    /**
+     * Cada subclasse deve sobrescrever o retornando true, caso represente
+     * um caractere literal. Por padrão o retorno é false.
+     */
+    isLiteral() {
+        return false;
+    }
+    /**
+     * Returns true if <code>aChar</code> is a valid reprensentation of
+     * the receiver. The default implementation returns true if the
+     * receiver represents a literal character and <code>getChar</code>
+     * == aChar. Otherwise, this will return true is <code>aChar</code>
+     * is contained in the valid characters and not contained
+     * in the invalid characters.
+     */
+    isValidCharacter(aChar) {
+        if (this.isLiteral()) {
+            return (this.getChar(aChar) == aChar);
+        }
+        aChar = this.getChar(aChar);
+        return true;
+    }
+    /**
+     * Returns the character to insert for <code>aChar</code>. The
+     * default implementation returns <code>aChar</code>. Subclasses
+     * that wish to do some sort of mapping, perhaps lower case to upper
+     * case should override this and do the necessary mapping.
+     */
+    getChar(aChar) {
+        return aChar;
+    }
+    /**
+     * Appends the necessary character in <code>formatting</code> at
+     * <code>index</code> to <code>buff</code>.
+     */
+    append(result, formatting, index) {
+        const inString = index[0] < formatting.length;
+        const aChar = inString ? formatting.charAt(index[0]) : '';
+        if (this.isLiteral()) {
+            const literal = this.getChar(aChar);
+            result += literal;
+            if (literal === aChar) {
+                index[0] = index[0] + 1;
+            }
+        }
+        else if (index[0] >= formatting.length) {
+            result += this.maskFormatter.placeholder;
+            index[0] = index[0] + 1;
+        }
+        else if (this.isValidCharacter(aChar)) {
+            result += this.getChar(aChar);
+            index[0] = index[0] + 1;
+        }
+        else {
+            throw new Error(`Valor inválido: "${aChar}". Na posição ${index[0] + 1} espera-se ${this.getFormatMessage()}.`);
+        }
+        return result;
+    }
+    getFormatMessage() {
+        let message;
+        switch (this.type) {
+            case MaskFormatter.UPPERCASE_KEY:
+            case MaskFormatter.LOWERCASE_KEY:
+            case MaskFormatter.CHARACTER_KEY:
+                message = 'uma letra';
+                break;
+            case MaskFormatter.DIGIT_KEY:
+                message = 'um número';
+                break;
+            case MaskFormatter.ALPHA_NUMERIC_KEY:
+                message = 'uma letra ou um número';
+                break;
+            default:
+                message = '';
+        }
+        return message;
+    }
+};
+MaskFormatter.LiteralCharacter = class extends MaskFormatter.MaskCharacter {
+    constructor(maskFormatter, fixedChar) {
+        super(maskFormatter, fixedChar);
+        this._fixedChar = fixedChar;
+    }
+    isLiteral() {
+        return true;
+    }
+    getChar(aChar) {
+        aChar;
+        return this._fixedChar;
+    }
+};
+MaskFormatter.DigitMaskCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        return (this.isDigit(aChar) && super.isValidCharacter(aChar));
+    }
+    isDigit(char) {
+        return char >= '0' && char <= '9';
+    }
+};
+MaskFormatter.UpperCaseCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+    }
+    getChar(aChar) {
+        return aChar.toUpperCase();
+    }
+};
+MaskFormatter.LowerCaseCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+    }
+    getChar(aChar) {
+        return aChar.toLocaleLowerCase();
+    }
+};
+MaskFormatter.AlphaNumericCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
+        return (/[a-z0-9]/i.test(aChar)) && super.isValidCharacter(aChar);
+    }
+};
+MaskFormatter.CharCharacter = class extends MaskFormatter.MaskCharacter {
+    isValidCharacter(aChar) {
+        //FIXME: talvez seja problema usar regex aqui... avaliar se existe forma mais barata
+        return (/[a-z]/i.test(aChar) && super.isValidCharacter(aChar));
+    }
+};
 //# sourceMappingURL=MaskFormatter.js.map

package/dist/utils/NumberUtils.d.ts

@@ -1,53 +1,53 @@
-/**
- * `NumberUtils` é uma biblioteca para manipulação de números
- *
- * `Métodos`:
- *
- * @stringToNumber: converte um número em formato de string em um valor numérico nativo do javascript
- * @format: arredonda um número em formato de string baseado nos parâmetros "presision" e "prettyPrecision";
- */
-export declare class NumberUtils {
-    /**
-    * @stringToNumber: converte um numero em formato de string em numero
-    *
-    * @param value numero em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico: ######.##)
-    *
-    * @returns string based number
-    *
-    * @Exemples
-    * @"100,12"     |       100.12
-    * @"100.12"     |       100.12
-    * @"-100,12"    |       -100.12
-    * @"R$100,12"   |       100.12
-    * @"-R$100,12"  |       -100.12
-    * @"string"     |       NaN
-    */
-    static stringToNumber: (value: string) => number;
-    /**
-    * @format: converte um numero em formato de string em um numero em formato de string formatado de acordo com os parametros de "precision" e "prettyPrecision"
-    *
-    * @param value numero em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico<sem separadors de milhares>: ######.##)
-    * @param precision (numero de decimais)
-    * @param prettyPrecision (numero de zeros nos decimais)
-    *
-    * @returns numero em formato de string formatado em PT-BR
-    */
-    static format: (value: string, precision: number, prettyPrecision?: number) => string;
-    /**
-    * @keepOnlyDecimalSeparator: retira os separadores de milhar de um número em formato de string
-    *
-    * @param value numero em formato de string a ser convertido
-    * @param formatnumber (formatação de ENTRADA e SAÍDA do utilitário: pt-BR="###.###,##" en-US="###,###.##"; Default: "pt-BR")
-    *
-    * @returns numero em formato de string formatado apenas com separador decimal
-    */
-    static keepOnlyDecimalSeparator: (value: string, formatnumber?: string) => string;
-    /**
-    * @changeFormat: troca o formato do numero string de "PT-BR" para "EN-US" e vice-versa
-    *
-    * @param value numero em formato de string a ser convertido
-    *
-    * @returns numero em formato de string formatado de "PT-BR" para "EN-US" e vice-versa
-    */
-    static changeFormat: (value: string) => string;
-}
+/**
+ * `NumberUtils` é uma biblioteca para manipulação de números
+ *
+ * `Métodos`:
+ *
+ * @stringToNumber: converte um número em formato de string em um valor numérico nativo do javascript
+ * @format: arredonda um número em formato de string baseado nos parâmetros "presision" e "prettyPrecision";
+ */
+export declare class NumberUtils {
+    /**
+    * @stringToNumber: converte um numero em formato de string em numero
+    *
+    * @param value numero em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico: ######.##)
+    *
+    * @returns string based number
+    *
+    * @Exemples
+    * @"100,12"     |       100.12
+    * @"100.12"     |       100.12
+    * @"-100,12"    |       -100.12
+    * @"R$100,12"   |       100.12
+    * @"-R$100,12"  |       -100.12
+    * @"string"     |       NaN
+    */
+    static stringToNumber: (value: string) => number;
+    /**
+    * @format: converte um numero em formato de string em um numero em formato de string formatado de acordo com os parametros de "precision" e "prettyPrecision"
+    *
+    * @param value numero em formato de string a ser convertido (Importante: formato PT-BR ou já em formato numérico<sem separadors de milhares>: ######.##)
+    * @param precision (numero de decimais)
+    * @param prettyPrecision (numero de zeros nos decimais)
+    *
+    * @returns numero em formato de string formatado em PT-BR
+    */
+    static format: (value: string, precision: number, prettyPrecision?: number) => string;
+    /**
+    * @keepOnlyDecimalSeparator: retira os separadores de milhar de um número em formato de string
+    *
+    * @param value numero em formato de string a ser convertido
+    * @param formatnumber (formatação de ENTRADA e SAÍDA do utilitário: pt-BR="###.###,##" en-US="###,###.##"; Default: "pt-BR")
+    *
+    * @returns numero em formato de string formatado apenas com separador decimal
+    */
+    static keepOnlyDecimalSeparator: (value: string, formatnumber?: string) => string;
+    /**
+    * @changeFormat: troca o formato do numero string de "PT-BR" para "EN-US" e vice-versa
+    *
+    * @param value numero em formato de string a ser convertido
+    *
+    * @returns numero em formato de string formatado de "PT-BR" para "EN-US" e vice-versa
+    */
+    static changeFormat: (value: string) => string;
+}