@suveren/gateway 0.29.0 → 0.30.0

package/node_modules/qs/test/utils.js

@@ -106,6 +106,146 @@ test('merge()', function (t) {
             s2t.end();
         });
 
+        st.test('with strictMerge, repeated conflicts append instead of nesting a new wrapper', function (s2t) {
+            var opts = { strictMerge: true };
+            var wrapped = utils.merge({ foo: 'bar' }, 'baz', opts);
+            s2t.deepEqual(wrapped, [{ foo: 'bar' }, 'baz'], 'first conflict wraps in an array');
+
+            var withObject = utils.merge(wrapped, { qux: 'quux' }, opts);
+            s2t.deepEqual(
+                withObject,
+                { 0: { foo: 'bar' }, 1: 'baz', qux: 'quux' },
+                'merging an object converts the wrapper to an object'
+            );
+
+            var second = utils.merge(withObject, 'corge', opts);
+            s2t.deepEqual(
+                second,
+                { 0: { foo: 'bar' }, 1: 'baz', 2: 'corge', qux: 'quux' },
+                'a second conflict appends at the next index'
+            );
+
+            var third = utils.merge(second, 'grault', opts);
+            s2t.deepEqual(
+                third,
+                { 0: { foo: 'bar' }, 1: 'baz', 2: 'corge', 3: 'grault', qux: 'quux' },
+                'a third conflict appends again, so nesting depth stays constant'
+            );
+
+            s2t.end();
+        });
+
+        st.test('with strictMerge, a caller-supplied array is still wrapped, not appended to', function (s2t) {
+            var merged = utils.merge({ 0: 'a', 1: 'b' }, 'c', { strictMerge: true });
+            s2t.deepEqual(merged, [{ 0: 'a', 1: 'b' }, 'c'], 'an unmarked object with numeric keys is wrapped');
+            s2t.end();
+        });
+
+        st.test('with strictMerge, throws instead of appending a conflict past arrayLimit with throwOnLimitExceeded', function (s2t) {
+            var appendConflict = function (options) {
+                var wrapped = utils.merge({ foo: 'bar' }, 'baz', { strictMerge: true });
+                var container = utils.merge(wrapped, { qux: 'quux' }, { strictMerge: true });
+                return utils.merge(container, 'corge', options);
+            };
+
+            s2t['throws'](
+                function () { appendConflict({ strictMerge: true, arrayLimit: 1, throwOnLimitExceeded: true }); },
+                new RangeError('Array limit exceeded. Only 1 element allowed in an array.'),
+                'appending to a two-element container past arrayLimit throws'
+            );
+            s2t['throws'](
+                function () { appendConflict({ strictMerge: true, arrayLimit: 2, throwOnLimitExceeded: true }); },
+                new RangeError('Array limit exceeded. Only 2 elements allowed in an array.'),
+                'uses the plural message when arrayLimit is not 1'
+            );
+            s2t.deepEqual(
+                appendConflict({ strictMerge: true, arrayLimit: 3, throwOnLimitExceeded: true }),
+                { 0: { foo: 'bar' }, 1: 'baz', 2: 'corge', qux: 'quux' },
+                'appends while the container stays within arrayLimit'
+            );
+            s2t.deepEqual(
+                appendConflict({ strictMerge: true, arrayLimit: 1 }),
+                { 0: { foo: 'bar' }, 1: 'baz', 2: 'corge', qux: 'quux' },
+                'still appends past arrayLimit without throwOnLimitExceeded, since the container is already an object'
+            );
+
+            s2t.end();
+        });
+
+        st.test('with strictMerge, a conflict appends after numeric keys already in its container', function (s2t) {
+            var opts = { strictMerge: true };
+
+            var container = utils.merge(utils.merge({ foo: 'bar' }, 'baz', opts), { qux: 'quux' }, opts);
+            var withIndex = utils.merge(container, { 2: 'keep' }, opts);
+            s2t.deepEqual(
+                utils.merge(withIndex, 'corge', opts),
+                { 0: { foo: 'bar' }, 1: 'baz', 2: 'keep', 3: 'corge', qux: 'quux' },
+                'a numeric key merged into the container is not overwritten'
+            );
+
+            var sparse = [];
+            sparse[2] = 'keep';
+            var extended = utils.merge(utils.merge({ foo: 'bar' }, 'baz', opts), sparse, opts);
+            s2t.deepEqual(extended, [{ foo: 'bar' }, 'baz', 'keep'], 'an indexed value extends the container while it is an array');
+            var converted = utils.merge(extended, { qux: 'quux' }, opts);
+            s2t.deepEqual(
+                utils.merge(converted, 'corge', opts),
+                { 0: { foo: 'bar' }, 1: 'baz', 2: 'keep', 3: 'corge', qux: 'quux' },
+                'converting the container to an object keeps its last index'
+            );
+
+            s2t.end();
+        });
+
+        st.test('enforces arrayLimit on the two-element array built for colliding values', function (s2t) {
+            s2t['throws'](
+                function () { utils.merge({ foo: 'bar' }, 'baz', { strictMerge: true, arrayLimit: 1, throwOnLimitExceeded: true }); },
+                new RangeError('Array limit exceeded. Only 1 element allowed in an array.'),
+                'a strictMerge conflict throws at arrayLimit 1'
+            );
+            s2t['throws'](
+                function () { utils.merge('a', 'b', { arrayLimit: 0, throwOnLimitExceeded: true }); },
+                new RangeError('Array limit exceeded. Only 0 elements allowed in an array.'),
+                'two colliding primitives throw at arrayLimit 0'
+            );
+
+            var conflict = utils.merge({ foo: 'bar' }, 'baz', { strictMerge: true, arrayLimit: 1 });
+            s2t.ok(utils.isOverflow(conflict), 'without throwOnLimitExceeded, a strictMerge conflict converts to an overflow object');
+            s2t.deepEqual(conflict, { 0: { foo: 'bar' }, 1: 'baz' }, 'holding both values');
+
+            var pair = utils.merge('a', 'b', { arrayLimit: 1 });
+            s2t.ok(utils.isOverflow(pair), 'without throwOnLimitExceeded, two colliding primitives convert to an overflow object');
+            s2t.deepEqual(pair, { 0: 'a', 1: 'b' }, 'holding both values');
+
+            s2t.deepEqual(
+                utils.merge({ foo: 'bar' }, 'baz', { strictMerge: true, arrayLimit: 2, throwOnLimitExceeded: true }),
+                [{ foo: 'bar' }, 'baz'],
+                'a strictMerge conflict within arrayLimit is still an array'
+            );
+            s2t.deepEqual(
+                utils.merge('a', 'b', { arrayLimit: 2, throwOnLimitExceeded: true }),
+                ['a', 'b'],
+                'two colliding primitives within arrayLimit are still an array'
+            );
+
+            s2t.end();
+        });
+
+        st.test('seeds an overflow container index from the keys it already holds', function (s2t) {
+            var overflow = utils.combine(['a'], 'b', 0, false);
+            s2t.ok(utils.isOverflow(overflow), 'the source is an overflow object');
+
+            var merged = utils.merge({ 2: 'keep', z: 'zz' }, overflow);
+            s2t.ok(utils.isOverflow(merged), 'the result is marked as overflow');
+            s2t.deepEqual(
+                utils.merge(merged, 'c'),
+                { 0: 'a', 1: 'b', 2: 'keep', 3: 'c', z: 'zz' },
+                'the next value lands after the highest numeric key the container already held'
+            );
+
+            s2t.end();
+        });
+
         st.test('merges overflow object into primitive', function (s2t) {
             // Create an overflow object via combine: 2 elements (indices 0-1) with limit 0
             var overflow = utils.combine(['a'], 'b', 0, false);
@@ -441,6 +581,50 @@ test('decode', function (t) {
         'decodes a string in iso-8859-1'
     );
 
+    t.test('strings with no percent sign', function (st) {
+        st.equal(utils.decode(''), '', 'empty string');
+        st.equal(utils.decode('abc'), 'abc', 'returns a plain string unchanged');
+        st.equal(utils.decode('abc', null, 'iso-8859-1'), 'abc', 'returns a plain string unchanged in iso-8859-1');
+        st.equal(utils.decode('a++b+'), 'a  b ', 'decodes every + to a space');
+        st.equal(utils.decode('a++b+', null, 'iso-8859-1'), 'a  b ', 'decodes every + to a space in iso-8859-1');
+        st.equal(utils.decode('\uD800x\uDC00'), '\uD800x\uDC00', 'leaves lone surrogates unchanged');
+        st.equal(utils.decode('😀+'), '😀 ', 'leaves surrogate pairs unchanged');
+        st.equal(utils.decode('a=b&c'), 'a=b&c', 'leaves delimiters unchanged');
+
+        st.end();
+    });
+
+    t.test('strings with a percent sign', function (st) {
+        st.equal(utils.decode('a+%20b'), 'a  b', 'decodes both + and an escape');
+        st.equal(utils.decode('%E9+x', null, 'iso-8859-1'), 'é x', 'decodes both + and an escape in iso-8859-1');
+        st.equal(utils.decode('a+%'), 'a %', 'decodes + even when the escape is malformed');
+        st.equal(utils.decode('a+%E0%A4%A'), 'a %E0%A4%A', 'decodes + even when the escape is truncated');
+
+        st.end();
+    });
+
+    t.test('non-strings', function (st) {
+        forEach(v.nullPrimitives, function (nullish) {
+            st['throws'](
+                function () { utils.decode(nullish); },
+                TypeError,
+                inspect(nullish) + ' is not a string'
+            );
+        });
+        st['throws'](
+            function () { utils.decode(['a']); },
+            TypeError,
+            'an array is not a string'
+        );
+
+        /* eslint no-new-wrappers: 0 */
+        st.equal(utils.decode(new String('ab')), 'ab', 'a boxed string decodes to a primitive');
+        st.equal(utils.decode(new String('a+b')), 'a b', 'a boxed string with + decodes to a primitive');
+        st.equal(utils.decode(new String('a%20b')), 'a b', 'a boxed string with an escape decodes to a primitive');
+
+        st.end();
+    });
+
     t.end();
 });
 

package/node_modules/sanitize-html/index.js

@@ -1,7 +1,6 @@
 const htmlparser = require('htmlparser2');
 const escapeStringRegexp = require('escape-string-regexp');
 const { isPlainObject } = require('is-plain-object');
-const deepmerge = require('deepmerge');
 const parseSrcset = require('parse-srcset');
 const { parse: postcssParse } = require('postcss');
 const { naughtyHref: launderNaughtyHref } = require('launder');
@@ -53,6 +52,29 @@ function has(obj, key) {
   return ({}).hasOwnProperty.call(obj, key);
 }
 
+// Combine the tag-specific and wildcard lists of allowed classes
+function mergeClasses(specific, wildcard) {
+  if (!Array.isArray(specific) || !Array.isArray(wildcard)) {
+    return wildcard;
+  }
+  return specific.concat(wildcard);
+}
+
+// Combine the tag-specific and wildcard allowed styles, concatenating the
+// lists of regular expressions for properties that appear in both. The result
+// has no prototype, so a property named `__proto__` is just another property
+function mergeStyles(specific, wildcard) {
+  const merged = Object.create(null);
+  for (const rules of [ specific, wildcard ]) {
+    for (const prop of Object.keys(rules)) {
+      merged[prop] = has(merged, prop)
+        ? merged[prop].concat(rules[prop])
+        : rules[prop];
+    }
+  }
+  return merged;
+}
+
 // Returns those elements of `a` for which `cb(a)` returns truthy
 function filter(a, cb) {
   const n = [];
@@ -103,14 +125,23 @@ module.exports = sanitizeHtml;
 // attribute name state with an empty attribute name buffer.
 const VALID_HTML_ATTRIBUTE_NAME = /^[^\0\t\n\f\r /<=>]+$/;
 
-// Ignore the _recursing flag; it's there for recursive
-// invocation as a guard against this exploit:
-// https://github.com/fb55/htmlparser2/issues/105
+// How many discarded <iframe> elements can be nested while their fallback
+// markup is still re-sanitized as HTML (see the `ontext` handler). Deeper
+// fallback is escaped as text, so that crafted input cannot recurse without
+// bound or re-parse the remainder of the input once per iframe
+// (GHSA-c9rx-x947-fp3h).
+const MAX_IFRAME_FALLBACK_DEPTH = 8;
 
-function sanitizeHtml(html, options, _recursing) {
+// `_fallback` is internal: it is set when re-sanitizing the fallback markup
+// of a discarded <iframe>, to carry the current nesting depth into the
+// recursive call.
+
+function sanitizeHtml(html, options, _fallback) {
   if (html == null) {
     return '';
   }
+  const baseDepth = (_fallback && _fallback.depth) || 0;
+  const iframeFallbackDepth = (_fallback && _fallback.iframeFallbackDepth) || 0;
   if (typeof html === 'number') {
     html = html.toString();
   }
@@ -542,7 +573,7 @@ function sanitizeHtml(html, options, _recursing) {
               if (allowedSpecificClasses && allowedWildcardClasses) {
                 value = filterClasses(
                   value,
-                  deepmerge(allowedSpecificClasses, allowedWildcardClasses),
+                  mergeClasses(allowedSpecificClasses, allowedWildcardClasses),
                   allowedClassesGlobs
                 );
               } else {
@@ -682,11 +713,17 @@ function sanitizeHtml(html, options, _recursing) {
         // (including after an unclosed <iframe>) arrives as a single text node.
         // When the iframe is discarded, re-sanitize that fallback markup as HTML
         // instead of escaping it as plain text (issue #5550).
+        // The nested call continues from the current depth so that
+        // `nestingLimit` applies to the whole output.
         tag === 'iframe' &&
         !tagAllowed(tag) &&
-        options.disallowedTagsMode === 'discard'
+        options.disallowedTagsMode === 'discard' &&
+        iframeFallbackDepth < MAX_IFRAME_FALLBACK_DEPTH
       ) {
-        result += sanitizeHtml(text, options);
+        result += sanitizeHtml(text, options, {
+          depth,
+          iframeFallbackDepth: iframeFallbackDepth + 1
+        });
       } else if (!addedText) {
         const escaped = escapeHtml(text, false);
         if (options.textFilter) {
@@ -819,7 +856,7 @@ function sanitizeHtml(html, options, _recursing) {
 
   function initializeState() {
     result = '';
-    depth = 0;
+    depth = baseDepth;
     stack = [];
     skipMap = {};
     transformMap = {};
@@ -1053,7 +1090,7 @@ function sanitizeHtml(html, options, _recursing) {
 
     // Merge global and tag-specific styles into new AST.
     if (allowedStyles[astRules.selector] && allowedStyles['*']) {
-      selectedRule = deepmerge(
+      selectedRule = mergeStyles(
         allowedStyles[astRules.selector],
         allowedStyles['*']
       );

package/node_modules/sanitize-html/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sanitize-html",
-  "version": "2.18.0",
+  "version": "2.18.1",
   "description": "Clean up user-submitted HTML, preserving allowlisted elements and allowlisted attributes on a per-element basis",
   "sideEffects": false,
   "main": "index.js",
@@ -29,7 +29,6 @@
     "node": ">=22.12.0"
   },
   "dependencies": {
-    "deepmerge": "^4.3.1",
     "escape-string-regexp": "^4.0.0",
     "htmlparser2": "^12.0.0",
     "is-plain-object": "^5.1.0",
@@ -40,7 +39,7 @@
   "devDependencies": {
     "eslint": "^9.39.5",
     "eslint-config-apostrophe": "^6.1.0",
-    "mocha": "^11.8.0",
+    "mocha": "^12.0.3",
     "sinon": "^9.2.4"
   },
   "apostropheTestConfig": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suveren/gateway",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Suveren gateway — local agent gateway built in compliance with the Human Agency Protocol (HAP). Runs the UI, control plane, and MCP server in one Node process.",
   "type": "module",
   "main": "server.js",