diff --git a/.yarn/patches/ip-npm-1.1.5-af36318aa6.patch b/.yarn/patches/ip-npm-1.1.5-af36318aa6.patch
new file mode 100644
index 0000000000..5518c955e9
--- /dev/null
+++ b/.yarn/patches/ip-npm-1.1.5-af36318aa6.patch
@@ -0,0 +1,658 @@
+diff --git a/.idea/.gitignore b/.idea/.gitignore
+new file mode 100644
+index 0000000000000000000000000000000000000000..b58b603fea78041071d125a30db58d79b3d49217
+--- /dev/null
++++ b/.idea/.gitignore
+@@ -0,0 +1,5 @@
++# Default ignored files
++/shelf/
++/workspace.xml
++# Editor-based HTTP Client requests
++/httpRequests/
+diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
+new file mode 100644
+index 0000000000000000000000000000000000000000..eff7139dc94035d3c213c5275bbe9433ac0d8567
+--- /dev/null
++++ b/.idea/inspectionProfiles/Project_Default.xml
+@@ -0,0 +1,6 @@
++
++
++
++
++
++
+\ No newline at end of file
+diff --git a/.idea/jsLinters/jshint.xml b/.idea/jsLinters/jshint.xml
+new file mode 100644
+index 0000000000000000000000000000000000000000..8e9049ddc52db21a6896496871c6ea08b36d6dd3
+--- /dev/null
++++ b/.idea/jsLinters/jshint.xml
+@@ -0,0 +1,16 @@
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
+\ No newline at end of file
+diff --git a/.idea/markdown.xml b/.idea/markdown.xml
+new file mode 100644
+index 0000000000000000000000000000000000000000..1e3409412310b56afb6dc2d619a9333bfe3f067e
+--- /dev/null
++++ b/.idea/markdown.xml
+@@ -0,0 +1,9 @@
++
++
++
++
++
++
++
++
++
+\ No newline at end of file
+diff --git a/.idea/modules.xml b/.idea/modules.xml
+new file mode 100644
+index 0000000000000000000000000000000000000000..d9fb14e4d06a030cba3cd105982c4f196e0718a0
+--- /dev/null
++++ b/.idea/modules.xml
+@@ -0,0 +1,8 @@
++
++
++
++
++
++
++
++
+\ No newline at end of file
+diff --git a/.idea/user.iml b/.idea/user.iml
+new file mode 100644
+index 0000000000000000000000000000000000000000..0c8867d7e175f46d4bcd66698ac13f4ca00cf592
+--- /dev/null
++++ b/.idea/user.iml
+@@ -0,0 +1,12 @@
++
++
++
++
++
++
++
++
++
++
++
++
+\ No newline at end of file
+diff --git a/.idea/workspace.xml b/.idea/workspace.xml
+new file mode 100644
+index 0000000000000000000000000000000000000000..11d806046fbc9fe6dff0a2233d486daff56c2759
+--- /dev/null
++++ b/.idea/workspace.xml
+@@ -0,0 +1,42 @@
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++ 1652225904981
++
++
++ 1652225904981
++
++
++
++
++
++
++
+\ No newline at end of file
+diff --git a/lib/ip.js b/lib/ip.js
+index c1799a8c50f42744320a529c3a9e2b77bac74898..328862a40c84f2e20f59abb6abbd1e866f01da76 100644
+--- a/lib/ip.js
++++ b/lib/ip.js
+@@ -1,26 +1,24 @@
+-'use strict';
++const ip = exports;
++const { Buffer } = require('buffer');
++const os = require('os');
+
+-var ip = exports;
+-var Buffer = require('buffer').Buffer;
+-var os = require('os');
+-
+-ip.toBuffer = function(ip, buff, offset) {
++ip.toBuffer = function (ip, buff, offset) {
+ offset = ~~offset;
+
+- var result;
++ let result;
+
+ if (this.isV4Format(ip)) {
+ result = buff || new Buffer(offset + 4);
+- ip.split(/\./g).map(function(byte) {
++ ip.split(/\./g).map((byte) => {
+ result[offset++] = parseInt(byte, 10) & 0xff;
+ });
+ } else if (this.isV6Format(ip)) {
+- var sections = ip.split(':', 8);
++ const sections = ip.split(':', 8);
+
+- var i;
++ let i;
+ for (i = 0; i < sections.length; i++) {
+- var isv4 = this.isV4Format(sections[i]);
+- var v4Buffer;
++ const isv4 = this.isV4Format(sections[i]);
++ let v4Buffer;
+
+ if (isv4) {
+ v4Buffer = this.toBuffer(sections[i]);
+@@ -38,42 +36,42 @@ ip.toBuffer = function(ip, buff, offset) {
+ while (sections.length < 8) sections.push('0');
+ } else if (sections.length < 8) {
+ for (i = 0; i < sections.length && sections[i] !== ''; i++);
+- var argv = [ i, 1 ];
++ const argv = [i, 1];
+ for (i = 9 - sections.length; i > 0; i--) {
+ argv.push('0');
+ }
+- sections.splice.apply(sections, argv);
++ sections.splice(...argv);
+ }
+
+ result = buff || new Buffer(offset + 16);
+ for (i = 0; i < sections.length; i++) {
+- var word = parseInt(sections[i], 16);
++ const word = parseInt(sections[i], 16);
+ result[offset++] = (word >> 8) & 0xff;
+ result[offset++] = word & 0xff;
+ }
+ }
+
+ if (!result) {
+- throw Error('Invalid ip address: ' + ip);
++ throw Error(`Invalid ip address: ${ip}`);
+ }
+
+ return result;
+ };
+
+-ip.toString = function(buff, offset, length) {
++ip.toString = function (buff, offset, length) {
+ offset = ~~offset;
+ length = length || (buff.length - offset);
+
+- var result = [];
++ let result = [];
+ if (length === 4) {
+ // IPv4
+- for (var i = 0; i < length; i++) {
++ for (let i = 0; i < length; i++) {
+ result.push(buff[offset + i]);
+ }
+ result = result.join('.');
+ } else if (length === 16) {
+ // IPv6
+- for (var i = 0; i < length; i += 2) {
++ for (let i = 0; i < length; i += 2) {
+ result.push(buff.readUInt16BE(offset + i).toString(16));
+ }
+ result = result.join(':');
+@@ -84,36 +82,42 @@ ip.toString = function(buff, offset, length) {
+ return result;
+ };
+
+-var ipv4Regex = /^(\d{1,3}\.){3,3}\d{1,3}$/;
+-var ipv6Regex =
+- /^(::)?(((\d{1,3}\.){3}(\d{1,3}){1})?([0-9a-f]){0,4}:{0,2}){1,8}(::)?$/i;
++const ipv4Regex = /^(\d{1,3}\.){3,3}\d{1,3}$/;
++const ipv6Regex = /^(::)?(((\d{1,3}\.){3}(\d{1,3}){1})?([0-9a-f]){0,4}:{0,2}){1,8}(::)?$/i;
+
+-ip.isV4Format = function(ip) {
++ip.isV4Format = function (ip) {
+ return ipv4Regex.test(ip);
+ };
+
+-ip.isV6Format = function(ip) {
++ip.isV6Format = function (ip) {
+ return ipv6Regex.test(ip);
+ };
++
+ function _normalizeFamily(family) {
++ if (family === 4) {
++ return 'ipv4';
++ }
++ if (family === 6) {
++ return 'ipv6';
++ }
+ return family ? family.toLowerCase() : 'ipv4';
+ }
+
+-ip.fromPrefixLen = function(prefixlen, family) {
++ip.fromPrefixLen = function (prefixlen, family) {
+ if (prefixlen > 32) {
+ family = 'ipv6';
+ } else {
+ family = _normalizeFamily(family);
+ }
+
+- var len = 4;
++ let len = 4;
+ if (family === 'ipv6') {
+ len = 16;
+ }
+- var buff = new Buffer(len);
++ const buff = new Buffer(len);
+
+- for (var i = 0, n = buff.length; i < n; ++i) {
+- var bits = 8;
++ for (let i = 0, n = buff.length; i < n; ++i) {
++ let bits = 8;
+ if (prefixlen < 8) {
+ bits = prefixlen;
+ }
+@@ -125,14 +129,14 @@ ip.fromPrefixLen = function(prefixlen, family) {
+ return ip.toString(buff);
+ };
+
+-ip.mask = function(addr, mask) {
++ip.mask = function (addr, mask) {
+ addr = ip.toBuffer(addr);
+ mask = ip.toBuffer(mask);
+
+- var result = new Buffer(Math.max(addr.length, mask.length));
++ const result = new Buffer(Math.max(addr.length, mask.length));
+
+- var i = 0;
+ // Same protocol - do bitwise and
++ let i;
+ if (addr.length === mask.length) {
+ for (i = 0; i < addr.length; i++) {
+ result[i] = addr[i] & mask[i];
+@@ -141,11 +145,11 @@ ip.mask = function(addr, mask) {
+ // IPv6 address and IPv4 mask
+ // (Mask low bits)
+ for (i = 0; i < mask.length; i++) {
+- result[i] = addr[addr.length - 4 + i] & mask[i];
++ result[i] = addr[addr.length - 4 + i] & mask[i];
+ }
+ } else {
+ // IPv6 mask and IPv4 addr
+- for (var i = 0; i < result.length - 6; i++) {
++ for (i = 0; i < result.length - 6; i++) {
+ result[i] = 0;
+ }
+
+@@ -155,38 +159,40 @@ ip.mask = function(addr, mask) {
+ for (i = 0; i < addr.length; i++) {
+ result[i + 12] = addr[i] & mask[i + 12];
+ }
+- i = i + 12;
++ i += 12;
+ }
+- for (; i < result.length; i++)
++ for (; i < result.length; i++) {
+ result[i] = 0;
++ }
+
+ return ip.toString(result);
+ };
+
+-ip.cidr = function(cidrString) {
+- var cidrParts = cidrString.split('/');
++ip.cidr = function (cidrString) {
++ const cidrParts = cidrString.split('/');
+
+- var addr = cidrParts[0];
+- if (cidrParts.length !== 2)
+- throw new Error('invalid CIDR subnet: ' + addr);
++ const addr = cidrParts[0];
++ if (cidrParts.length !== 2) {
++ throw new Error(`invalid CIDR subnet: ${addr}`);
++ }
+
+- var mask = ip.fromPrefixLen(parseInt(cidrParts[1], 10));
++ const mask = ip.fromPrefixLen(parseInt(cidrParts[1], 10));
+
+ return ip.mask(addr, mask);
+ };
+
+-ip.subnet = function(addr, mask) {
+- var networkAddress = ip.toLong(ip.mask(addr, mask));
++ip.subnet = function (addr, mask) {
++ const networkAddress = ip.toLong(ip.mask(addr, mask));
+
+ // Calculate the mask's length.
+- var maskBuffer = ip.toBuffer(mask);
+- var maskLength = 0;
++ const maskBuffer = ip.toBuffer(mask);
++ let maskLength = 0;
+
+- for (var i = 0; i < maskBuffer.length; i++) {
++ for (let i = 0; i < maskBuffer.length; i++) {
+ if (maskBuffer[i] === 0xff) {
+ maskLength += 8;
+ } else {
+- var octet = maskBuffer[i] & 0xff;
++ let octet = maskBuffer[i] & 0xff;
+ while (octet) {
+ octet = (octet << 1) & 0xff;
+ maskLength++;
+@@ -194,84 +200,84 @@ ip.subnet = function(addr, mask) {
+ }
+ }
+
+- var numberOfAddresses = Math.pow(2, 32 - maskLength);
++ const numberOfAddresses = 2 ** (32 - maskLength);
+
+ return {
+ networkAddress: ip.fromLong(networkAddress),
+- firstAddress: numberOfAddresses <= 2 ?
+- ip.fromLong(networkAddress) :
+- ip.fromLong(networkAddress + 1),
+- lastAddress: numberOfAddresses <= 2 ?
+- ip.fromLong(networkAddress + numberOfAddresses - 1) :
+- ip.fromLong(networkAddress + numberOfAddresses - 2),
++ firstAddress: numberOfAddresses <= 2
++ ? ip.fromLong(networkAddress)
++ : ip.fromLong(networkAddress + 1),
++ lastAddress: numberOfAddresses <= 2
++ ? ip.fromLong(networkAddress + numberOfAddresses - 1)
++ : ip.fromLong(networkAddress + numberOfAddresses - 2),
+ broadcastAddress: ip.fromLong(networkAddress + numberOfAddresses - 1),
+ subnetMask: mask,
+ subnetMaskLength: maskLength,
+- numHosts: numberOfAddresses <= 2 ?
+- numberOfAddresses : numberOfAddresses - 2,
++ numHosts: numberOfAddresses <= 2
++ ? numberOfAddresses : numberOfAddresses - 2,
+ length: numberOfAddresses,
+- contains: function(other) {
++ contains(other) {
+ return networkAddress === ip.toLong(ip.mask(other, mask));
+- }
++ },
+ };
+ };
+
+-ip.cidrSubnet = function(cidrString) {
+- var cidrParts = cidrString.split('/');
++ip.cidrSubnet = function (cidrString) {
++ const cidrParts = cidrString.split('/');
+
+- var addr = cidrParts[0];
+- if (cidrParts.length !== 2)
+- throw new Error('invalid CIDR subnet: ' + addr);
++ const addr = cidrParts[0];
++ if (cidrParts.length !== 2) {
++ throw new Error(`invalid CIDR subnet: ${addr}`);
++ }
+
+- var mask = ip.fromPrefixLen(parseInt(cidrParts[1], 10));
++ const mask = ip.fromPrefixLen(parseInt(cidrParts[1], 10));
+
+ return ip.subnet(addr, mask);
+ };
+
+-ip.not = function(addr) {
+- var buff = ip.toBuffer(addr);
+- for (var i = 0; i < buff.length; i++) {
++ip.not = function (addr) {
++ const buff = ip.toBuffer(addr);
++ for (let i = 0; i < buff.length; i++) {
+ buff[i] = 0xff ^ buff[i];
+ }
+ return ip.toString(buff);
+ };
+
+-ip.or = function(a, b) {
++ip.or = function (a, b) {
+ a = ip.toBuffer(a);
+ b = ip.toBuffer(b);
+
+ // same protocol
+ if (a.length === b.length) {
+- for (var i = 0; i < a.length; ++i) {
++ for (let i = 0; i < a.length; ++i) {
+ a[i] |= b[i];
+ }
+ return ip.toString(a);
+
+- // mixed protocols
+- } else {
+- var buff = a;
+- var other = b;
+- if (b.length > a.length) {
+- buff = b;
+- other = a;
+- }
+-
+- var offset = buff.length - other.length;
+- for (var i = offset; i < buff.length; ++i) {
+- buff[i] |= other[i - offset];
+- }
++ // mixed protocols
++ }
++ let buff = a;
++ let other = b;
++ if (b.length > a.length) {
++ buff = b;
++ other = a;
++ }
+
+- return ip.toString(buff);
++ const offset = buff.length - other.length;
++ for (let i = offset; i < buff.length; ++i) {
++ buff[i] |= other[i - offset];
+ }
++
++ return ip.toString(buff);
+ };
+
+-ip.isEqual = function(a, b) {
++ip.isEqual = function (a, b) {
+ a = ip.toBuffer(a);
+ b = ip.toBuffer(b);
+
+ // Same protocol
+ if (a.length === b.length) {
+- for (var i = 0; i < a.length; i++) {
++ for (let i = 0; i < a.length; i++) {
+ if (a[i] !== b[i]) return false;
+ }
+ return true;
+@@ -279,53 +285,53 @@ ip.isEqual = function(a, b) {
+
+ // Swap
+ if (b.length === 4) {
+- var t = b;
++ const t = b;
+ b = a;
+ a = t;
+ }
+
+ // a - IPv4, b - IPv6
+- for (var i = 0; i < 10; i++) {
++ for (let i = 0; i < 10; i++) {
+ if (b[i] !== 0) return false;
+ }
+
+- var word = b.readUInt16BE(10);
++ const word = b.readUInt16BE(10);
+ if (word !== 0 && word !== 0xffff) return false;
+
+- for (var i = 0; i < 4; i++) {
++ for (let i = 0; i < 4; i++) {
+ if (a[i] !== b[i + 12]) return false;
+ }
+
+ return true;
+ };
+
+-ip.isPrivate = function(addr) {
++ip.isPrivate = function (addr) {
+ return /^(::f{4}:)?10\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i
+- .test(addr) ||
+- /^(::f{4}:)?192\.168\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+- /^(::f{4}:)?172\.(1[6-9]|2\d|30|31)\.([0-9]{1,3})\.([0-9]{1,3})$/i
+- .test(addr) ||
+- /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+- /^(::f{4}:)?169\.254\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr) ||
+- /^f[cd][0-9a-f]{2}:/i.test(addr) ||
+- /^fe80:/i.test(addr) ||
+- /^::1$/.test(addr) ||
+- /^::$/.test(addr);
++ .test(addr)
++ || /^(::f{4}:)?192\.168\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr)
++ || /^(::f{4}:)?172\.(1[6-9]|2\d|30|31)\.([0-9]{1,3})\.([0-9]{1,3})$/i
++ .test(addr)
++ || /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr)
++ || /^(::f{4}:)?169\.254\.([0-9]{1,3})\.([0-9]{1,3})$/i.test(addr)
++ || /^f[cd][0-9a-f]{2}:/i.test(addr)
++ || /^fe80:/i.test(addr)
++ || /^::1$/.test(addr)
++ || /^::$/.test(addr);
+ };
+
+-ip.isPublic = function(addr) {
++ip.isPublic = function (addr) {
+ return !ip.isPrivate(addr);
+ };
+
+-ip.isLoopback = function(addr) {
++ip.isLoopback = function (addr) {
+ return /^(::f{4}:)?127\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})/
+- .test(addr) ||
+- /^fe80::1$/.test(addr) ||
+- /^::1$/.test(addr) ||
+- /^::$/.test(addr);
++ .test(addr)
++ || /^fe80::1$/.test(addr)
++ || /^::1$/.test(addr)
++ || /^::$/.test(addr);
+ };
+
+-ip.loopback = function(family) {
++ip.loopback = function (family) {
+ //
+ // Default to `ipv4`
+ //
+@@ -353,9 +359,8 @@ ip.loopback = function(family) {
+ // * 'private': the first private ip address of family.
+ // * undefined: First address with `ipv4` or loopback address `127.0.0.1`.
+ //
+-ip.address = function(name, family) {
+- var interfaces = os.networkInterfaces();
+- var all;
++ip.address = function (name, family) {
++ const interfaces = os.networkInterfaces();
+
+ //
+ // Default to `ipv4`
+@@ -367,30 +372,31 @@ ip.address = function(name, family) {
+ // return the address.
+ //
+ if (name && name !== 'private' && name !== 'public') {
+- var res = interfaces[name].filter(function(details) {
+- var itemFamily = details.family.toLowerCase();
++ const res = interfaces[name].filter((details) => {
++ const itemFamily = _normalizeFamily(details.family);
+ return itemFamily === family;
+ });
+- if (res.length === 0)
++ if (res.length === 0) {
+ return undefined;
++ }
+ return res[0].address;
+ }
+
+- var all = Object.keys(interfaces).map(function (nic) {
++ const all = Object.keys(interfaces).map((nic) => {
+ //
+ // Note: name will only be `public` or `private`
+ // when this is called.
+ //
+- var addresses = interfaces[nic].filter(function (details) {
+- details.family = details.family.toLowerCase();
++ const addresses = interfaces[nic].filter((details) => {
++ details.family = _normalizeFamily(details.family);
+ if (details.family !== family || ip.isLoopback(details.address)) {
+ return false;
+- } else if (!name) {
++ } if (!name) {
+ return true;
+ }
+
+- return name === 'public' ? ip.isPrivate(details.address) :
+- ip.isPublic(details.address);
++ return name === 'public' ? ip.isPrivate(details.address)
++ : ip.isPublic(details.address);
+ });
+
+ return addresses.length ? addresses[0].address : undefined;
+@@ -399,18 +405,18 @@ ip.address = function(name, family) {
+ return !all.length ? ip.loopback(family) : all[0];
+ };
+
+-ip.toLong = function(ip) {
+- var ipl = 0;
+- ip.split('.').forEach(function(octet) {
++ip.toLong = function (ip) {
++ let ipl = 0;
++ ip.split('.').forEach((octet) => {
+ ipl <<= 8;
+ ipl += parseInt(octet);
+ });
+- return(ipl >>> 0);
++ return (ipl >>> 0);
+ };
+
+-ip.fromLong = function(ipl) {
+- return ((ipl >>> 24) + '.' +
+- (ipl >> 16 & 255) + '.' +
+- (ipl >> 8 & 255) + '.' +
+- (ipl & 255) );
++ip.fromLong = function (ipl) {
++ return (`${ipl >>> 24}.${
++ ipl >> 16 & 255}.${
++ ipl >> 8 & 255}.${
++ ipl & 255}`);
+ };
diff --git a/package.json b/package.json
index 03d31d9318..0f43ed32b0 100644
--- a/package.json
+++ b/package.json
@@ -35,5 +35,8 @@
"reportUnusedDisableDirectives": "error"
}
},
- "packageManager": "yarn@3.2.0"
+ "packageManager": "yarn@3.2.0",
+ "resolutions": {
+ "ip@^1.1.5": "patch:ip@npm:1.1.5#.yarn/patches/ip-npm-1.1.5-af36318aa6.patch"
+ }
}
diff --git a/src/sx-design/.storybook/main.js b/src/sx-design/.storybook/main.js
index 5e289e4431..f35dfb08ac 100644
--- a/src/sx-design/.storybook/main.js
+++ b/src/sx-design/.storybook/main.js
@@ -3,7 +3,7 @@
module.exports = {
stories: ['../src/**/*.stories.mdx', '../src/**/*.stories.@(js|jsx|ts|tsx)'],
addons: ['@storybook/addon-essentials', '@storybook/addon-links', '@storybook/addon-a11y'],
- webpackFinal: (config: $FlowFixMe): $FlowFixMe => {
+ webpackFinal: (config /*: $FlowFixMe */) /*: $FlowFixMe */ => {
// https://github.com/storybookjs/storybook/issues/16690
config.module.rules.push({
test: /\.mjs$/,
diff --git a/yarn.lock b/yarn.lock
index 4af997a3af..9b6e237ca1 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -12038,13 +12038,20 @@ __metadata:
languageName: node
linkType: hard
-"ip@npm:^1.1.5":
+"ip@npm:1.1.5":
version: 1.1.5
resolution: "ip@npm:1.1.5"
checksum: 30133981f082a060a32644f6a7746e9ba7ac9e2bc07ecc8bbdda3ee8ca9bec1190724c390e45a1ee7695e7edfd2a8f7dda2c104ec5f7ac5068c00648504c7e5a
languageName: node
linkType: hard
+"ip@patch:ip@npm:1.1.5#.yarn/patches/ip-npm-1.1.5-af36318aa6.patch::locator=root-workspace-0b6124%40workspace%3A.":
+ version: 1.1.5
+ resolution: "ip@patch:ip@npm%3A1.1.5#.yarn/patches/ip-npm-1.1.5-af36318aa6.patch::version=1.1.5&hash=734266&locator=root-workspace-0b6124%40workspace%3A."
+ checksum: 0f3ba3f703f31807dd0a4f73269fadc65c80beb4fa8680c2c2119dd5d16e5cc849506342d08030d89286344262e8b2f1869d88e23c54c4213c580c4368e72260
+ languageName: node
+ linkType: hard
+
"ipaddr.js@npm:1.9.1":
version: 1.9.1
resolution: "ipaddr.js@npm:1.9.1"