Rename NumberType to JsNumber

src/core/calc.ts

@@ -1,19 +1,19 @@
 import { type } from "os";
 import { Expression } from "../expression/expression-interfaces";
 import formatter from "./formatter";
-import { NumberType } from "./types";
+import { JsNumber } from "./types";
 import { asIntN } from "./utils";
 
 export default {
-    abs (num : NumberType) : NumberType {
+    abs (num : JsNumber) : JsNumber {
         return num >= 0 ? num : -num;
     },
     
-    maxBitSize(num : NumberType) : number {
+    maxBitSize(num : JsNumber) : number {
         return typeof num == "bigint" ? 64 : 32;
     },
 
-    numberOfBitsDisplayed: function (num: NumberType) : number {
+    numberOfBitsDisplayed: function (num: JsNumber) : number {
         
         if(num < 0) {
             return typeof num == 'bigint' ? 64 : 32
@@ -33,7 +33,7 @@ export default {
         return Math.max.apply(null, counts);
     },
 
-    flipBit: function(num: NumberType, index: number): NumberType  {
+    flipBit: function(num: JsNumber, index: number): JsNumber  {
 
         const is64bit = typeof num == 'bigint';
         const size = typeof num == "bigint" ? 64 : 32;
@@ -80,7 +80,7 @@ export default {
         return bin.split('').map(b => b=="1"?"0":"1").join("");
     },
 
-    binaryRepresentation(num : NumberType, bitSize?: number) : string {
+    binaryRepresentation(num : JsNumber, bitSize?: number) : string {
         
         bitSize = bitSize || typeof num == "bigint" ? 64 : 32;
         const bin = this.abs(num).toString(2);
@@ -93,7 +93,7 @@ export default {
             : bin;
     },
 
-    rshift (num: NumberType, numBytes : NumberType, bitSize: number) : NumberType {
+    rshift (num: JsNumber, numBytes : JsNumber, bitSize: number) : JsNumber {
         
         const bytes = asIntN(numBytes);
         

src/core/formatter.ts

@@ -1,9 +1,9 @@
 import calc from "./calc";
-import { NumberType } from "./types";
+import { JsNumber } from "./types";
 export type NumberBase = 'dec' | 'hex' | 'bin';
 
 const formatter = {
-    numberToString: function(num: NumberType, base: NumberBase) : string {
+    numberToString: function(num: JsNumber, base: NumberBase) : string {
      
         switch(base) {
             case 'hex':
@@ -30,10 +30,10 @@ const formatter = {
 
         return sb.join('');
     },
-    bin(number: NumberType) {
+    bin(number: JsNumber) {
         return this.numberToString(number, 'bin');
     },
-    emBin(number: NumberType) {
+    emBin(number: JsNumber) {
         return this.padLeft(this.bin(number), 8, '0');
     },
     

src/core/types.ts

@@ -1 +1 @@
-export type NumberType = number | bigint;
+export type JsNumber = number | bigint;

src/core/utils.tsx

@@ -1,4 +1,4 @@
-import { NumberType } from "./types";
+import { JsNumber } from "./types";
 
 function chunkifyString(input: string, chunkSize: number) : string[] {
     
@@ -11,7 +11,7 @@ function chunkifyString(input: string, chunkSize: number) : string[] {
     return result;
 }
 
-function asIntN(num: NumberType) : number {
+function asIntN(num: JsNumber) : number {
     return typeof num == "bigint" ? parseInt(num.toString()): num as number;
 }
 

src/expression/ScalarValue.ts

@@ -2,7 +2,7 @@ import {numberParser} from './numberParser';
 import { ExpressionElement as ExpressionElement } from './expression-interfaces';
 import { NumberBase } from '../core/formatter';
 import { INT32_MAX_VALUE, INT32_MIN_VALUE, INT64_MAX_VALUE, INT64_MIN_VALUE } from '../core/const';
-import { NumberType } from '../core/types';
+import { JsNumber } from '../core/types';
 
 var globalId : number = 1;
 
@@ -10,11 +10,11 @@ var globalId : number = 1;
 // Represents scalar numeric value
 export default class ScalarValue implements ExpressionElement {
     id: number;
-    value: NumberType;
+    value: JsNumber;
     base: NumberBase;
     isOperator: boolean;
 
-    constructor(value : NumberType, base?: NumberBase, is32Limit?: boolean) {
+    constructor(value : JsNumber, base?: NumberBase, is32Limit?: boolean) {
         
         ScalarValue.validateSupported(value);
 
@@ -32,7 +32,7 @@ export default class ScalarValue implements ExpressionElement {
         return typeof this.value === 'bigint';
     }
             
-    setValue(value : NumberType) {
+    setValue(value : JsNumber) {
         this.value = value;
     }
 
@@ -44,7 +44,7 @@ export default class ScalarValue implements ExpressionElement {
         return this
     }
 
-    static validateSupported(num : NumberType) {
+    static validateSupported(num : JsNumber) {
         
         if(typeof num == "bigint" && (num < INT64_MIN_VALUE || num > INT64_MAX_VALUE)) {
             throw new Error(`64-bit numbers are supported in range from ${INT64_MIN_VALUE} to ${INT64_MAX_VALUE}`);

src/expression/engine.ts

@@ -1,5 +1,5 @@
 import calc from "../core/calc";
-import { NumberType } from "../core/types";
+import { JsNumber } from "../core/types";
 import ScalarValue from "./ScalarValue";
 
 const engine = {
@@ -14,22 +14,22 @@ const engine = {
     }
 };
 
-function evalute(op1 : NumberType, operator: string, op2 : NumberType) : NumberType{
+function evalute(op1 : JsNumber, operator: string, op2 : JsNumber) : JsNumber{
     const a = equalizeType(op2, op1) as any;
     const b = equalizeType(op1, op2) as any;
     
     switch(operator) {
-        case ">>": return (a >> b) as (NumberType);
-        case ">>>": return (a >>> b) as (NumberType);
+        case ">>": return (a >> b) as (JsNumber);
+        case ">>>": return (a >>> b) as (JsNumber);
         case "<<": return calc.rshift(a, b, calc.maxBitSize(a));
-        case "&": return (b & a) as (NumberType);
-        case "|": return (b | a) as (NumberType);
-        case "^": return (b ^ a) as (NumberType);
+        case "&": return (b & a) as (JsNumber);
+        case "|": return (b | a) as (JsNumber);
+        case "^": return (b ^ a) as (JsNumber);
         default: throw new Error(operator + " operator is not supported");
     }
 }
 
-function equalizeType(source : NumberType, dest : NumberType) : NumberType {
+function equalizeType(source : JsNumber, dest : JsNumber) : JsNumber {
     
     return typeof source == 'bigint' && typeof dest != 'bigint'
         ? BigInt(dest)

src/expression/numberParser.ts

@@ -1,6 +1,6 @@
 import { INT32_MAX_VALUE, INT32_MIN_VALUE } from "../core/const";
 import { NumberBase } from "../core/formatter";
-import { NumberType } from "../core/types";
+import { JsNumber } from "../core/types";
 
 const decimalRegex = /^-?\d+[l,L]?$/;
 const hexRegex = /^-?0x[0-9,a-f]+[l,L]?$/i;
@@ -9,11 +9,11 @@ const binRegex = /^-?0b[0-1]+[l,L]?$/i;
 interface ParserConfig {
     regex: RegExp,
     base: NumberBase,
-    parse: (input: string) => NumberType 
+    parse: (input: string) => JsNumber 
 }
 
 export interface ParsedNumber {
-    value: NumberType;
+    value: JsNumber;
     base: NumberBase;
     input: string;
 }
@@ -66,7 +66,7 @@ class NumberParser {
 const MAX_SAFE_INTn = BigInt(INT32_MAX_VALUE);
 const MIN_SAFE_INTn = BigInt(INT32_MIN_VALUE);
 
-function parseIntSafe(input : string, radix: number)  : NumberType {
+function parseIntSafe(input : string, radix: number)  : JsNumber {
     
 const bigIntStr = input.replace('-', '').replace('l', '').replace('L', '');
     let bigInt = BigInt(bigIntStr);