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 ++ ++ ++ ++ ++ ++ +\ 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"