@aws/lsp-codewhisperer 0.0.108 → 0.0.110

package/node_modules/@amzn/codewhisperer-streaming/node_modules/fast-xml-parser/src/xmlparser/node2json.js

@@ -0,0 +1,113 @@
+'use strict';
+
+/**
+ * 
+ * @param {array} node 
+ * @param {any} options 
+ * @returns 
+ */
+function prettify(node, options){
+  return compress( node, options);
+}
+
+/**
+ * 
+ * @param {array} arr 
+ * @param {object} options 
+ * @param {string} jPath 
+ * @returns object
+ */
+function compress(arr, options, jPath){
+  let text;
+  const compressedObj = {};
+  for (let i = 0; i < arr.length; i++) {
+    const tagObj = arr[i];
+    const property = propName(tagObj);
+    let newJpath = "";
+    if(jPath === undefined) newJpath = property;
+    else newJpath = jPath + "." + property;
+
+    if(property === options.textNodeName){
+      if(text === undefined) text = tagObj[property];
+      else text += "" + tagObj[property];
+    }else if(property === undefined){
+      continue;
+    }else if(tagObj[property]){
+      
+      let val = compress(tagObj[property], options, newJpath);
+      const isLeaf = isLeafTag(val, options);
+
+      if(tagObj[":@"]){
+        assignAttributes( val, tagObj[":@"], newJpath, options);
+      }else if(Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode){
+        val = val[options.textNodeName];
+      }else if(Object.keys(val).length === 0){
+        if(options.alwaysCreateTextNode) val[options.textNodeName] = "";
+        else val = "";
+      }
+
+      if(compressedObj[property] !== undefined && compressedObj.hasOwnProperty(property)) {
+        if(!Array.isArray(compressedObj[property])) {
+            compressedObj[property] = [ compressedObj[property] ];
+        }
+        compressedObj[property].push(val);
+      }else{
+        //TODO: if a node is not an array, then check if it should be an array
+        //also determine if it is a leaf node
+        if (options.isArray(property, newJpath, isLeaf )) {
+          compressedObj[property] = [val];
+        }else{
+          compressedObj[property] = val;
+        }
+      }
+    }
+    
+  }
+  // if(text && text.length > 0) compressedObj[options.textNodeName] = text;
+  if(typeof text === "string"){
+    if(text.length > 0) compressedObj[options.textNodeName] = text;
+  }else if(text !== undefined) compressedObj[options.textNodeName] = text;
+  return compressedObj;
+}
+
+function propName(obj){
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if(key !== ":@") return key;
+  }
+}
+
+function assignAttributes(obj, attrMap, jpath, options){
+  if (attrMap) {
+    const keys = Object.keys(attrMap);
+    const len = keys.length; //don't make it inline
+    for (let i = 0; i < len; i++) {
+      const atrrName = keys[i];
+      if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
+        obj[atrrName] = [ attrMap[atrrName] ];
+      } else {
+        obj[atrrName] = attrMap[atrrName];
+      }
+    }
+  }
+}
+
+function isLeafTag(obj, options){
+  const { textNodeName } = options;
+  const propCount = Object.keys(obj).length;
+  
+  if (propCount === 0) {
+    return true;
+  }
+
+  if (
+    propCount === 1 &&
+    (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)
+  ) {
+    return true;
+  }
+
+  return false;
+}
+exports.prettify = prettify;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js

@@ -0,0 +1,25 @@
+'use strict';
+
+class XmlNode{
+  constructor(tagname) {
+    this.tagname = tagname;
+    this.child = []; //nested tags, text, cdata, comments in order
+    this[":@"] = {}; //attributes map
+  }
+  add(key,val){
+    // this.child.push( {name : key, val: val, isCdata: isCdata });
+    if(key === "__proto__") key = "#__proto__";
+    this.child.push( {[key]: val });
+  }
+  addChild(node) {
+    if(node.tagname === "__proto__") node.tagname = "#__proto__";
+    if(node[":@"] && Object.keys(node[":@"]).length > 0){
+      this.child.push( { [node.tagname]: node.child, [":@"]: node[":@"] });
+    }else{
+      this.child.push( { [node.tagname]: node.child });
+    }
+  };
+};
+
+
+module.exports = XmlNode;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/strnum/.vscode/launch.json

@@ -0,0 +1,25 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Jasmine Tests",
+            "program": "${workspaceFolder}/node_modules/jasmine/bin/jasmine.js",
+            "args": [
+                "${workspaceFolder}/spec/attr_spec.js"
+            ],
+            "internalConsoleOptions": "openOnSessionStart"
+        },{
+            "type": "node",
+            "request": "launch",
+            "name": "Jasmine Tests current test file",
+            "program": "${workspaceFolder}/node_modules/jasmine/bin/jasmine.js",
+            "args": [
+                "${file}"
+            ],
+            "internalConsoleOptions": "openOnSessionStart"
+        }
+    ]
+   
+}

package/node_modules/@amzn/codewhisperer-streaming/node_modules/strnum/CHANGELOG.md

@@ -0,0 +1,22 @@
+
+**1.1.2 / 2025-02-27**
+- fix skiplike for 0
+
+**1.1.1 / 2025-02-21**
+- All recent fixes of version 2
+
+**2.0.4 / 2025-02-20**
+- remove console log
+
+**2.0.3 / 2025-02-20**
+- fix for string which are falsly identified as e-notation
+
+**2.0.1 / 2025-02-20**
+- fix: handle only zeros
+- fix: return original string when NaN
+
+**2.0.0 / 2025-02-20**
+- Migrating to ESM modules. No functional change
+
+**1.1.0 / 2025-02-20**
+- fix (#9): support missing floating point and e notations

package/node_modules/@amzn/codewhisperer-streaming/node_modules/strnum/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Natural Intelligence
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@amzn/codewhisperer-streaming/node_modules/strnum/README.md

@@ -0,0 +1,97 @@
+# strnum
+Parse string into Number based on configuration
+
+## Users
+
+<a href="https://github.com/aws-amplify" target="_blank"><img src="https://avatars.githubusercontent.com/u/41077760?s=100&v=4"></a>
+<a href="https://github.com/astrapay" target="_blank"><img src="https://avatars.githubusercontent.com/u/90901882?s=100&v=4"></a>
+<a href="https://github.com/process-analytics" target="_blank"><img src="https://avatars.githubusercontent.com/u/60110287?s=100&v=4"></a>
+<a href="https://github.com/NaturalIntelligence" target="_blank"><img src="https://avatars.githubusercontent.com/u/16322633?s=100&v=4"></a>
+Many React Native projects and plugins
+
+## Usage
+
+```bash
+npm install strnum
+```
+```js
+const toNumber = require("strnum");
+
+toNumber(undefined) // undefined
+toNumber(null)) //null
+toNumber("")) // ""
+toNumber("string"); //"string")
+toNumber("12,12"); //"12,12")
+toNumber("12 12"); //"12 12")
+toNumber("12-12"); //"12-12")
+toNumber("12.12.12"); //"12.12.12")
+toNumber("0x2f"); //47)
+toNumber("-0x2f"); //-47)
+toNumber("0x2f", { hex :  true}); //47)
+toNumber("-0x2f", { hex :  true}); //-47)
+toNumber("0x2f", { hex :  false}); //"0x2f")
+toNumber("-0x2f", { hex :  false}); //"-0x2f")
+toNumber("06"); //6)
+toNumber("06", { leadingZeros :  true}); //6)
+toNumber("06", { leadingZeros :  false}); //"06")
+
+toNumber("006"); //6)
+toNumber("006", { leadingZeros :  true}); //6)
+toNumber("006", { leadingZeros :  false}); //"006")
+toNumber("0.0"); //0)
+toNumber("00.00"); //0)
+toNumber("0.06"); //0.06)
+toNumber("00.6"); //0.6)
+toNumber(".006"); //0.006)
+toNumber("6.0"); //6)
+toNumber("06.0"); //6)
+
+toNumber("0.0",  { leadingZeros :  false}); //0)
+toNumber("00.00",  { leadingZeros :  false}); //"00.00")
+toNumber("0.06",  { leadingZeros :  false}); //0.06)
+toNumber("00.6",  { leadingZeros :  false}); //"00.6")
+toNumber(".006", { leadingZeros :  false}); //0.006)
+toNumber("6.0"  ,  { leadingZeros :  false}); //6)
+toNumber("06.0"  ,  { leadingZeros :  false}); //"06.0")
+toNumber("-06"); //-6)
+toNumber("-06", { leadingZeros :  true}); //-6)
+toNumber("-06", { leadingZeros :  false}); //"-06")
+
+toNumber("-0.0"); //-0)
+toNumber("-00.00"); //-0)
+toNumber("-0.06"); //-0.06)
+toNumber("-00.6"); //-0.6)
+toNumber("-.006"); //-0.006)
+toNumber("-6.0"); //-6)
+toNumber("-06.0"); //-6)
+
+toNumber("-0.0"   ,  { leadingZeros :  false}); //-0)
+toNumber("-00.00",  { leadingZeros :  false}); //"-00.00")
+toNumber("-0.06",  { leadingZeros :  false}); //-0.06)
+toNumber("-00.6",  { leadingZeros :  false}); //"-00.6")
+toNumber("-.006",  {leadingZeros :  false}); //-0.006)
+toNumber("-6.0"  ,  { leadingZeros :  false}); //-6)
+toNumber("-06.0"  ,  { leadingZeros :  false}); //"-06.0")
+toNumber("420926189200190257681175017717")  ; //4.209261892001902e+29)
+toNumber("000000000000000000000000017717"  ,  { leadingZeros :  false}); //"000000000000000000000000017717")
+toNumber("000000000000000000000000017717"  ,  { leadingZeros :  true}); //17717)
+toNumber("01.0e2"  ,  { leadingZeros :  false}); //"01.0e2")
+toNumber("-01.0e2"  ,  { leadingZeros :  false}); //"-01.0e2")
+toNumber("01.0e2") ; //100)
+toNumber("-01.0e2") ; //-100)
+toNumber("1.0e2") ; //100)
+
+toNumber("-1.0e2") ; //-100)
+toNumber("1.0e-2"); //0.01)
+
+toNumber("+1212121212"); // 1212121212
+toNumber("+1212121212", { skipLike: /\+[0-9]{10}/} )); //"+1212121212"
+```
+
+Supported Options
+```js
+hex: true,          //when hexadecimal string should be parsed
+leadingZeros: true, //when number with leading zeros like 08 should be parsed. 0.0 is not impacted
+eNotation: true,    //when number with eNotation or number parsed in eNotation should be considered
+skipLike: /regex/   //when string should not be parsed when it matches the specified regular expression
+```

package/node_modules/@amzn/codewhisperer-streaming/node_modules/strnum/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "strnum",
+  "version": "1.1.2",
+  "description": "Parse String to Number based on configuration",
+  "main": "strnum.js",
+  "scripts": {
+    "test": "jasmine strnum.test.js"
+  },
+  "keywords": [
+    "string",
+    "number",
+    "parse",
+    "convert"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NaturalIntelligence/strnum"
+  },
+  "author": "Amit Gupta (https://amitkumargupta.work/)",
+  "license": "MIT",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/NaturalIntelligence"
+    }
+  ],
+  "devDependencies": {
+    "jasmine": "^5.6.0"
+  }
+}

package/node_modules/@amzn/codewhisperer-streaming/node_modules/strnum/strnum.js

@@ -0,0 +1,111 @@
+const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
+const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
+// const octRegex = /^0x[a-z0-9]+/;
+// const binRegex = /0x[a-z0-9]+/;
+
+ 
+const consider = {
+    hex :  true,
+    // oct: false,
+    leadingZeros: true,
+    decimalPoint: "\.",
+    eNotation: true,
+    //skipLike: /regex/
+};
+
+function toNumber(str, options = {}){
+    options = Object.assign({}, consider, options );
+    if(!str || typeof str !== "string" ) return str;
+    
+    let trimmedStr  = str.trim();
+    
+    if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
+    else if(str==="0") return 0;
+    else if (options.hex && hexRegex.test(trimmedStr)) {
+        return parse_int(trimmedStr, 16);
+    // }else if (options.oct && octRegex.test(str)) {
+    //     return Number.parseInt(val, 8);
+    }else if (trimmedStr.search(/[eE]/)!== -1) { //eNotation
+        const notation = trimmedStr.match(/^([-\+])?(0*)([0-9]*(\.[0-9]*)?[eE][-\+]?[0-9]+)$/); 
+        // +00.123 => [ , '+', '00', '.123', ..
+        if(notation){
+            // console.log(notation)
+            if(options.leadingZeros){ //accept with leading zeros
+                trimmedStr = (notation[1] || "") + notation[3];
+            }else{
+                if(notation[2] === "0" && notation[3][0]=== "."){ //valid number
+                }else{
+                    return str;
+                }
+            }
+            return options.eNotation ? Number(trimmedStr) : str;
+        }else{
+            return str;
+        }
+    // }else if (options.parseBin && binRegex.test(str)) {
+    //     return Number.parseInt(val, 2);
+    }else{
+        //separate negative sign, leading zeros, and rest number
+        const match = numRegex.exec(trimmedStr);
+        // +00.123 => [ , '+', '00', '.123', ..
+        if(match){
+            const sign = match[1];
+            const leadingZeros = match[2];
+            let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros
+            //trim ending zeros for floating number
+            
+            if(!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") return str; //-0123
+            else if(!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") return str; //0123
+            else if(options.leadingZeros && leadingZeros===str) return 0; //00
+            
+            else{//no leading zeros or leading zeros are allowed
+                const num = Number(trimmedStr);
+                const numStr = "" + num;
+
+                if(numStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation
+                    if(options.eNotation) return num;
+                    else return str;
+                }else if(trimmedStr.indexOf(".") !== -1){ //floating number
+                    if(numStr === "0" && (numTrimmedByZeros === "") ) return num; //0.0
+                    else if(numStr === numTrimmedByZeros) return num; //0.456. 0.79000
+                    else if( sign && numStr === "-"+numTrimmedByZeros) return num;
+                    else return str;
+                }
+                
+                if(leadingZeros){
+                    return (numTrimmedByZeros === numStr) || (sign+numTrimmedByZeros === numStr) ? num : str
+                }else  {
+                    return (trimmedStr === numStr) || (trimmedStr === sign+numStr) ? num : str
+                }
+            }
+        }else{ //non-numeric string
+            return str;
+        }
+    }
+}
+
+/**
+ * 
+ * @param {string} numStr without leading zeros
+ * @returns 
+ */
+function trimZeros(numStr){
+    if(numStr && numStr.indexOf(".") !== -1){//float
+        numStr = numStr.replace(/0+$/, ""); //remove ending zeros
+        if(numStr === ".")  numStr = "0";
+        else if(numStr[0] === ".")  numStr = "0"+numStr;
+        else if(numStr[numStr.length-1] === ".")  numStr = numStr.substr(0,numStr.length-1);
+        return numStr;
+    }
+    return numStr;
+}
+
+function parse_int(numStr, base){
+    //polyfill
+    if(parseInt) return parseInt(numStr, base);
+    else if(Number.parseInt) return Number.parseInt(numStr, base);
+    else if(window && window.parseInt) return window.parseInt(numStr, base);
+    else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported")
+}
+
+module.exports = toNumber;

package/node_modules/@amzn/codewhisperer-streaming/node_modules/strnum/strnum.test.js

@@ -0,0 +1,165 @@
+const toNumber = require("./strnum.js");
+
+describe("Should convert all the valid numeric strings to number", () => {
+    it("should return undefined, null, empty string, or non-numeric as it is", () => {
+        expect(toNumber(undefined)).not.toBeDefined();
+        expect(toNumber(null)).toEqual(null);
+        expect(toNumber("")).toEqual("");
+        expect(toNumber("string")).toEqual("string");
+        expect(toNumber("e89794659669cb7bb967db73a7ea6889c3891727")).toEqual("e89794659669cb7bb967db73a7ea6889c3891727");
+        
+    });
+    it("should not parse number with spaces or comma", () => {
+        expect(toNumber("12,12")).toEqual("12,12");
+        expect(toNumber("12 12")).toEqual("12 12");
+        expect(toNumber("12-12")).toEqual("12-12");
+        expect(toNumber("12.12.12")).toEqual("12.12.12");
+    })
+    it("should consider + sign", () => {
+        expect(toNumber("+12")).toEqual(12);
+        expect(toNumber("+ 12")).toEqual("+ 12");
+        expect(toNumber("12+12")).toEqual("12+12");
+        expect(toNumber("1212+")).toEqual("1212+");
+    })
+    it("should parse hexadecimal values", () => {
+        expect(toNumber("0x2f")).toEqual(47);
+        expect(toNumber("-0x2f")).toEqual(-47);
+        expect(toNumber("0x2f", { hex :  true})).toEqual(47);
+        expect(toNumber("-0x2f", { hex :  true})).toEqual(-47);
+        expect(toNumber("0x2f", { hex :  false})).toEqual("0x2f");
+        expect(toNumber("-0x2f", { hex :  false})).toEqual("-0x2f");
+    })
+    it("should not parse strings with 0x embedded", () => {
+        expect(toNumber("0xzz")).toEqual("0xzz");
+        expect(toNumber("iweraf0x123qwerqwer")).toEqual("iweraf0x123qwerqwer");
+        expect(toNumber("1230x55")).toEqual("1230x55");
+        expect(toNumber("JVBERi0xLjMNCiXi48")).toEqual("JVBERi0xLjMNCiXi48");
+    })
+    it("leading zeros", () => {
+        expect(toNumber("0")).toEqual(0);
+        expect(toNumber("00")).toEqual(0);
+        expect(toNumber("00.0")).toEqual(0);
+
+        expect(toNumber("0",{ leadingZeros :  false})).toEqual(0);
+        expect(toNumber("00",{ leadingZeros :  false})).toEqual("00");
+        expect(toNumber("00.0",{ leadingZeros :  false})).toEqual("00.0");
+
+        expect(toNumber("06")).toEqual(6);
+        expect(toNumber("06", { leadingZeros :  true})).toEqual(6);
+        expect(toNumber("06", { leadingZeros :  false})).toEqual("06");
+
+        expect(toNumber("006")).toEqual(6);
+        expect(toNumber("006", { leadingZeros :  true})).toEqual(6);
+        expect(toNumber("006", { leadingZeros :  false})).toEqual("006");
+
+        expect(toNumber("000000000000000000000000017717"  ,  { leadingZeros :  false})).toEqual("000000000000000000000000017717");
+        expect(toNumber("000000000000000000000000017717"  ,  { leadingZeros :  true})).toEqual(17717);
+        expect(toNumber("020211201030005811824")  ).toEqual("020211201030005811824");
+        expect(toNumber("0420926189200190257681175017717")  ).toEqual(4.209261892001902e+29);
+    })
+    it("invalid floating number", () => {
+        expect(toNumber("20.21.030")  ).toEqual("20.21.030");
+        expect(toNumber("0.21.030")  ).toEqual("0.21.030");
+        expect(toNumber("0.21.")  ).toEqual("0.21.");
+    });
+    it("floating point and leading zeros", () => {
+        expect(toNumber("0.")).toEqual(0);
+        expect(toNumber("+0.")).toEqual(0);
+        expect(toNumber("-0.")).toEqual(-0);
+        expect(toNumber("1.")  ).toEqual(1);
+        expect(toNumber("00.00")).toEqual(0);
+        expect(toNumber("0.06")).toEqual(0.06);
+        expect(toNumber("00.6")).toEqual(0.6);
+        expect(toNumber(".006")).toEqual(0.006);
+        expect(toNumber("6.0")).toEqual(6);
+        expect(toNumber("06.0")).toEqual(6);
+        
+        expect(toNumber("0.0",  { leadingZeros :  false})).toEqual(0);
+        expect(toNumber("00.00",  { leadingZeros :  false})).toEqual("00.00");
+        expect(toNumber("0.06",  { leadingZeros :  false})).toEqual(0.06);
+        expect(toNumber("00.6",  { leadingZeros :  false})).toEqual("00.6");
+        expect(toNumber(".006", { leadingZeros :  false})).toEqual(0.006);
+        expect(toNumber("6.0"  ,  { leadingZeros :  false})).toEqual(6);
+        expect(toNumber("06.0"  ,  { leadingZeros :  false})).toEqual("06.0");
+    })
+    it("negative number  leading zeros", () => {
+        expect(toNumber("+06")).toEqual(6);
+        expect(toNumber("-06")).toEqual(-6);
+        expect(toNumber("-06", { leadingZeros :  true})).toEqual(-6);
+        expect(toNumber("-06", { leadingZeros :  false})).toEqual("-06");
+        
+        expect(toNumber("-0.0")).toEqual(-0);
+        expect(toNumber("-00.00")).toEqual(-0);
+        expect(toNumber("-0.06")).toEqual(-0.06);
+        expect(toNumber("-00.6")).toEqual(-0.6);
+        expect(toNumber("-.006")).toEqual(-0.006);
+        expect(toNumber("-6.0")).toEqual(-6);
+        expect(toNumber("-06.0")).toEqual(-6);
+        
+        expect(toNumber("-0.0"   ,  { leadingZeros :  false})).toEqual(-0);
+        expect(toNumber("-00.00",  { leadingZeros :  false})).toEqual("-00.00");
+        expect(toNumber("-0.06",  { leadingZeros :  false})).toEqual(-0.06);
+        expect(toNumber("-00.6",  { leadingZeros :  false})).toEqual("-00.6");
+        expect(toNumber("-.006",  {leadingZeros :  false})).toEqual(-0.006);
+        expect(toNumber("-6.0"  ,  { leadingZeros :  false})).toEqual(-6);
+        expect(toNumber("-06.0"  ,  { leadingZeros :  false})).toEqual("-06.0");
+    })
+    it("long number", () => {
+        expect(toNumber("020211201030005811824")  ).toEqual("020211201030005811824");
+        expect(toNumber("20211201030005811824")  ).toEqual("20211201030005811824");
+        expect(toNumber("20.211201030005811824")  ).toEqual("20.211201030005811824");
+        expect(toNumber("0.211201030005811824")  ).toEqual("0.211201030005811824");
+    });
+    it("scientific notation", () => {
+        expect(toNumber("01.0e2"  ,  { leadingZeros :  false})).toEqual("01.0e2");
+        expect(toNumber("-01.0e2"  ,  { leadingZeros :  false})).toEqual("-01.0e2");
+        expect(toNumber("01.0e2") ).toEqual(100);
+        expect(toNumber("-01.0e2") ).toEqual(-100);
+        expect(toNumber("1.0e2") ).toEqual(100);
+
+        expect(toNumber("-1.0e2") ).toEqual(-100);
+        expect(toNumber("1.0e-2")).toEqual(0.01);
+        
+        expect(toNumber("420926189200190257681175017717")  ).toEqual(4.209261892001902e+29);
+        expect(toNumber("420926189200190257681175017717" , { eNotation: false} )).toEqual("420926189200190257681175017717");
+        
+        expect(toNumber("1e-2")).toEqual(0.01);
+        expect(toNumber("1e+2")).toEqual(100);
+        expect(toNumber("1.e+2")).toEqual(100);
+    });
+
+    it("scientific notation with upper E", () => {
+        expect(toNumber("01.0E2"  ,  { leadingZeros :  false})).toEqual("01.0E2");
+        expect(toNumber("-01.0E2"  ,  { leadingZeros :  false})).toEqual("-01.0E2");
+        expect(toNumber("01.0E2") ).toEqual(100);
+        expect(toNumber("-01.0E2") ).toEqual(-100);
+        expect(toNumber("1.0E2") ).toEqual(100);
+
+        expect(toNumber("-1.0E2") ).toEqual(-100);
+        expect(toNumber("1.0E-2")).toEqual(0.01);
+    });
+    
+    it("should skip matching pattern", () => {
+        expect(toNumber("0", { skipLike: /.*/ })).toEqual("0");
+        expect(toNumber("+12", { skipLike: /\+[0-9]{10}/} )).toEqual(12);
+        expect(toNumber("12+12", { skipLike: /\+[0-9]{10}/} )).toEqual("12+12");
+        expect(toNumber("12+1212121212", { skipLike: /\+[0-9]{10}/} )).toEqual("12+1212121212");
+        expect(toNumber("+1212121212") ).toEqual(1212121212);
+        expect(toNumber("+1212121212", { skipLike: /\+[0-9]{10}/} )).toEqual("+1212121212");
+    })
+    it("should not change string if not number", () => {
+        expect(toNumber("+12 12")).toEqual("+12 12");
+        expect(toNumber("    +12 12   ")).toEqual("    +12 12   ");
+    })
+    it("should ignore sorrounded spaces ", () => {
+        expect(toNumber("   +1212   ")).toEqual(1212);
+    })
+    
+    it("negative numbers", () => {
+        expect(toNumber("+1212")).toEqual(1212);
+        expect(toNumber("+12.12")).toEqual(12.12);
+        expect(toNumber("-12.12")).toEqual(-12.12);
+        expect(toNumber("-012.12")).toEqual(-12.12);
+        expect(toNumber("-012.12")).toEqual(-12.12);
+    })
+});