asab_webui_components 25.2.17 → 25.2.19

package/dist/abc/Renderer.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.Renderer = void 0;
 var _react = _interopRequireWildcard(require("react"));
 var _AsabReactJson = require("../components/AsabReactJson/AsabReactJson.js");
+var _RendererWrapper = require("../components/RendererWrapper/RendererWrapper.js");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 class Renderer extends _react.Component {
   // Renderer defaults
@@ -14,6 +15,7 @@ class Renderer extends _react.Component {
     this.App = app;
   }
   render(key, value, schemaField) {
+    var params = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
     // Render ReactJson component if value is a object
     if (typeof value === 'object') {
       return /*#__PURE__*/_react.default.createElement(_AsabReactJson.AsabReactJson, {
@@ -27,8 +29,20 @@ class Renderer extends _react.Component {
         indentWidth: 8
       });
     }
+
+    // Convert bigint to string (to preserve precision and to display the value when no other renderer is applied)
+    if (typeof value === "bigint") {
+      value = value.toString();
+    }
+
     // Render span with value inside as a default
-    return /*#__PURE__*/_react.default.createElement("span", null, typeof value === "bigint" ? value.toString() : value);
+    return /*#__PURE__*/_react.default.createElement(_RendererWrapper.RendererWrapper, {
+      "data-value": value // Passing value (to eventually work with in the external wrapper)
+      ,
+      "data-key": key // Passing key (to eventually work with in the external wrapper)
+      ,
+      component: (params === null || params === void 0 ? void 0 : params.WrapperComponent) || "span"
+    }, value);
   }
   plain(key, value, schemaField) {
     // Render stringified component if value is a object
@@ -40,6 +54,11 @@ class Renderer extends _react.Component {
         return value;
       }
     }
+
+    // Convert bigint to string (to preserve precision and to display the value when no other renderer is applied)
+    if (typeof value === "bigint") {
+      value = value.toString();
+    }
     return value;
   }
 }

package/dist/components/RendererWrapper/RendererWrapper.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RendererWrapper = RendererWrapper;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = _interopRequireDefault(require("react"));
+var _excluded = ["children", "component"];
+// Renderer wraper
+function RendererWrapper(_ref) {
+  var {
+      children,
+      component: Component = 'span' // Default tag, can be overloaded
+    } = _ref,
+    rest = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  return /*#__PURE__*/_react.default.createElement(Component, rest, children);
+}

package/dist/components/RendererWrapper/RendererWrapper.jsx

@@ -0,0 +1,16 @@
+import React from 'react';
+
+// Renderer wraper
+export function RendererWrapper({
+	children,
+	component: Component = 'span', // Default tag, can be overloaded
+	...rest
+}) {
+	return (
+		<Component
+			{...rest}
+		>
+			{children}
+		</Component>
+	);
+}

package/dist/index.js

@@ -172,6 +172,12 @@ Object.defineProperty(exports, "Renderer", {
     return _Renderer.Renderer;
   }
 });
+Object.defineProperty(exports, "RendererWrapper", {
+  enumerable: true,
+  get: function get() {
+    return _RendererWrapper.RendererWrapper;
+  }
+});
 Object.defineProperty(exports, "ResultCard", {
   enumerable: true,
   get: function get() {
@@ -381,6 +387,7 @@ var _FullscreenButton = require("./components/FullscreenButton.js");
 var _ConsoleCard = require("./components/Console/ConsoleCard.js");
 var _isoCodeCountries = require("./utils/lookups/isoCodeCountries.js");
 var _AttentionRequiredBadge = require("./components/AttentionRequired/AttentionRequiredBadge.js");
+var _RendererWrapper = require("./components/RendererWrapper/RendererWrapper.js");
 require("./styles/index.scss");
 var _Pagination = _interopRequireDefault(require("./components/DataTable/Pagination"));
 var _DataTable2 = require("./components/DataTable");

package/dist/styles/constants/colors.scss

@@ -46,11 +46,14 @@
 	--slate-smoke: #6a6a6a8f; // The color of the disabled item text in the TreeMenu
 	--slate-smoke-rgb: 106, 106, 106;
 
-	--deep-red: #D1004A; // The color of the highest Alert severity
-	--deep-red-rgb: 209, 0, 74;
+	--light-honey: #ffe082; // The color of the lowest Alert severity
+	--light-honey-rgb: 255, 224, 130;
 
-	--deep-green: #0E6027; // The color of the lowest Alert severity
-	--deep-green-rgb: 14, 96, 39;
+	--bright-orange: #ff9800; // The color of the medium Alert severity
+	--bright-orange-rgb: 255, 125, 0;
+
+	--fiery-sunset: #ff5722; // The color of the high Alert severity
+	--fiery-sunset-rgb: 255, 87, 34;
 
 	--charcoal: #494949; // Console background dark theme
 	--charcoal-rgb: 0, 43, 54;
@@ -63,10 +66,4 @@
 
 	--moody-blues: #586E75; // Console font color for light theme
 	--moody-blues-rgb: rgb(88, 110, 117);
-
-	--soft-gray: #e1e2e7; // Emulate table hover row color for light theme
-	--soft-gray-rgb: rgb(225, 226, 231);
-
-	--charcoal-blue: #202636; // Emulate table hover row color for dark theme
-	--charcoal-blue-rgb: rgb(32, 38, 54);
 }

package/dist/utils/classifyIPAddress.js

@@ -1,30 +1,72 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.classifyIPAddress = classifyIPAddress;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function parseIPv4(ipAddress) {
-  var ipv4Octets = ipAddress.split('.'); // Octet is on of the segments of an IP address
-  if (ipv4Octets.length == 4) {
-    return ipv4Octets.reduce((acc, octet) => (acc << 8n) + BigInt(octet), 0n);
+  if (typeof ipAddress == 'string') {
+    var ipv4Octets = ipAddress.split('.'); // Octet is on of the segments of an IP address
+    if (ipv4Octets.length == 4) {
+      return ipv4Octets.reduce((acc, octet) => (acc << 8n) + BigInt(octet), 0n);
+    } else {
+      return undefined;
+    }
+  }
+  var bigintIP4Address = undefined;
+  if (typeof ipAddress === 'bigint') {
+    bigintIP4Address = ipAddress;
+  } else if (typeof ipAddress === 'object' && 'h' in ipAddress && 'l' in ipAddress) {
+    // This part can be removed in Jan 2026 when object form of IP address is removed from the codebase
+    bigintIP4Address = (BigInt(ipAddress.h) << 64n) + BigInt(ipAddress.l);
+  } else if (typeof ipAddress === 'number') {
+    bigintIP4Address = BigInt(ipAddress);
+  }
+  if (bigintIP4Address !== undefined) {
+    // Check if the address is in the ::ffff:0:0/96 range (IPv4-mapped IPv6 addresses) - then it is an IPv4 address
+    var ipv4MappedPrefix = BigInt('0x0000000000000000FFFF00000000');
+    var ipv4Mask = BigInt('0xFFFFFFFF');
+    if ((bigintIP4Address & BigInt('0xFFFFFFFFFFFFFFFFFFFF00000000')) === ipv4MappedPrefix) {
+      return bigintIP4Address & ipv4Mask;
+    }
+
+    // Check if the address is in the ::/96 range - then it is an IPv4 address
+    var ipv6Prefix = BigInt('0x00000000000000000000000000000000');
+    if ((bigintIP4Address & BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFF00000000')) === ipv6Prefix) {
+      return bigintIP4Address;
+    }
   }
   return undefined;
 }
 function parseIPv6(ipAddress) {
-  var ipv6Address = ipAddress;
-  if (ipv6Address.includes('::')) {
-    var parts = ipv6Address.split('::');
-    var left = parts[0] ? parts[0].split(':') : [];
-    var right = parts[1] ? parts[1].split(':') : [];
-    var missing = 8 - (left.length + right.length);
-    var zeros = Array(missing).fill('0000');
-    var full = [...left, ...zeros, ...right];
-    ipv6Address = full.map(block => block.padStart(4, '0')).join(':');
-  }
-  var ipv6Blocks = ipv6Address.split(':'); // Block is on of the segments of an IP address
-  if (ipv6Blocks.length == 8) {
-    return ipv6Blocks.reduce((acc, block) => (acc << 16n) + BigInt(parseInt(block, 16)), 0n);
+  if (typeof ipAddress == 'string') {
+    var ipv6Address = ipAddress;
+    if (ipv6Address.includes('::')) {
+      var parts = ipv6Address.split('::');
+      var left = parts[0] ? parts[0].split(':') : [];
+      var right = parts[1] ? parts[1].split(':') : [];
+      var missing = 8 - (left.length + right.length);
+      var zeros = Array(missing).fill('0000');
+      var full = [...left, ...zeros, ...right];
+      ipv6Address = full.map(block => block.padStart(4, '0')).join(':');
+    }
+    var ipv6Blocks = ipv6Address.split(':'); // Block is on of the segments of an IP address
+    if (ipv6Blocks.length == 8) {
+      return ipv6Blocks.reduce((acc, block) => (acc << 16n) + BigInt(parseInt(block, 16)), 0n);
+    } else {
+      return undefined;
+    }
+  } else if (typeof ipAddress === 'bigint') {
+    return ipAddress;
+  } else if (typeof ipAddress === 'object' && 'h' in ipAddress && 'l' in ipAddress) {
+    // This part can be removed in Jan 2026 when object form of IP address is removed from the codebase
+    return (BigInt(ipAddress.h) << 64n) + BigInt(ipAddress.l);
+  } else if (typeof ipAddress === 'number') {
+    return BigInt(ipAddress);
   }
   return undefined;
 }
@@ -36,120 +78,254 @@ function parseIPv6(ipAddress) {
 var ipv4Ranges = [{
   block: parseIPv4("10.0.0.0"),
   mask: 8,
-  class: "IPv4 private"
+  attrs: {
+    cls: "private",
+    family: "IPv4",
+    msg: "IPv4 private"
+  }
 }, {
   block: parseIPv4("172.16.0.0"),
   mask: 12,
-  class: "IPv4 private" // https://datatracker.ietf.org/doc/html/rfc1918
+  // https://datatracker.ietf.org/doc/html/rfc1918
+  attrs: {
+    cls: "private",
+    family: "IPv4",
+    msg: "IPv4 private"
+  }
 }, {
   block: parseIPv4("192.168.0.0"),
   mask: 16,
-  class: "IPv4 private"
+  attrs: {
+    cls: "private",
+    family: "IPv4",
+    msg: "IPv4 private"
+  }
 }, {
   block: parseIPv4("169.254.0.0"),
   mask: 24,
-  class: "IPv4 reserved"
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 reserved"
+  }
 }, {
   block: parseIPv4("169.254.255.0"),
   mask: 24,
-  class: "IPv4 reserved"
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 reserved"
+  }
 }, {
   block: parseIPv4("169.254.0.0"),
   mask: 16,
-  class: "IPv4 link-local" // https://datatracker.ietf.org/doc/html/rfc3927
+  // https://datatracker.ietf.org/doc/html/rfc3927
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 link-local"
+  }
 }, {
   block: parseIPv4("100.64.0.0"),
   mask: 10,
-  class: "IPv4 SAS" // Shared Address Space  https://datatracker.ietf.org/doc/html/rfc6598
+  // Shared Address Space https://datatracker.ietf.org/doc/html/rfc6598
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 Shared Address Space"
+  }
 }, {
   block: parseIPv4("127.0.0.0"),
   mask: 8,
-  class: "IPv4 loopback"
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 loopback"
+  }
 }, {
   block: parseIPv4("0.0.0.0"),
   mask: 8,
-  class: "IPv4 special"
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 reserved"
+  }
 }, {
   block: parseIPv4("192.0.0.0"),
   mask: 29,
-  class: "IPv4 ds-lite" // https://datatracker.ietf.org/doc/html/rfc6333
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 ds-lite"
+  }
 }, {
   block: parseIPv4("192.0.2.0"),
   mask: 24,
-  class: "IPv4 documentation" // https://datatracker.ietf.org/doc/html/rfc5737
+  // https://datatracker.ietf.org/doc/html/rfc5737
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 documentation"
+  }
 }, {
   block: parseIPv4("192.88.99.0"),
   mask: 24,
-  class: "IPv4 6to4" // RFC3068
+  // RFC3068
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 6to4"
+  }
 }, {
   block: parseIPv4("198.18.0.0"),
   mask: 15,
-  class: "IPv4 benchmarking" // https://datatracker.ietf.org/doc/html/rfc2544
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 benchmarking"
+  }
 }, {
   block: parseIPv4("198.51.100.0"),
   mask: 24,
-  class: "IPv4 documentation" // https://datatracker.ietf.org/doc/html/rfc5737
+  // https://datatracker.ietf.org/doc/html/rfc5737
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 documentation"
+  }
 }, {
   block: parseIPv4("203.0.113.0"),
   mask: 24,
-  class: "IPv4 documentation" // https://datatracker.ietf.org/doc/html/rfc5737
+  // https://datatracker.ietf.org/doc/html/rfc5737
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 documentation"
+  }
 }, {
   block: parseIPv4("240.0.0.0"),
   mask: 4,
-  class: "IPv4 reserved" // [RFC1112], Section 4
+  // [RFC1112], Section 4
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 reserved"
+  }
 }, {
   block: parseIPv4("255.255.255.255"),
   mask: 32,
-  class: "IPv4 limited-broadcast" //  RFC0919], Section 7
+  attrs: {
+    cls: "special",
+    family: "IPv4",
+    msg: "IPv4 limited-broadcast"
+  }
 }];
 var ipv6Ranges = [{
   block: parseIPv6("::1"),
   mask: 128,
-  class: "IPv6 loopback" // https://datatracker.ietf.org/doc/html/rfc4291
+  // https://datatracker.ietf.org/doc/html/rfc4291
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 loopback"
+  }
 }, {
   block: parseIPv6("::"),
   mask: 128,
-  class: "IPv6 unspecified" // https://datatracker.ietf.org/doc/html/rfc4291
+  // https://datatracker.ietf.org/doc/html/rfc4291
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 unspecified"
+  }
 }, {
   block: parseIPv6("64:ff9b::"),
   mask: 96,
-  class: "IPv6 IPv4-IPv6" // https://datatracker.ietf.org/doc/html/rfc6052
+  // https://datatracker.ietf.org/doc/html/rfc6052
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 IPv4-IPv6"
+  }
 }, {
   block: parseIPv6("::ffff:0:0"),
   mask: 96,
-  class: "IPv6 IPv4-mapped" // https://datatracker.ietf.org/doc/html/rfc4291
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 IPv4-mapped"
+  }
 }, {
   block: parseIPv6("100::"),
   mask: 64,
-  class: "IPv6 discard" // https://datatracker.ietf.org/doc/html/rfc6666
+  // https://datatracker.ietf.org/doc/html/rfc6666
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 discard"
+  }
 }, {
   block: parseIPv6("2001::"),
   mask: 32,
-  class: "IPv6 terredo" // https://datatracker.ietf.org/doc/html/rfc4380
+  // https://datatracker.ietf.org/doc/html/rfc4380
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 terredo"
+  }
 }, {
   block: parseIPv6("2001:2::"),
   mask: 32,
-  class: "IPv6 benchmarking" // https://datatracker.ietf.org/doc/html/rfc5180
+  // https://datatracker.ietf.org/doc/html/rfc5180
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 benchmarking"
+  }
 }, {
   block: parseIPv6("2001:db8::"),
   mask: 32,
-  class: "IPv6 documentation" // https://datatracker.ietf.org/doc/html/rfc3849
+  // https://datatracker.ietf.org/doc/html/rfc3849
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 documentation"
+  }
 }, {
   block: parseIPv6("2001:10::"),
   mask: 28,
-  class: "IPv6 orchid" // https://datatracker.ietf.org/doc/html/rfc4843
+  // https://datatracker.ietf.org/doc/html/rfc4843
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 orchid"
+  }
 }, {
   block: parseIPv6("2002::"),
   mask: 16,
-  class: "IPv6 6to4" // https://datatracker.ietf.org/doc/html/rfc3056
+  // https://datatracker.ietf.org/doc/html/rfc3056
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 6to4"
+  }
 }, {
   block: parseIPv6("fc00::"),
   mask: 7,
-  class: "IPv6 private" // https://datatracker.ietf.org/doc/html/rfc4193
+  // https://datatracker.ietf.org/doc/html/rfc4193
+  attrs: {
+    cls: "private",
+    family: "IPv6",
+    msg: "IPv6 unique local"
+  }
 }, {
   block: parseIPv6("fe80::"),
   mask: 10,
-  class: "IPv6 link-local" // https://datatracker.ietf.org/doc/html/rfc4291
+  attrs: {
+    cls: "special",
+    family: "IPv6",
+    msg: "IPv6 link-local"
+  }
 }];
 function classifyIPv4(ipAddress) {
   for (var range of ipv4Ranges) {
@@ -157,10 +333,17 @@ function classifyIPv4(ipAddress) {
     var network = range.block & ~mask;
     var ipNetwork = ipAddress & ~mask;
     if (network === ipNetwork) {
-      return range.class;
+      return _objectSpread(_objectSpread({}, range.attrs), {}, {
+        normalizedValue: stringifyIPv4(ipAddress)
+      });
     }
   }
-  return "IPv4 public"; // If no range matches, it's a public IP
+  return {
+    cls: "public",
+    family: "IPv4",
+    normalizedValue: stringifyIPv4(ipAddress),
+    msg: "IPv4 public"
+  };
 }
 function classifyIPv6(ipAddress) {
   for (var range of ipv6Ranges) {
@@ -168,44 +351,49 @@ function classifyIPv6(ipAddress) {
     var network = range.block & ~mask;
     var ipNetwork = ipAddress & ~mask;
     if (network === ipNetwork) {
-      return range.class;
+      return _objectSpread(_objectSpread({}, range.attrs), {}, {
+        normalizedValue: stringifyIPv6(ipAddress)
+      });
     }
   }
-  return "IPv6 public"; // If no range matches, it's a public IP
+  return {
+    cls: "public",
+    family: "IPv6",
+    normalizedValue: stringifyIPv6(ipAddress),
+    msg: "IPv6 public"
+  };
 }
 
 /*
 	Classify an IP address.
 	Input:
-		ipAddress - string, IP address to classify
+		ipAddress - string/BigInt/object{h: number, l: number}, IP address to classify
 	
 	Returns:
-		"IPv4 private"
-		"IPv4 public"
-		"IPv4 ..."
-		"IPv6 private"
-		"IPv6 public"
-		"IPv6 ..."
-		"invalid" ... for invalid IP address
-		"invalid parse ipv4" ... for invalid IPv4 address
-		"invalid parse ipv6" ... for invalid IPv6 address
-
-	The first word is "IPv4", "IPv6" or "invalid".
-	
-	If the second word is "private", it means that the IP address is private.
-	If the second word is "public", it means that the IP address is public.
-	Any other second word means "special".
+		Dictionary
 */
 
 function classifyIPAddress(ipAddress) {
   var ipv4 = undefined;
   var ipv6 = undefined;
+  if (ipAddress == undefined) {
+    return {
+      cls: "invalid",
+      normalizedValue: "N/A",
+      msg: "Not an IP address"
+    };
+  }
 
   // Parse IPv4 address
   try {
     ipv4 = parseIPv4(ipAddress);
   } catch (error) {
-    return "invalid parse ipv4";
+    console.error(error);
+    return {
+      cls: "invalid",
+      normalizedValue: sanitizeInvalidIPAddress(ipAddress),
+      msg: "invalid parse ipv4"
+    };
   }
   if (ipv4 !== undefined) {
     return classifyIPv4(ipv4);
@@ -215,10 +403,88 @@ function classifyIPAddress(ipAddress) {
   try {
     ipv6 = parseIPv6(ipAddress);
   } catch (error) {
-    return "invalid parse ipv6";
+    return {
+      cls: "invalid",
+      normalizedValue: sanitizeInvalidIPAddress(ipAddress),
+      msg: "invalid parse ipv6"
+    };
   }
   if (ipv6 !== undefined) {
     return classifyIPv6(ipv6);
   }
-  return "invalid"; // Means invalid IP address
-}
+  return {
+    cls: "invalid",
+    normalizedValue: sanitizeInvalidIPAddress(ipAddress),
+    msg: "Not an IP address"
+  };
+}
+
+// Improved function to compress IPv6 addresses, fully replicating Python's `.compressed` behavior.
+var stringifyIPv6 = bigintIP6Address => {
+  var parts = [];
+  for (var i = 0; i < 8; i++) {
+    parts.unshift(Number(bigintIP6Address & 0xFFFFn).toString(16));
+    bigintIP6Address >>= 16n;
+  }
+
+  // Variables to track the start and length of the longest sequence of zeros.
+  var zeroStart = -1; // Start index of the longest zero sequence
+  var zeroMax = 0; // Length of the longest zero sequence
+  var zeroTempStart = -1; // Start index of the current zero sequence being checked
+  var zeroTempLen = 0; // Length of the current zero sequence being checked
+
+  // Iterate through the parts of the IPv6 address to find the longest sequence of zeros.
+  for (var _i = 0; _i < parts.length; _i++) {
+    if (parts[_i] === '0') {
+      // If the current part is zero, start or continue tracking a zero sequence.
+      if (zeroTempStart === -1) zeroTempStart = _i; // Mark the start of the sequence
+      zeroTempLen++; // Increment the length of the current sequence
+    } else {
+      // If the current part is not zero, check if the current zero sequence is the longest.
+      if (zeroTempLen > zeroMax) {
+        zeroStart = zeroTempStart; // Update the start of the longest sequence
+        zeroMax = zeroTempLen; // Update the length of the longest sequence
+      }
+      // Reset the tracking variables for the next potential zero sequence.
+      zeroTempStart = -1;
+      zeroTempLen = 0;
+    }
+  }
+
+  // After the loop, check if the last zero sequence is the longest.
+  if (zeroTempLen > zeroMax) {
+    zeroStart = zeroTempStart;
+    zeroMax = zeroTempLen;
+  }
+
+  // If a sequence of more than one zero is found, replace it with `::` to compress the IPv6 address.
+  if (zeroMax > 1) {
+    parts.splice(zeroStart, zeroMax, ''); // Replace the zero sequence with an empty string
+  }
+
+  // Join the parts with colons to form the final compressed IPv6 address.
+  return parts.join(':');
+};
+var stringifyIPv4 = bigintIP4Address => {
+  var parts = [];
+  for (var i = 0; i < 4; i++) {
+    parts.push(Number(bigintIP4Address & 0xFFn));
+    bigintIP4Address >>= 8n;
+  }
+  return parts.reverse().join('.');
+};
+
+// This function is used to sanitize the input which is NOT the IP address to a string.
+var sanitizeInvalidIPAddress = ipAddress => {
+  if (typeof ipAddress === 'string') {
+    return ipAddress;
+  } else if (typeof ipAddress === 'bigint') {
+    return ipAddress.toString();
+  } else if (typeof ipAddress === 'object') {
+    return "".concat(ipAddress); // TODO: This can be more clever if needed
+  } else if (typeof ipAddress === 'number') {
+    return ipAddress.toString();
+  } else {
+    return "???";
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asab_webui_components",
-  "version": "25.2.17",
+  "version": "25.2.19",
   "license": "BSD-3-Clause",
   "description": "TeskaLabs ASAB WebUI Components Library",
   "contributors": [