@gemeentenijmegen/webapp 1.1.14 → 1.1.15

package/node_modules/path-expression-matcher/src/index.d.ts

@@ -188,6 +188,153 @@ export interface MatcherSnapshot {
   siblingStacks: Map<string, number>[];
 }
 
+/**
+ * ReadOnlyMatcher - A safe, read-only view over a {@link Matcher} instance.
+ *
+ * Returned by {@link Matcher.readOnly}. Exposes all query and inspection
+ * methods but **throws a `TypeError`** if any state-mutating method is called
+ * (`push`, `pop`, `reset`, `updateCurrent`, `restore`).  Direct property
+ * writes are also blocked.
+ *
+ * Pass this to consumers that only need to inspect or match the current path
+ * so they cannot accidentally corrupt the parser state.
+ *
+ * @example
+ * ```typescript
+ * const matcher = new Matcher();
+ * matcher.push("root", {});
+ * matcher.push("users", {});
+ * matcher.push("user", { id: "123" });
+ *
+ * const ro: ReadOnlyMatcher = matcher.readOnly();
+ *
+ * ro.matches(expr);      // ✓ works
+ * ro.getCurrentTag();    // ✓ "user"
+ * ro.getDepth();         // ✓ 3
+ * ro.push("child", {}); // ✗ TypeError: Cannot call 'push' on a read-only Matcher
+ * ro.reset();            // ✗ TypeError: Cannot call 'reset' on a read-only Matcher
+ * ```
+ */
+export interface ReadOnlyMatcher {
+  /**
+   * Default path separator (read-only)
+   */
+  readonly separator: string;
+
+  /**
+   * Current path stack (each node is a frozen copy)
+   */
+  readonly path: ReadonlyArray<Readonly<PathNode>>;
+
+  // ── Query methods ───────────────────────────────────────────────────────────
+
+  /**
+   * Get current tag name
+   * @returns Current tag name or undefined if path is empty
+   */
+  getCurrentTag(): string | undefined;
+
+  /**
+   * Get current namespace
+   * @returns Current namespace or undefined if not present or path is empty
+   */
+  getCurrentNamespace(): string | undefined;
+
+  /**
+   * Get current node's attribute value
+   * @param attrName - Attribute name
+   * @returns Attribute value or undefined
+   */
+  getAttrValue(attrName: string): any;
+
+  /**
+   * Check if current node has an attribute
+   * @param attrName - Attribute name
+   */
+  hasAttr(attrName: string): boolean;
+
+  /**
+   * Get current node's sibling position (child index in parent)
+   * @returns Position index or -1 if path is empty
+   */
+  getPosition(): number;
+
+  /**
+   * Get current node's repeat counter (occurrence count of this tag name)
+   * @returns Counter value or -1 if path is empty
+   */
+  getCounter(): number;
+
+  /**
+   * Get current node's sibling index (alias for getPosition for backward compatibility)
+   * @returns Index or -1 if path is empty
+   * @deprecated Use getPosition() or getCounter() instead
+   */
+  getIndex(): number;
+
+  /**
+   * Get current path depth
+   * @returns Number of nodes in the path
+   */
+  getDepth(): number;
+
+  /**
+   * Get path as string
+   * @param separator - Optional separator (uses default if not provided)
+   * @param includeNamespace - Whether to include namespace in output
+   * @returns Path string (e.g., "root.users.user" or "ns:root.ns:users.user")
+   */
+  toString(separator?: string, includeNamespace?: boolean): string;
+
+  /**
+   * Get path as array of tag names
+   * @returns Array of tag names
+   */
+  toArray(): string[];
+
+  /**
+   * Match current path against an Expression
+   * @param expression - The expression to match against
+   * @returns True if current path matches the expression
+   */
+  matches(expression: Expression): boolean;
+
+  /**
+   * Create a snapshot of current state
+   * @returns State snapshot that can be restored later
+   */
+  snapshot(): MatcherSnapshot;
+
+  // ── Blocked mutating methods ────────────────────────────────────────────────
+  // These are present in the type so callers get a compile-time error with a
+  // helpful message instead of a silent "property does not exist" error.
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  push(tagName: string, attrValues?: Record<string, any> | null, namespace?: string | null): never;
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  pop(): never;
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  updateCurrent(attrValues: Record<string, any>): never;
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  reset(): never;
+
+  /**
+   * @throws {TypeError} Always – mutation is not allowed on a read-only view.
+   */
+  restore(snapshot: MatcherSnapshot): never;
+}
+
 /**
  * Matcher - Tracks current path in XML/JSON tree and matches against Expressions
  * 
@@ -353,6 +500,11 @@ export class Matcher {
    * @param snapshot - State snapshot from previous snapshot() call
    */
   restore(snapshot: MatcherSnapshot): void;
+
+  /**
+   * Return a read-only view of this matcher.
+   */
+  readOnly(): ReadOnlyMatcher;
 }
 
 /**

package/node_modules/proxy-from-env/README.md

@@ -1,15 +1,25 @@
 # proxy-from-env
 
-[![Build Status](https://travis-ci.org/Rob--W/proxy-from-env.svg?branch=master)](https://travis-ci.org/Rob--W/proxy-from-env)
+![Build Status](https://github.com/Rob--W/proxy-from-env/actions/workflows/run-tests.yaml/badge.svg?branch=master)
 [![Coverage Status](https://coveralls.io/repos/github/Rob--W/proxy-from-env/badge.svg?branch=master)](https://coveralls.io/github/Rob--W/proxy-from-env?branch=master)
 
 `proxy-from-env` is a Node.js package that exports a function (`getProxyForUrl`)
-that takes an input URL (a string or
-[`url.parse`](https://nodejs.org/docs/latest/api/url.html#url_url_parsing)'s
+that takes an input URL (a string, an instance of
+[`URL`](https://nodejs.org/docs/latest/api/url.html#the-whatwg-url-api),
+or [`url.parse`](https://nodejs.org/docs/latest/api/url.html#url_url_parsing)'s
 return value) and returns the desired proxy URL (also a string) based on
 standard proxy environment variables. If no proxy is set, an empty string is
 returned.
 
+If your application makes important (security) decisions based on the URL, be
+consistent in the mechanism to parse and validate URLs, as differences in URL
+parsing behavior can affect the outcome of proxy resolution.
+Strings are parsed with the standard `URL` API, as of `proxy-from-env@2.0.0`.
+Older versions relied on the (now deprecated) `url.parse` method instead.
+
+Invalid values in environment variables are not handled by the library
+([#41](https://github.com/Rob--W/proxy-from-env/issues/41)).
+
 It is your responsibility to actually proxy the request using the given URL.
 
 Installation:
@@ -22,10 +32,14 @@ npm install proxy-from-env
 This example shows how the data for a URL can be fetched via the
 [`http` module](https://nodejs.org/api/http.html), in a proxy-aware way.
 
+warning: this simple example works for http requests only. To support https,
+you must establish a proxy tunnel via the
+[http `connect` method](https://developer.mozilla.org/en-us/docs/web/http/reference/methods/connect).
+
 ```javascript
-var http = require('http');
-var parseUrl = require('url').parse;
-var getProxyForUrl = require('proxy-from-env').getProxyForUrl;
+import http from 'node:test';
+import { getProxyForUrl } from 'proxy-from-env';
+// ^ or: var getProxyForUrl = require('proxy-from-env').getProxyForUrl;
 
 var some_url = 'http://example.com/something';
 
@@ -40,8 +54,8 @@ var some_url = 'http://example.com/something';
 var proxy_url = getProxyForUrl(some_url);  // <-- Our magic.
 if (proxy_url) {
   // Should be proxied through proxy_url.
-  var parsed_some_url = parseUrl(some_url);
-  var parsed_proxy_url = parseUrl(proxy_url);
+  var parsed_some_url = new URL(some_url);
+  var parsed_proxy_url = new URL(proxy_url);
   // A HTTP proxy is quite simple. It is similar to a normal request, except the
   // path is an absolute URL, and the proxied URL's host is put in the header
   // instead of the server's actual host.
@@ -63,12 +77,30 @@ http.get(httpOptions, function(res) {
   res.on('data', function(chunk) { responses.push(chunk); });
   res.on('end', function() { console.log(responses.join(''));  });
 });
-
 ```
 
+### Full proxy support
+The simple example above works for http requests only. To support https, you
+must establish a proxy tunnel via the
+[http `connect` method](https://developer.mozilla.org/en-us/docs/web/http/reference/methods/connect).
+
+An example of that is shown in the
+[`https-proxy-agent` npm package](https://www.npmjs.com/package/https-proxy-agent).
+The [`proxy-agent` npm package](https://www.npmjs.com/package/proxy-agent)
+combines `https-proxy-agent` and `proxy-from-env` to offer a `http.Agent` that
+supports proxies from environment variables.
+
+### Built-in proxy support
+Node.js is working on built-in support for proxy environment variables,
+currently behind `NODE_USE_ENV_PROXY=1` or `--use-env-proxy`. For details, see:
+
+- https://github.com/nodejs/node/issues/57872
+- https://nodejs.org/api/http.html#built-in-proxy-support
+
+
 ## Environment variables
-The environment variables can be specified in lowercase or uppercase, with the
-lowercase name having precedence over the uppercase variant. A variable that is
+The environment variables can be specified in all lowercase or all uppercase,
+with lowercase taking precedence over the uppercase variant. A variable that is
 not set has the same meaning as a variable that is set but has no value.
 
 ### NO\_PROXY

package/node_modules/proxy-from-env/index.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+var DEFAULT_PORTS = {
+  ftp: 21,
+  gopher: 70,
+  http: 80,
+  https: 443,
+  ws: 80,
+  wss: 443,
+};
+
+function parseUrl(urlString) {
+  try {
+    return new URL(urlString);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string|object|URL} url - The URL as a string or URL instance, or a
+ *   compatible object (such as the result from legacy url.parse).
+ * @return {string} The URL of the proxy that should handle the request to the
+ *  given URL. If no proxy is set, this will be an empty string.
+ */
+function getProxyForUrl(url) {
+  var parsedUrl = (typeof url === 'string' ? parseUrl(url) : url) || {};
+  var proto = parsedUrl.protocol;
+  var hostname = parsedUrl.host;
+  var port = parsedUrl.port;
+  if (typeof hostname !== 'string' || !hostname || typeof proto !== 'string') {
+    return '';  // Don't proxy URLs without a valid scheme or host.
+  }
+
+  proto = proto.split(':', 1)[0];
+  // Stripping ports in this way instead of using parsedUrl.hostname to make
+  // sure that the brackets around IPv6 addresses are kept.
+  hostname = hostname.replace(/:\d*$/, '');
+  port = parseInt(port) || DEFAULT_PORTS[proto] || 0;
+  if (!shouldProxy(hostname, port)) {
+    return '';  // Don't proxy URLs that match NO_PROXY.
+  }
+
+  var proxy = getEnv(proto + '_proxy') || getEnv('all_proxy');
+  if (proxy && proxy.indexOf('://') === -1) {
+    // Missing scheme in proxy, default to the requested URL's scheme.
+    proxy = proto + '://' + proxy;
+  }
+  return proxy;
+}
+
+/**
+ * Determines whether a given URL should be proxied.
+ *
+ * @param {string} hostname - The host name of the URL.
+ * @param {number} port - The effective port of the URL.
+ * @returns {boolean} Whether the given URL should be proxied.
+ * @private
+ */
+function shouldProxy(hostname, port) {
+  var NO_PROXY = getEnv('no_proxy').toLowerCase();
+  if (!NO_PROXY) {
+    return true;  // Always proxy if NO_PROXY is not set.
+  }
+  if (NO_PROXY === '*') {
+    return false;  // Never proxy if wildcard is set.
+  }
+
+  return NO_PROXY.split(/[,\s]/).every(function(proxy) {
+    if (!proxy) {
+      return true;  // Skip zero-length hosts.
+    }
+    var parsedProxy = proxy.match(/^(.+):(\d+)$/);
+    var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
+    var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
+    if (parsedProxyPort && parsedProxyPort !== port) {
+      return true;  // Skip if ports don't match.
+    }
+
+    if (!/^[.*]/.test(parsedProxyHostname)) {
+      // No wildcards, so stop proxying if there is an exact match.
+      return hostname !== parsedProxyHostname;
+    }
+
+    if (parsedProxyHostname.charAt(0) === '*') {
+      // Remove leading wildcard.
+      parsedProxyHostname = parsedProxyHostname.slice(1);
+    }
+    // Stop proxying if the hostname ends with the no_proxy host.
+    return !hostname.endsWith(parsedProxyHostname);
+  });
+}
+
+/**
+ * Get the value for an environment variable.
+ *
+ * @param {string} key - The name of the environment variable.
+ * @return {string} The value of the environment variable.
+ * @private
+ */
+function getEnv(key) {
+  return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';
+}
+
+exports.getProxyForUrl = getProxyForUrl;

package/node_modules/proxy-from-env/index.js

@@ -1,7 +1,5 @@
 'use strict';
 
-var parseUrl = require('url').parse;
-
 var DEFAULT_PORTS = {
   ftp: 21,
   gopher: 70,
@@ -11,18 +9,22 @@ var DEFAULT_PORTS = {
   wss: 443,
 };
 
-var stringEndsWith = String.prototype.endsWith || function(s) {
-  return s.length <= this.length &&
-    this.indexOf(s, this.length - s.length) !== -1;
-};
+function parseUrl(urlString) {
+  try {
+    return new URL(urlString);
+  } catch {
+    return null;
+  }
+}
 
 /**
- * @param {string|object} url - The URL, or the result from url.parse.
+ * @param {string|object|URL} url - The URL as a string or URL instance, or a
+ *   compatible object (such as the result from legacy url.parse).
  * @return {string} The URL of the proxy that should handle the request to the
  *  given URL. If no proxy is set, this will be an empty string.
  */
-function getProxyForUrl(url) {
-  var parsedUrl = typeof url === 'string' ? parseUrl(url) : url || {};
+export function getProxyForUrl(url) {
+  var parsedUrl = (typeof url === 'string' ? parseUrl(url) : url) || {};
   var proto = parsedUrl.protocol;
   var hostname = parsedUrl.host;
   var port = parsedUrl.port;
@@ -39,11 +41,7 @@ function getProxyForUrl(url) {
     return '';  // Don't proxy URLs that match NO_PROXY.
   }
 
-  var proxy =
-    getEnv('npm_config_' + proto + '_proxy') ||
-    getEnv(proto + '_proxy') ||
-    getEnv('npm_config_proxy') ||
-    getEnv('all_proxy');
+  var proxy = getEnv(proto + '_proxy') || getEnv('all_proxy');
   if (proxy && proxy.indexOf('://') === -1) {
     // Missing scheme in proxy, default to the requested URL's scheme.
     proxy = proto + '://' + proxy;
@@ -60,8 +58,7 @@ function getProxyForUrl(url) {
  * @private
  */
 function shouldProxy(hostname, port) {
-  var NO_PROXY =
-    (getEnv('npm_config_no_proxy') || getEnv('no_proxy')).toLowerCase();
+  var NO_PROXY = getEnv('no_proxy').toLowerCase();
   if (!NO_PROXY) {
     return true;  // Always proxy if NO_PROXY is not set.
   }
@@ -90,7 +87,7 @@ function shouldProxy(hostname, port) {
       parsedProxyHostname = parsedProxyHostname.slice(1);
     }
     // Stop proxying if the hostname ends with the no_proxy host.
-    return !stringEndsWith.call(hostname, parsedProxyHostname);
+    return !hostname.endsWith(parsedProxyHostname);
   });
 }
 
@@ -104,5 +101,3 @@ function shouldProxy(hostname, port) {
 function getEnv(key) {
   return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';
 }
-
-exports.getProxyForUrl = getProxyForUrl;

package/node_modules/proxy-from-env/package.json

@@ -1,16 +1,23 @@
 {
   "name": "proxy-from-env",
-  "version": "1.1.0",
+  "version": "2.1.0",
   "description": "Offers getProxyForUrl to get the proxy URL for a URL, respecting the *_PROXY (e.g. HTTP_PROXY) and NO_PROXY environment variables.",
-  "main": "index.js",
+  "main": "index.cjs",
+  "exports": {
+    "import": "./index.js",
+    "require": "./index.cjs"
+  },
+  "files": ["index.js", "index.cjs"],
   "scripts": {
-    "lint": "eslint *.js",
-    "test": "mocha ./test.js --reporter spec",
-    "test-coverage": "istanbul cover ./node_modules/.bin/_mocha -- --reporter spec"
+    "lint": "eslint *.js *.mjs *.cjs",
+    "test": "node --test ./test.js",
+    "test-require": "node ./test-require.cjs",
+    "test-coverage": "node --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info ./test.js",
+    "test-coverage-as-html": "npm run test-coverage && genhtml lcov.info -o coverage/"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Rob--W/proxy-from-env.git"
+    "url": "git+https://github.com/Rob--W/proxy-from-env.git"
   },
   "keywords": [
     "proxy",
@@ -26,9 +33,11 @@
   },
   "homepage": "https://github.com/Rob--W/proxy-from-env#readme",
   "devDependencies": {
-    "coveralls": "^3.0.9",
-    "eslint": "^6.8.0",
-    "istanbul": "^0.4.5",
-    "mocha": "^7.1.0"
-  }
+    "eslint": "^9.39.2"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=10"
+  },
+  "sideEffects": false
 }

package/node_modules/strnum/CHANGELOG.md

@@ -1,6 +1,13 @@
 
-**2.1.1 / 2025-05-15**
-- remove unnecessary check to remove lint error
+**2.2.2 / 2026-03-23**
+- fix for space string
+
+
+**2.2.1 / 2026-03-19**
+- fix false positive for eNotation when no leading zeros
+
+**2.2.0 / 2026-02-28**
+- support infinity
 
 **2.1.0 / 2025-05-01**
 - fix e-notation 

package/node_modules/strnum/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strnum",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Parse String to Number based on configuration",
   "type": "module",
   "main": "strnum.js",

package/node_modules/strnum/strnum.js

@@ -20,8 +20,9 @@ export default function toNumber(str, options = {}) {
 
     let trimmedStr = str.trim();
 
-    if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
-    else if (str === "0") return 0;
+    if (trimmedStr.length === 0) return str;
+    else if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
+    else if (trimmedStr === "0") return 0;
     else if (options.hex && hexRegex.test(trimmedStr)) {
         return parse_int(trimmedStr, 16);
         // }else if (options.oct && octRegex.test(str)) {
@@ -97,11 +98,16 @@ function resolveEnotation(str, trimmedStr, options) {
         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];
+        } else if (leadingZeros.length > 0) {
+            // Has leading zeros — only accept if leadingZeros option allows it
+            if (options.leadingZeros && !eAdjacentToLeadingZeros) {
+                trimmedStr = (notation[1] || "") + notation[3];
+                return Number(trimmedStr);
+            } else return str;
+        } else {
+            // No leading zeros — always valid e-notation, parse it
             return Number(trimmedStr);
-        } else return str;
+        }
     } else {
         return str;
     }

package/node_modules/strnum/tests/strnum_test.js

@@ -5,6 +5,7 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber(undefined)).not.toBeDefined();
         expect(toNumber(null)).toEqual(null);
         expect(toNumber("")).toEqual("");
+        expect(toNumber(" ")).toEqual(" ");
         expect(toNumber("string")).toEqual("string");
         expect(toNumber("e89794659669cb7bb967db73a7ea6889c3891727")).toEqual("e89794659669cb7bb967db73a7ea6889c3891727");
     });
@@ -126,6 +127,8 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("1e-2")).toEqual(0.01);
         expect(toNumber("1e+2")).toEqual(100);
         expect(toNumber("1.e+2")).toEqual(100);
+
+        expect(toNumber("1.5e3", { leadingZeros: false })).toEqual(1500);
     });
 
     it("scientific notation with upper E", () => {

package/node_modules/strnum/tests/temp.js

@@ -0,0 +1,8 @@
+import toNumber from "../strnum.js";
+
+console.log(toNumber("1.5e3", {leadingZeros: false}))
+// describe("temp", () = {
+
+//   it("scientific notation", () => {
+//     });
+// })

package/package.json

@@ -45,7 +45,7 @@
     "@axe-core/playwright": "^4.11.1",
     "@gemeentenijmegen/projen-project-type": "^1.12.2",
     "@glen/jest-raw-loader": "^2.0.0",
-    "@playwright/test": "^1.58.2",
+    "@playwright/test": "^1.59.1",
     "@stylistic/eslint-plugin": "^2",
     "@types/aws-lambda": "^8.10.161",
     "@types/jest": "^27",
@@ -81,15 +81,15 @@
   },
   "dependencies": {
     "@aws-lambda-powertools/logger": "^1.17.0",
-    "@aws-sdk/client-dynamodb": "^3.1011.0",
-    "@aws-sdk/client-secrets-manager": "^3.1011.0",
+    "@aws-sdk/client-dynamodb": "^3.1022.0",
+    "@aws-sdk/client-secrets-manager": "^3.1022.0",
     "@aws-solutions-constructs/aws-lambda-dynamodb": "^2.100.1",
     "@gemeentenijmegen/apiclient": "^0.0.41",
     "@gemeentenijmegen/apigateway-http": "^0.0.37",
     "@gemeentenijmegen/aws-constructs": "^0.0.49",
     "@gemeentenijmegen/session": "^0.0.35",
     "@gemeentenijmegen/utils": "^0.0.38",
-    "axios": "^1.13.6",
+    "axios": "^1.14.0",
     "cdk-remote-stack": "^2.1.0",
     "cookie": "^0.7.2",
     "dotenv": "^16.6.1",
@@ -121,7 +121,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.14",
+  "version": "1.1.15",
   "jest": {
     "coverageProvider": "v8",
     "setupFiles": [