game_dig 0.0.1 → 0.2.0

data/lib/game_dig/node/node_modules/string_decoder/index.js

@@ -0,0 +1,221 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var Buffer = require('buffer').Buffer;
+
+var isBufferEncoding = Buffer.isEncoding
+  || function(encoding) {
+       switch (encoding && encoding.toLowerCase()) {
+         case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+         default: return false;
+       }
+     }
+
+
+function assertEncoding(encoding) {
+  if (encoding && !isBufferEncoding(encoding)) {
+    throw new Error('Unknown encoding: ' + encoding);
+  }
+}
+
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters. CESU-8 is handled as part of the UTF-8 encoding.
+//
+// @TODO Handling all encodings inside a single object makes it very difficult
+// to reason about this code, so it should be split up in the future.
+// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
+// points as used by CESU-8.
+var StringDecoder = exports.StringDecoder = function(encoding) {
+  this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+  assertEncoding(encoding);
+  switch (this.encoding) {
+    case 'utf8':
+      // CESU-8 represents each of Surrogate Pair by 3-bytes
+      this.surrogateSize = 3;
+      break;
+    case 'ucs2':
+    case 'utf16le':
+      // UTF-16 represents each of Surrogate Pair by 2-bytes
+      this.surrogateSize = 2;
+      this.detectIncompleteChar = utf16DetectIncompleteChar;
+      break;
+    case 'base64':
+      // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+      this.surrogateSize = 3;
+      this.detectIncompleteChar = base64DetectIncompleteChar;
+      break;
+    default:
+      this.write = passThroughWrite;
+      return;
+  }
+
+  // Enough space to store all bytes of a single character. UTF-8 needs 4
+  // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
+  this.charBuffer = new Buffer(6);
+  // Number of bytes received for the current incomplete multi-byte character.
+  this.charReceived = 0;
+  // Number of bytes expected for the current incomplete multi-byte character.
+  this.charLength = 0;
+};
+
+
+// write decodes the given buffer and returns it as JS string that is
+// guaranteed to not contain any partial multi-byte characters. Any partial
+// character found at the end of the buffer is buffered up, and will be
+// returned when calling write again with the remaining bytes.
+//
+// Note: Converting a Buffer containing an orphan surrogate to a String
+// currently works, but converting a String to a Buffer (via `new Buffer`, or
+// Buffer#write) will replace incomplete surrogates with the unicode
+// replacement character. See https://codereview.chromium.org/121173009/ .
+StringDecoder.prototype.write = function(buffer) {
+  var charStr = '';
+  // if our last write ended with an incomplete multibyte character
+  while (this.charLength) {
+    // determine how many remaining bytes this buffer has to offer for this char
+    var available = (buffer.length >= this.charLength - this.charReceived) ?
+        this.charLength - this.charReceived :
+        buffer.length;
+
+    // add the new bytes to the char buffer
+    buffer.copy(this.charBuffer, this.charReceived, 0, available);
+    this.charReceived += available;
+
+    if (this.charReceived < this.charLength) {
+      // still not enough chars in this buffer? wait for more ...
+      return '';
+    }
+
+    // remove bytes belonging to the current character from the buffer
+    buffer = buffer.slice(available, buffer.length);
+
+    // get the character that was split
+    charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+    // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+    var charCode = charStr.charCodeAt(charStr.length - 1);
+    if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+      this.charLength += this.surrogateSize;
+      charStr = '';
+      continue;
+    }
+    this.charReceived = this.charLength = 0;
+
+    // if there are no more bytes in this buffer, just emit our char
+    if (buffer.length === 0) {
+      return charStr;
+    }
+    break;
+  }
+
+  // determine and set charLength / charReceived
+  this.detectIncompleteChar(buffer);
+
+  var end = buffer.length;
+  if (this.charLength) {
+    // buffer the incomplete character bytes we got
+    buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+    end -= this.charReceived;
+  }
+
+  charStr += buffer.toString(this.encoding, 0, end);
+
+  var end = charStr.length - 1;
+  var charCode = charStr.charCodeAt(end);
+  // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
+  if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+    var size = this.surrogateSize;
+    this.charLength += size;
+    this.charReceived += size;
+    this.charBuffer.copy(this.charBuffer, size, 0, size);
+    buffer.copy(this.charBuffer, 0, 0, size);
+    return charStr.substring(0, end);
+  }
+
+  // or just emit the charStr
+  return charStr;
+};
+
+// detectIncompleteChar determines if there is an incomplete UTF-8 character at
+// the end of the given buffer. If so, it sets this.charLength to the byte
+// length that character, and sets this.charReceived to the number of bytes
+// that are available for this character.
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+  // determine how many bytes we have to check at the end of this buffer
+  var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+  // Figure out if one of the last i bytes of our buffer announces an
+  // incomplete char.
+  for (; i > 0; i--) {
+    var c = buffer[buffer.length - i];
+
+    // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+    // 110XXXXX
+    if (i == 1 && c >> 5 == 0x06) {
+      this.charLength = 2;
+      break;
+    }
+
+    // 1110XXXX
+    if (i <= 2 && c >> 4 == 0x0E) {
+      this.charLength = 3;
+      break;
+    }
+
+    // 11110XXX
+    if (i <= 3 && c >> 3 == 0x1E) {
+      this.charLength = 4;
+      break;
+    }
+  }
+  this.charReceived = i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+  var res = '';
+  if (buffer && buffer.length)
+    res = this.write(buffer);
+
+  if (this.charReceived) {
+    var cr = this.charReceived;
+    var buf = this.charBuffer;
+    var enc = this.encoding;
+    res += buf.slice(0, cr).toString(enc);
+  }
+
+  return res;
+};
+
+function passThroughWrite(buffer) {
+  return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 2;
+  this.charLength = this.charReceived ? 2 : 0;
+}
+
+function base64DetectIncompleteChar(buffer) {
+  this.charReceived = buffer.length % 3;
+  this.charLength = this.charReceived ? 3 : 0;
+}

data/lib/game_dig/node/node_modules/string_decoder/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "string_decoder",
+  "version": "0.10.31",
+  "description": "The string_decoder module from Node core",
+  "main": "index.js",
+  "dependencies": {},
+  "devDependencies": {
+    "tap": "~0.4.8"
+  },
+  "scripts": {
+    "test": "tap test/simple/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/rvagg/string_decoder.git"
+  },
+  "homepage": "https://github.com/rvagg/string_decoder",
+  "keywords": [
+    "string",
+    "decoder",
+    "browser",
+    "browserify"
+  ],
+  "license": "MIT"
+}

data/lib/game_dig/node/node_modules/strnum/.github/SECURITY.md

@@ -0,0 +1,5 @@
+If you believe you have found a security vulnerability in this repository which can be potentially harful for the users in anyway, please do not report security vulnerabilities through public GitHub issues. Instead, please report it to us as described below.
+
+## Security contact information
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.

data/lib/game_dig/node/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"
+        }
+    ]
+   
+}

data/lib/game_dig/node/node_modules/strnum/CHANGELOG.md

@@ -0,0 +1,33 @@
+
+**2.1.1 / 2025-05-15**
+- remove unnecessary check to remove lint error
+
+**2.1.0 / 2025-05-01**
+- fix e-notation 
+  - to return string when invalid enotation is found. Eg `E24`
+  - to return valid number when only leading zero before e char is present
+
+**2.0.5 / 2025-02-27**
+- changes done in 1.1.2
+
+**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

data/lib/game_dig/node/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.

data/lib/game_dig/node/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
+```

data/lib/game_dig/node/node_modules/strnum/algo.stflow

@@ -0,0 +1,84 @@
+
+FLOW: toNumber
+input: x, options
+IF not string
+  END x
+ELSE_IF should skip
+  END x
+ELSE_IF 0
+  END 0
+ELSE_IF hex is supported AND x is hex
+  END int of x of base 16
+ELSE_IF possible e notation
+  FOLLOW: resolve enotation (x, trimmed x, options)
+ELSE
+  IF match numeric pattern
+    separate sign, leading zeros, pure number
+    IF x doesn't starts with "[+-]0."
+      END number(x)
+    IF leading zeros are not allowed 
+      IF leading zeros > 1
+        #00.1
+        END x
+      ELSE_IF leading zeros == 1 AND decimal is not adjacent to leading zeros
+        #06.5
+        #but not 0.65, .65, 6.0
+        END x
+    ELSE_IF str has only zeros
+      END 0
+    ELSE
+      parse x to number
+      IF parsed x == 0 or -0
+        END parsed x
+      ELSE_IF parsed x is eNotation
+        IF conversion to enotation is allowed
+          END parsed x
+        ELSE
+          END x
+      ELSE_IF floating number
+        IF parsed x is 0
+          END parsed x 
+        ELSE_IF parsed x == number without leading 0s
+          #0.456. 0.79000
+          END parsed x
+        ELSE_IF parsed x is negative AND == parsed x == number without leading 0s
+          END parsed x
+        ELSE
+          END x
+      ELSE_IF leading 0s are present
+        IF parsed x == x without leading 0s
+          END parsed x
+        ELSE
+          END x
+      ELSE
+        IF parsed x == x (consider sign)
+          END parsed x
+        ELSE
+          END x
+
+  ELSE
+    END x
+
+
+
+FLOW: resolve enotation
+input: x, trimmed x, options
+IF eNotation has not to be evaluated
+  END x
+IF match eNotation pattern
+  extract sign, eChar, leading zeros
+  find if eChar adjacent to leading zeros
+
+  IF leading zeros > 1 AND eChar adjacent to leading zeros
+    # 00e, -00e
+    END x
+  ELSE_IF exp is `0e`, `0.e`, `-0.e`, `-0e`
+    END number(x); 
+  ELSE_IF leading zeros are allowed but eChar is not adjacent to leading zeros
+    # -003e2
+    remove leading zeros
+    END number(x)
+  ELSE
+    END x
+ELSE
+  END x

data/lib/game_dig/node/node_modules/strnum/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "strnum",
+  "version": "2.1.1",
+  "description": "Parse String to Number based on configuration",
+  "type": "module",
+  "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"
+  }
+}

data/lib/game_dig/node/node_modules/strnum/strnum.js

@@ -0,0 +1,129 @@
+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/
+};
+
+export default 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
+        return resolveEnotation(str,trimmedStr,options);
+    // }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
+            const decimalAdjacentToLeadingZeros = sign ? // 0., -00., 000.
+                str[leadingZeros.length+1] === "." 
+                : str[leadingZeros.length] === ".";
+
+            //trim ending zeros for floating number
+            if(!options.leadingZeros //leading zeros are not allowed
+                && (leadingZeros.length > 1 
+                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))){
+                // 00, 00.3, +03.24, 03, 03.24
+                return str;
+            }
+            else{//no leading zeros or leading zeros are allowed
+                const num = Number(trimmedStr);
+                const parsedStr = String(num);
+
+                if( num === 0) return num;
+                if(parsedStr.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(parsedStr === "0") return num; //0.0
+                    else if(parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000
+                    else if( parsedStr === `${sign}${numTrimmedByZeros}`) return num;
+                    else return str;
+                }
+                
+                let n = leadingZeros? numTrimmedByZeros : trimmedStr;
+                if(leadingZeros){
+                    // -009 => -9
+                    return (n === parsedStr) || (sign+n === parsedStr) ? num : str
+                }else  {
+                    // +9
+                    return (n === parsedStr) || (n === sign+parsedStr) ? num : str
+                }
+            }
+        }else{ //non-numeric string
+            return str;
+        }
+    }
+}
+
+const eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
+function resolveEnotation(str,trimmedStr,options){
+    if(!options.eNotation) return str;
+    const notation = trimmedStr.match(eNotationRegx); 
+    if(notation){
+        let sign = notation[1] || "";
+        const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";
+        const leadingZeros = notation[2];
+        const eAdjacentToLeadingZeros = sign ? // 0E.
+            str[leadingZeros.length+1] === eChar 
+            : str[leadingZeros.length] === eChar;
+
+        if(leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;
+        else if(leadingZeros.length === 1 
+            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)){
+                return Number(trimmedStr);
+        }else if(options.leadingZeros && !eAdjacentToLeadingZeros){ //accept with leading zeros
+            //remove leading 0s
+            trimmedStr = (notation[1] || "") + notation[3];
+            return Number(trimmedStr);
+        }else return str;
+    }else{
+        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.substring(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")
+}