@gemeentenijmegen/webapp 1.1.3 → 1.1.5

package/node_modules/math-intrinsics/test/index.js

@@ -0,0 +1,192 @@
+'use strict';
+
+var test = require('tape');
+var v = require('es-value-fixtures');
+var forEach = require('for-each');
+var inspect = require('object-inspect');
+
+var abs = require('../abs');
+var floor = require('../floor');
+var isFinite = require('../isFinite');
+var isInteger = require('../isInteger');
+var isNaN = require('../isNaN');
+var isNegativeZero = require('../isNegativeZero');
+var max = require('../max');
+var min = require('../min');
+var mod = require('../mod');
+var pow = require('../pow');
+var round = require('../round');
+var sign = require('../sign');
+
+var maxArrayLength = require('../constants/maxArrayLength');
+var maxSafeInteger = require('../constants/maxSafeInteger');
+var maxValue = require('../constants/maxValue');
+
+test('abs', function (t) {
+	t.equal(abs(-1), 1, 'abs(-1) === 1');
+	t.equal(abs(+1), 1, 'abs(+1) === 1');
+	t.equal(abs(+0), +0, 'abs(+0) === +0');
+	t.equal(abs(-0), +0, 'abs(-0) === +0');
+
+	t.end();
+});
+
+test('floor', function (t) {
+	t.equal(floor(-1.1), -2, 'floor(-1.1) === -2');
+	t.equal(floor(+1.1), 1, 'floor(+1.1) === 1');
+	t.equal(floor(+0), +0, 'floor(+0) === +0');
+	t.equal(floor(-0), -0, 'floor(-0) === -0');
+	t.equal(floor(-Infinity), -Infinity, 'floor(-Infinity) === -Infinity');
+	t.equal(floor(Number(Infinity)), Number(Infinity), 'floor(+Infinity) === +Infinity');
+	t.equal(floor(NaN), NaN, 'floor(NaN) === NaN');
+	t.equal(floor(0), +0, 'floor(0) === +0');
+	t.equal(floor(-0), -0, 'floor(-0) === -0');
+	t.equal(floor(1), 1, 'floor(1) === 1');
+	t.equal(floor(-1), -1, 'floor(-1) === -1');
+	t.equal(floor(1.1), 1, 'floor(1.1) === 1');
+	t.equal(floor(-1.1), -2, 'floor(-1.1) === -2');
+	t.equal(floor(maxValue), maxValue, 'floor(maxValue) === maxValue');
+	t.equal(floor(maxSafeInteger), maxSafeInteger, 'floor(maxSafeInteger) === maxSafeInteger');
+
+	t.end();
+});
+
+test('isFinite', function (t) {
+	t.equal(isFinite(0), true, 'isFinite(+0) === true');
+	t.equal(isFinite(-0), true, 'isFinite(-0) === true');
+	t.equal(isFinite(1), true, 'isFinite(1) === true');
+	t.equal(isFinite(Infinity), false, 'isFinite(Infinity) === false');
+	t.equal(isFinite(-Infinity), false, 'isFinite(-Infinity) === false');
+	t.equal(isFinite(NaN), false, 'isFinite(NaN) === false');
+
+	forEach(v.nonNumbers, function (nonNumber) {
+		t.equal(isFinite(nonNumber), false, 'isFinite(' + inspect(nonNumber) + ') === false');
+	});
+
+	t.end();
+});
+
+test('isInteger', function (t) {
+	forEach([].concat(
+		// @ts-expect-error TS sucks with concat
+		v.nonNumbers,
+		v.nonIntegerNumbers
+	), function (nonInteger) {
+		t.equal(isInteger(nonInteger), false, 'isInteger(' + inspect(nonInteger) + ') === false');
+	});
+
+	t.end();
+});
+
+test('isNaN', function (t) {
+	forEach([].concat(
+		// @ts-expect-error TS sucks with concat
+		v.nonNumbers,
+		v.infinities,
+		v.zeroes,
+		v.integerNumbers
+	), function (nonNaN) {
+		t.equal(isNaN(nonNaN), false, 'isNaN(' + inspect(nonNaN) + ') === false');
+	});
+
+	t.equal(isNaN(NaN), true, 'isNaN(NaN) === true');
+
+	t.end();
+});
+
+test('isNegativeZero', function (t) {
+	t.equal(isNegativeZero(-0), true, 'isNegativeZero(-0) === true');
+	t.equal(isNegativeZero(+0), false, 'isNegativeZero(+0) === false');
+	t.equal(isNegativeZero(1), false, 'isNegativeZero(1) === false');
+	t.equal(isNegativeZero(-1), false, 'isNegativeZero(-1) === false');
+	t.equal(isNegativeZero(NaN), false, 'isNegativeZero(NaN) === false');
+	t.equal(isNegativeZero(Infinity), false, 'isNegativeZero(Infinity) === false');
+	t.equal(isNegativeZero(-Infinity), false, 'isNegativeZero(-Infinity) === false');
+
+	forEach(v.nonNumbers, function (nonNumber) {
+		t.equal(isNegativeZero(nonNumber), false, 'isNegativeZero(' + inspect(nonNumber) + ') === false');
+	});
+
+	t.end();
+});
+
+test('max', function (t) {
+	t.equal(max(1, 2), 2, 'max(1, 2) === 2');
+	t.equal(max(1, 2, 3), 3, 'max(1, 2, 3) === 3');
+	t.equal(max(1, 2, 3, 4), 4, 'max(1, 2, 3, 4) === 4');
+	t.equal(max(1, 2, 3, 4, 5), 5, 'max(1, 2, 3, 4, 5) === 5');
+	t.equal(max(1, 2, 3, 4, 5, 6), 6, 'max(1, 2, 3, 4, 5, 6) === 6');
+	t.equal(max(1, 2, 3, 4, 5, 6, 7), 7, 'max(1, 2, 3, 4, 5, 6, 7) === 7');
+
+	t.end();
+});
+
+test('min', function (t) {
+	t.equal(min(1, 2), 1, 'min(1, 2) === 1');
+	t.equal(min(1, 2, 3), 1, 'min(1, 2, 3) === 1');
+	t.equal(min(1, 2, 3, 4), 1, 'min(1, 2, 3, 4) === 1');
+	t.equal(min(1, 2, 3, 4, 5), 1, 'min(1, 2, 3, 4, 5) === 1');
+	t.equal(min(1, 2, 3, 4, 5, 6), 1, 'min(1, 2, 3, 4, 5, 6) === 1');
+
+	t.end();
+});
+
+test('mod', function (t) {
+	t.equal(mod(1, 2), 1, 'mod(1, 2) === 1');
+	t.equal(mod(2, 2), 0, 'mod(2, 2) === 0');
+	t.equal(mod(3, 2), 1, 'mod(3, 2) === 1');
+	t.equal(mod(4, 2), 0, 'mod(4, 2) === 0');
+	t.equal(mod(5, 2), 1, 'mod(5, 2) === 1');
+	t.equal(mod(6, 2), 0, 'mod(6, 2) === 0');
+	t.equal(mod(7, 2), 1, 'mod(7, 2) === 1');
+	t.equal(mod(8, 2), 0, 'mod(8, 2) === 0');
+	t.equal(mod(9, 2), 1, 'mod(9, 2) === 1');
+	t.equal(mod(10, 2), 0, 'mod(10, 2) === 0');
+	t.equal(mod(11, 2), 1, 'mod(11, 2) === 1');
+
+	t.end();
+});
+
+test('pow', function (t) {
+	t.equal(pow(2, 2), 4, 'pow(2, 2) === 4');
+	t.equal(pow(2, 3), 8, 'pow(2, 3) === 8');
+	t.equal(pow(2, 4), 16, 'pow(2, 4) === 16');
+	t.equal(pow(2, 5), 32, 'pow(2, 5) === 32');
+	t.equal(pow(2, 6), 64, 'pow(2, 6) === 64');
+	t.equal(pow(2, 7), 128, 'pow(2, 7) === 128');
+	t.equal(pow(2, 8), 256, 'pow(2, 8) === 256');
+	t.equal(pow(2, 9), 512, 'pow(2, 9) === 512');
+	t.equal(pow(2, 10), 1024, 'pow(2, 10) === 1024');
+
+	t.end();
+});
+
+test('round', function (t) {
+	t.equal(round(1.1), 1, 'round(1.1) === 1');
+	t.equal(round(1.5), 2, 'round(1.5) === 2');
+	t.equal(round(1.9), 2, 'round(1.9) === 2');
+
+	t.end();
+});
+
+test('sign', function (t) {
+	t.equal(sign(-1), -1, 'sign(-1) === -1');
+	t.equal(sign(+1), +1, 'sign(+1) === +1');
+	t.equal(sign(+0), +0, 'sign(+0) === +0');
+	t.equal(sign(-0), -0, 'sign(-0) === -0');
+	t.equal(sign(NaN), NaN, 'sign(NaN) === NaN');
+	t.equal(sign(Infinity), +1, 'sign(Infinity) === +1');
+	t.equal(sign(-Infinity), -1, 'sign(-Infinity) === -1');
+	t.equal(sign(maxValue), +1, 'sign(maxValue) === +1');
+	t.equal(sign(maxSafeInteger), +1, 'sign(maxSafeInteger) === +1');
+
+	t.end();
+});
+
+test('constants', function (t) {
+	t.equal(typeof maxArrayLength, 'number', 'typeof maxArrayLength === "number"');
+	t.equal(typeof maxSafeInteger, 'number', 'typeof maxSafeInteger === "number"');
+	t.equal(typeof maxValue, 'number', 'typeof maxValue === "number"');
+
+	t.end();
+});

package/node_modules/math-intrinsics/tsconfig.json

@@ -0,0 +1,3 @@
+{
+	"extends": "@ljharb/tsconfig",
+}

package/node_modules/oidc-token-hash/README.md

@@ -17,6 +17,8 @@ oidc-token-hash validates (and generates) ID Token `_hash` claims such as `at_ha
 | HS512, RS512, PS512, ES512 | sha512 | |
 | EdDSA w/ Ed25519 curve | sha512 | [connect/issues#1125](https://bitbucket.org/openid/connect/issues/1125) |
 | EdDSA w/ Ed448 curve | shake256 | [connect/issues#1125](https://bitbucket.org/openid/connect/issues/1125) |
+| Ed25519 | sha512 | [connect/issues#1125](https://bitbucket.org/openid/connect/issues/1125) |
+| Ed448 | shake256 | [connect/issues#1125](https://bitbucket.org/openid/connect/issues/1125) |
 
 ## Usage
 
@@ -28,6 +30,7 @@ const access_token = 'YmJiZTAwYmYtMzgyOC00NzhkLTkyOTItNjJjNDM3MGYzOWIy9sFhvH8K_x
 
 oidcTokenHash.validate({ claim: 'at_hash', source: 'access_token' }, 'x7vk7f6BvQj0jQHYFIk4ag', access_token, 'RS256'); // => does not throw
 oidcTokenHash.validate({ claim: 'at_hash', source: 'access_token' }, 'EGEAhGYyfuwDaVTifvrWSoD5MSy_5hZPy6I7Vm-7pTQ', access_token, 'EdDSA', 'Ed25519'); // => does not throw
+oidcTokenHash.validate({ claim: 'at_hash', source: 'access_token' }, 'EGEAhGYyfuwDaVTifvrWSoD5MSy_5hZPy6I7Vm-7pTQ', access_token, 'Ed25519'); // => does not throw
 oidcTokenHash.validate({ claim: 'at_hash', source: 'access_token' }, 'x7vk7f6BvQj0jQHYFIk4ag', 'foobar', 'RS256'); // => throws AssertionError, message: at_hash mismatch, expected w6uP8Tcg6K2QR905Rms8iQ, got: x7vk7f6BvQj0jQHYFIk4ag
 ```
 
@@ -37,11 +40,14 @@ Generating
 oidcTokenHash.generate(access_token, 'RS256'); // => 'x7vk7f6BvQj0jQHYFIk4ag'
 oidcTokenHash.generate(access_token, 'HS384'); // => 'ups_76_7CCye_J1WIyGHKVG7AAs2olYm'
 oidcTokenHash.generate(access_token, 'ES512'); // => 'EGEAhGYyfuwDaVTifvrWSoD5MSy_5hZPy6I7Vm-7pTQ'
+oidcTokenHash.generate(access_token, 'Ed25519'); // => 'EGEAhGYyfuwDaVTifvrWSoD5MSy_5hZPy6I7Vm-7pTQ'
 oidcTokenHash.generate(access_token, 'EdDSA', 'Ed25519'); // => 'EGEAhGYyfuwDaVTifvrWSoD5MSy_5hZPy6I7Vm-7pTQ'
+oidcTokenHash.generate(access_token, 'Ed448'); // => 'jxsy68_eG9-91VnHsZ2VnCr_WqDMv4nspiSuUPRdNZnv1y5lNV3rPVYYWNiY_TbUB1JRwlgiDTzZ'
 oidcTokenHash.generate(access_token, 'EdDSA', 'Ed448'); // => 'jxsy68_eG9-91VnHsZ2VnCr_WqDMv4nspiSuUPRdNZnv1y5lNV3rPVYYWNiY_TbUB1JRwlgiDTzZ'
 ```
 
 ## Changelog
+- 5.1.0 - add support for Ed25519 and Ed448 JWS Algorithm Identifiers
 - 5.0.2 - avoid use of deprecated String.prototype.substr
 - 5.0.1 - use `base64url` native encoding in Node.js when available
 - 5.0.0 - fixed `Ed448` and `shake256` to use 114 bytes output

package/node_modules/oidc-token-hash/lib/index.js

@@ -49,8 +49,16 @@ function getHash(alg, crv) {
     case 'RS512':
     case 'PS512':
     case 'ES512':
+    case 'Ed25519':
       return createHash('sha512');
 
+    case 'Ed448':
+      if (!shake256) {
+        throw new TypeError('Ed448 *_hash calculation is not supported in your Node.js runtime version');
+      }
+
+      return createHash('shake256', { outputLength: 114 });
+
     case 'EdDSA':
       switch (crv) {
         case 'Ed25519':

package/node_modules/oidc-token-hash/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oidc-token-hash",
-  "version": "5.0.3",
+  "version": "5.1.0",
   "homepage": "https://github.com/panva/oidc-token-hash",
   "bugs": {
     "url": "https://github.com/panva/oidc-token-hash/issues"
@@ -19,9 +19,9 @@
     "test": "node test"
   },
   "devDependencies": {
-    "eslint": "^7.2.0",
-    "eslint-config-airbnb-base": "^14.2.0",
-    "eslint-plugin-import": "^2.21.2",
+    "eslint": "^7.32.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-plugin-import": "^2.28.1",
     "nyc": "^15.1.0"
   },
   "engines": {

package/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/strnum/README.md

@@ -1,6 +1,16 @@
 # 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
 ```
@@ -80,7 +90,8 @@ toNumber("+1212121212", { skipLike: /\+[0-9]{10}/} )); //"+1212121212"
 
 Supported Options
 ```js
-hex :  true, //when hexadecimal string should be parsed
+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
-```
+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/strnum/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strnum",
-  "version": "1.0.5",
+  "version": "1.1.2",
   "description": "Parse String to Number based on configuration",
   "main": "strnum.js",
   "scripts": {
@@ -18,7 +18,13 @@
   },
   "author": "Amit Gupta (https://amitkumargupta.work/)",
   "license": "MIT",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/NaturalIntelligence"
+    }
+  ],
   "devDependencies": {
-    "jasmine": "^3.10.0"
+    "jasmine": "^5.6.0"
   }
 }

package/node_modules/strnum/strnum.js

@@ -1,78 +1,71 @@
 const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
-const numRegex = /^([\-\+])?(0*)(\.[0-9]+([eE]\-?[0-9]+)?|[0-9]+(\.[0-9]+([eE]\-?[0-9]+)?)?)$/;
-// const octRegex = /0x[a-z0-9]+/;
+const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
+// const octRegex = /^0x[a-z0-9]+/;
 // const binRegex = /0x[a-z0-9]+/;
 
-
-//polyfill
-if (!Number.parseInt && window.parseInt) {
-    Number.parseInt = window.parseInt;
-}
-if (!Number.parseFloat && window.parseFloat) {
-    Number.parseFloat = window.parseFloat;
-}
-
-  
+ 
 const consider = {
     hex :  true,
+    // oct: false,
     leadingZeros: true,
     decimalPoint: "\.",
-    eNotation: true
+    eNotation: true,
     //skipLike: /regex/
 };
 
 function toNumber(str, options = {}){
-    // const options = Object.assign({}, consider);
-    // if(opt.leadingZeros === false){
-    //     options.leadingZeros = false;
-    // }else if(opt.hex === false){
-    //     options.hex = false;
-    // }
-
     options = Object.assign({}, consider, options );
     if(!str || typeof str !== "string" ) return str;
     
     let trimmedStr  = str.trim();
-    // if(trimmedStr === "0.0") return 0;
-    // else if(trimmedStr === "+0.0") return 0;
-    // else if(trimmedStr === "-0.0") return -0;
-
+    
     if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
+    else if(str==="0") return 0;
     else if (options.hex && hexRegex.test(trimmedStr)) {
-        return Number.parseInt(trimmedStr, 16);
-    // } else if (options.parseOct && octRegex.test(str)) {
+        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
             
-            const eNotation = match[4] || match[6];
             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(eNotation){ //given number has enotation
-                    if(options.eNotation) return num;
-                    else return str;
                 }else if(trimmedStr.indexOf(".") !== -1){ //floating number
-                    // const decimalPart = match[5].substr(1);
-                    // const intPart = trimmedStr.substr(0,trimmedStr.indexOf("."));
-
-                    
-                    // const p = numStr.indexOf(".");
-                    // const givenIntPart = numStr.substr(0,p);
-                    // const givenDecPart = numStr.substr(p+1);
                     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;
@@ -80,26 +73,11 @@ function toNumber(str, options = {}){
                 }
                 
                 if(leadingZeros){
-                    // if(numTrimmedByZeros === numStr){
-                    //     if(options.leadingZeros) return num;
-                    //     else return str;
-                    // }else return str;
-                    if(numTrimmedByZeros === numStr) return num;
-                    else if(sign+numTrimmedByZeros === numStr) return num;
-                    else return str;
+                    return (numTrimmedByZeros === numStr) || (sign+numTrimmedByZeros === numStr) ? num : str
+                }else  {
+                    return (trimmedStr === numStr) || (trimmedStr === sign+numStr) ? num : str
                 }
-
-                if(trimmedStr === numStr) return num;
-                else if(trimmedStr === sign+numStr) return num;
-                // else{
-                //     //number with +/- sign
-                //     trimmedStr.test(/[-+][0-9]);
-
-                // }
-                return str;
             }
-            // else if(!eNotation && trimmedStr && trimmedStr !== Number(trimmedStr) ) return str;
-            
         }else{ //non-numeric string
             return str;
         }
@@ -121,4 +99,13 @@ function trimZeros(numStr){
     }
     return numStr;
 }
-module.exports = toNumber
+
+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/strnum/strnum.test.js

@@ -1,4 +1,4 @@
-const toNumber = require("./strnum");
+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", () => {
@@ -6,6 +6,8 @@ describe("Should convert all the valid numeric strings to number", () => {
         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");
@@ -34,6 +36,14 @@ describe("Should convert all the valid numeric strings to number", () => {
         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");
@@ -51,11 +61,12 @@ describe("Should convert all the valid numeric strings to 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.");
-        expect(toNumber("0.")  ).toEqual("0.");
-        expect(toNumber("1.")  ).toEqual("1.");
     });
     it("floating point and leading zeros", () => {
-        expect(toNumber("0.0")).toEqual(0);
+        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);
@@ -108,10 +119,13 @@ describe("Should convert all the valid numeric strings to number", () => {
 
         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", () => {
@@ -126,6 +140,7 @@ describe("Should convert all the valid numeric strings to number", () => {
     });
     
     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");

package/package.json

@@ -40,13 +40,13 @@
     "organization": false
   },
   "devDependencies": {
-    "@aws-sdk/types": "^3.696.0",
+    "@aws-sdk/types": "^3.734.0",
     "@axe-core/playwright": "^4.10.1",
-    "@gemeentenijmegen/projen-project-type": "^1.8.4",
+    "@gemeentenijmegen/projen-project-type": "^1.8.7",
     "@glen/jest-raw-loader": "^2.0.0",
-    "@playwright/test": "^1.49.0",
+    "@playwright/test": "^1.50.1",
     "@stylistic/eslint-plugin": "^2",
-    "@types/aws-lambda": "^8.10.146",
+    "@types/aws-lambda": "^8.10.147",
     "@types/jest": "^27",
     "@types/mustache": "^4.2.5",
     "@types/node": "^16 <= 16.18.78",
@@ -58,18 +58,18 @@
     "commit-and-tag-version": "^12",
     "constructs": "10.0.5",
     "copyfiles": "^2.4.1",
-    "esbuild": "^0.24.0",
+    "esbuild": "^0.25.0",
     "eslint": "^9",
-    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint-import-resolver-typescript": "^3.8.3",
     "eslint-plugin-import": "^2.31.0",
     "jest": "^27",
-    "jest-junit": "^15",
+    "jest-junit": "^16",
     "jsii": "~5.5.0",
-    "jsii-diff": "^1.105.0",
+    "jsii-diff": "^1.108.0",
     "jsii-docgen": "^10.5.0",
-    "jsii-pacmak": "^1.105.0",
+    "jsii-pacmak": "^1.108.0",
     "jsii-rosetta": "~5.5.0",
-    "projen": "^0.90.6",
+    "projen": "^0.91.13",
     "ts-jest": "^27",
     "typescript": "^5.6.2"
   },
@@ -79,15 +79,15 @@
   },
   "dependencies": {
     "@aws-lambda-powertools/logger": "^1.17.0",
-    "@aws-sdk/client-dynamodb": "^3.705.0",
-    "@aws-sdk/client-secrets-manager": "^3.699.0",
-    "@aws-solutions-constructs/aws-lambda-dynamodb": "^2.74.0",
-    "@gemeentenijmegen/apiclient": "^0.0.21",
-    "@gemeentenijmegen/apigateway-http": "^0.0.18",
-    "@gemeentenijmegen/aws-constructs": "^0.0.24",
-    "@gemeentenijmegen/session": "^0.0.18",
-    "@gemeentenijmegen/utils": "^0.0.20",
-    "axios": "^1.7.9",
+    "@aws-sdk/client-dynamodb": "^3.758.0",
+    "@aws-sdk/client-secrets-manager": "^3.758.0",
+    "@aws-solutions-constructs/aws-lambda-dynamodb": "^2.77.0",
+    "@gemeentenijmegen/apiclient": "^0.0.27",
+    "@gemeentenijmegen/apigateway-http": "^0.0.22",
+    "@gemeentenijmegen/aws-constructs": "^0.0.30",
+    "@gemeentenijmegen/session": "^0.0.22",
+    "@gemeentenijmegen/utils": "^0.0.25",
+    "axios": "^1.8.1",
     "cdk-remote-stack": "^2.1.0",
     "cookie": "^0.7.2",
     "dotenv": "^16.4.7",
@@ -118,7 +118,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.3",
+  "version": "1.1.5",
   "jest": {
     "coverageProvider": "v8",
     "setupFiles": [