@module-federation/bridge-react-webpack-plugin
Advanced tools
@module-federation/bridge-react-webpack-plugin - npm Package Compare versions
Comparing version 0.0.0-next-20240822090000 to 0.0.0-next-20240822101913
| # @module-federation/bridge-react-webpack-plugin | ||
| ## 0.0.0-next-20240822090000 | ||
| ## 0.0.0-next-20240822101913 | ||
| ### Patch Changes | ||
| - Updated dependencies [b90fa7d] | ||
| - @module-federation/sdk@0.0.0-next-20240822101913 | ||
| ## 0.5.1 | ||
| ### Patch Changes | ||
| - 472e2cc: feat: enchance react-bridge react-router-dom alias according to origin react-router-dom version | ||
| - @module-federation/sdk@0.5.1 | ||
| ## 0.5.0 | ||
| ### Patch Changes | ||
| - 49d6135: feat(@module-federation/bridge): enhance Bridge capabilities and fix some issues | ||
| - Updated dependencies [8378a77] | ||
| - @module-federation/sdk@0.0.0-next-20240822090000 | ||
| - @module-federation/sdk@0.5.0 | ||
@@ -10,0 +25,0 @@ ## 0.4.0 |
| "use strict"; | ||
| var __create = Object.create; | ||
| var __defProp = Object.defineProperty; | ||
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
| var __getOwnPropNames = Object.getOwnPropertyNames; | ||
| var __getProtoOf = Object.getPrototypeOf; | ||
| var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
| var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; | ||
| var __copyProps = (to, from, except, desc) => { | ||
| if (from && typeof from === "object" || typeof from === "function") { | ||
| for (let key of __getOwnPropNames(from)) | ||
| if (!__hasOwnProp.call(to, key) && key !== except) | ||
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
| } | ||
| return to; | ||
| }; | ||
| var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( | ||
| // If the importer is in node compatibility mode or this is not an ESM | ||
| // file that has been converted to a CommonJS file using a Babel- | ||
| // compatible transform (i.e. "__esModule" has not been set), then set | ||
| // "default" to the CommonJS "module.exports" for node compatibility. | ||
| isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, | ||
| mod | ||
| )); | ||
| var __publicField = (obj, key, value) => { | ||
@@ -10,2 +31,1666 @@ __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); | ||
| const path = require("node:path"); | ||
| function getDefaultExportFromCjs(x) { | ||
| return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; | ||
| } | ||
| var re$2 = { exports: {} }; | ||
| const SEMVER_SPEC_VERSION = "2.0.0"; | ||
| const MAX_LENGTH$1 = 256; | ||
| const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */ | ||
| 9007199254740991; | ||
| const MAX_SAFE_COMPONENT_LENGTH = 16; | ||
| const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6; | ||
| const RELEASE_TYPES = [ | ||
| "major", | ||
| "premajor", | ||
| "minor", | ||
| "preminor", | ||
| "patch", | ||
| "prepatch", | ||
| "prerelease" | ||
| ]; | ||
| var constants$1 = { | ||
| MAX_LENGTH: MAX_LENGTH$1, | ||
| MAX_SAFE_COMPONENT_LENGTH, | ||
| MAX_SAFE_BUILD_LENGTH, | ||
| MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1, | ||
| RELEASE_TYPES, | ||
| SEMVER_SPEC_VERSION, | ||
| FLAG_INCLUDE_PRERELEASE: 1, | ||
| FLAG_LOOSE: 2 | ||
| }; | ||
| const debug$1 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => { | ||
| }; | ||
| var debug_1 = debug$1; | ||
| (function(module2, exports2) { | ||
| const { | ||
| MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2, | ||
| MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH2, | ||
| MAX_LENGTH: MAX_LENGTH2 | ||
| } = constants$1; | ||
| const debug2 = debug_1; | ||
| exports2 = module2.exports = {}; | ||
| const re2 = exports2.re = []; | ||
| const safeRe = exports2.safeRe = []; | ||
| const src = exports2.src = []; | ||
| const t2 = exports2.t = {}; | ||
| let R = 0; | ||
| const LETTERDASHNUMBER = "[a-zA-Z0-9-]"; | ||
| const safeRegexReplacements = [ | ||
| ["\\s", 1], | ||
| ["\\d", MAX_LENGTH2], | ||
| [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH2] | ||
| ]; | ||
| const makeSafeRegex = (value) => { | ||
| for (const [token, max] of safeRegexReplacements) { | ||
| value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`); | ||
| } | ||
| return value; | ||
| }; | ||
| const createToken = (name, value, isGlobal) => { | ||
| const safe = makeSafeRegex(value); | ||
| const index = R++; | ||
| debug2(name, index, value); | ||
| t2[name] = index; | ||
| src[index] = value; | ||
| re2[index] = new RegExp(value, isGlobal ? "g" : void 0); | ||
| safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0); | ||
| }; | ||
| createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*"); | ||
| createToken("NUMERICIDENTIFIERLOOSE", "\\d+"); | ||
| createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`); | ||
| createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`); | ||
| createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`); | ||
| createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NUMERICIDENTIFIER]}|${src[t2.NONNUMERICIDENTIFIER]})`); | ||
| createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NUMERICIDENTIFIERLOOSE]}|${src[t2.NONNUMERICIDENTIFIER]})`); | ||
| createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`); | ||
| createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`); | ||
| createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`); | ||
| createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`); | ||
| createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`); | ||
| createToken("FULL", `^${src[t2.FULLPLAIN]}$`); | ||
| createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`); | ||
| createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`); | ||
| createToken("GTLT", "((?:<|>)?=?)"); | ||
| createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`); | ||
| createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`); | ||
| createToken("XRANGEPLAIN", `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${src[t2.PRERELEASE]})?${src[t2.BUILD]}?)?)?`); | ||
| createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`); | ||
| createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`); | ||
| createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`); | ||
| createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?`); | ||
| createToken("COERCE", `${src[t2.COERCEPLAIN]}(?:$|[^\\d])`); | ||
| createToken("COERCEFULL", src[t2.COERCEPLAIN] + `(?:${src[t2.PRERELEASE]})?(?:${src[t2.BUILD]})?(?:$|[^\\d])`); | ||
| createToken("COERCERTL", src[t2.COERCE], true); | ||
| createToken("COERCERTLFULL", src[t2.COERCEFULL], true); | ||
| createToken("LONETILDE", "(?:~>?)"); | ||
| createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true); | ||
| exports2.tildeTrimReplace = "$1~"; | ||
| createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`); | ||
| createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`); | ||
| createToken("LONECARET", "(?:\\^)"); | ||
| createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true); | ||
| exports2.caretTrimReplace = "$1^"; | ||
| createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`); | ||
| createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`); | ||
| createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`); | ||
| createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`); | ||
| createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true); | ||
| exports2.comparatorTrimReplace = "$1$2$3"; | ||
| createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`); | ||
| createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`); | ||
| createToken("STAR", "(<|>)?=?\\s*\\*"); | ||
| createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"); | ||
| createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$"); | ||
| })(re$2, re$2.exports); | ||
| var reExports = re$2.exports; | ||
| const looseOption = Object.freeze({ loose: true }); | ||
| const emptyOpts = Object.freeze({}); | ||
| const parseOptions$1 = (options) => { | ||
| if (!options) { | ||
| return emptyOpts; | ||
| } | ||
| if (typeof options !== "object") { | ||
| return looseOption; | ||
| } | ||
| return options; | ||
| }; | ||
| var parseOptions_1 = parseOptions$1; | ||
| const numeric = /^[0-9]+$/; | ||
| const compareIdentifiers$1 = (a, b) => { | ||
| const anum = numeric.test(a); | ||
| const bnum = numeric.test(b); | ||
| if (anum && bnum) { | ||
| a = +a; | ||
| b = +b; | ||
| } | ||
| return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1; | ||
| }; | ||
| const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a); | ||
| var identifiers$1 = { | ||
| compareIdentifiers: compareIdentifiers$1, | ||
| rcompareIdentifiers | ||
| }; | ||
| const debug = debug_1; | ||
| const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants$1; | ||
| const { safeRe: re$1, t: t$1 } = reExports; | ||
| const parseOptions = parseOptions_1; | ||
| const { compareIdentifiers } = identifiers$1; | ||
| let SemVer$d = class SemVer { | ||
| constructor(version, options) { | ||
| options = parseOptions(options); | ||
| if (version instanceof SemVer) { | ||
| if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) { | ||
| return version; | ||
| } else { | ||
| version = version.version; | ||
| } | ||
| } else if (typeof version !== "string") { | ||
| throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`); | ||
| } | ||
| if (version.length > MAX_LENGTH) { | ||
| throw new TypeError( | ||
| `version is longer than ${MAX_LENGTH} characters` | ||
| ); | ||
| } | ||
| debug("SemVer", version, options); | ||
| this.options = options; | ||
| this.loose = !!options.loose; | ||
| this.includePrerelease = !!options.includePrerelease; | ||
| const m = version.trim().match(options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL]); | ||
| if (!m) { | ||
| throw new TypeError(`Invalid Version: ${version}`); | ||
| } | ||
| this.raw = version; | ||
| this.major = +m[1]; | ||
| this.minor = +m[2]; | ||
| this.patch = +m[3]; | ||
| if (this.major > MAX_SAFE_INTEGER || this.major < 0) { | ||
| throw new TypeError("Invalid major version"); | ||
| } | ||
| if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { | ||
| throw new TypeError("Invalid minor version"); | ||
| } | ||
| if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { | ||
| throw new TypeError("Invalid patch version"); | ||
| } | ||
| if (!m[4]) { | ||
| this.prerelease = []; | ||
| } else { | ||
| this.prerelease = m[4].split(".").map((id) => { | ||
| if (/^[0-9]+$/.test(id)) { | ||
| const num = +id; | ||
| if (num >= 0 && num < MAX_SAFE_INTEGER) { | ||
| return num; | ||
| } | ||
| } | ||
| return id; | ||
| }); | ||
| } | ||
| this.build = m[5] ? m[5].split(".") : []; | ||
| this.format(); | ||
| } | ||
| format() { | ||
| this.version = `${this.major}.${this.minor}.${this.patch}`; | ||
| if (this.prerelease.length) { | ||
| this.version += `-${this.prerelease.join(".")}`; | ||
| } | ||
| return this.version; | ||
| } | ||
| toString() { | ||
| return this.version; | ||
| } | ||
| compare(other) { | ||
| debug("SemVer.compare", this.version, this.options, other); | ||
| if (!(other instanceof SemVer)) { | ||
| if (typeof other === "string" && other === this.version) { | ||
| return 0; | ||
| } | ||
| other = new SemVer(other, this.options); | ||
| } | ||
| if (other.version === this.version) { | ||
| return 0; | ||
| } | ||
| return this.compareMain(other) || this.comparePre(other); | ||
| } | ||
| compareMain(other) { | ||
| if (!(other instanceof SemVer)) { | ||
| other = new SemVer(other, this.options); | ||
| } | ||
| return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch); | ||
| } | ||
| comparePre(other) { | ||
| if (!(other instanceof SemVer)) { | ||
| other = new SemVer(other, this.options); | ||
| } | ||
| if (this.prerelease.length && !other.prerelease.length) { | ||
| return -1; | ||
| } else if (!this.prerelease.length && other.prerelease.length) { | ||
| return 1; | ||
| } else if (!this.prerelease.length && !other.prerelease.length) { | ||
| return 0; | ||
| } | ||
| let i = 0; | ||
| do { | ||
| const a = this.prerelease[i]; | ||
| const b = other.prerelease[i]; | ||
| debug("prerelease compare", i, a, b); | ||
| if (a === void 0 && b === void 0) { | ||
| return 0; | ||
| } else if (b === void 0) { | ||
| return 1; | ||
| } else if (a === void 0) { | ||
| return -1; | ||
| } else if (a === b) { | ||
| continue; | ||
| } else { | ||
| return compareIdentifiers(a, b); | ||
| } | ||
| } while (++i); | ||
| } | ||
| compareBuild(other) { | ||
| if (!(other instanceof SemVer)) { | ||
| other = new SemVer(other, this.options); | ||
| } | ||
| let i = 0; | ||
| do { | ||
| const a = this.build[i]; | ||
| const b = other.build[i]; | ||
| debug("build compare", i, a, b); | ||
| if (a === void 0 && b === void 0) { | ||
| return 0; | ||
| } else if (b === void 0) { | ||
| return 1; | ||
| } else if (a === void 0) { | ||
| return -1; | ||
| } else if (a === b) { | ||
| continue; | ||
| } else { | ||
| return compareIdentifiers(a, b); | ||
| } | ||
| } while (++i); | ||
| } | ||
| // preminor will bump the version up to the next minor release, and immediately | ||
| // down to pre-release. premajor and prepatch work the same way. | ||
| inc(release, identifier, identifierBase) { | ||
| switch (release) { | ||
| case "premajor": | ||
| this.prerelease.length = 0; | ||
| this.patch = 0; | ||
| this.minor = 0; | ||
| this.major++; | ||
| this.inc("pre", identifier, identifierBase); | ||
| break; | ||
| case "preminor": | ||
| this.prerelease.length = 0; | ||
| this.patch = 0; | ||
| this.minor++; | ||
| this.inc("pre", identifier, identifierBase); | ||
| break; | ||
| case "prepatch": | ||
| this.prerelease.length = 0; | ||
| this.inc("patch", identifier, identifierBase); | ||
| this.inc("pre", identifier, identifierBase); | ||
| break; | ||
| case "prerelease": | ||
| if (this.prerelease.length === 0) { | ||
| this.inc("patch", identifier, identifierBase); | ||
| } | ||
| this.inc("pre", identifier, identifierBase); | ||
| break; | ||
| case "major": | ||
| if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { | ||
| this.major++; | ||
| } | ||
| this.minor = 0; | ||
| this.patch = 0; | ||
| this.prerelease = []; | ||
| break; | ||
| case "minor": | ||
| if (this.patch !== 0 || this.prerelease.length === 0) { | ||
| this.minor++; | ||
| } | ||
| this.patch = 0; | ||
| this.prerelease = []; | ||
| break; | ||
| case "patch": | ||
| if (this.prerelease.length === 0) { | ||
| this.patch++; | ||
| } | ||
| this.prerelease = []; | ||
| break; | ||
| case "pre": { | ||
| const base = Number(identifierBase) ? 1 : 0; | ||
| if (!identifier && identifierBase === false) { | ||
| throw new Error("invalid increment argument: identifier is empty"); | ||
| } | ||
| if (this.prerelease.length === 0) { | ||
| this.prerelease = [base]; | ||
| } else { | ||
| let i = this.prerelease.length; | ||
| while (--i >= 0) { | ||
| if (typeof this.prerelease[i] === "number") { | ||
| this.prerelease[i]++; | ||
| i = -2; | ||
| } | ||
| } | ||
| if (i === -1) { | ||
| if (identifier === this.prerelease.join(".") && identifierBase === false) { | ||
| throw new Error("invalid increment argument: identifier already exists"); | ||
| } | ||
| this.prerelease.push(base); | ||
| } | ||
| } | ||
| if (identifier) { | ||
| let prerelease2 = [identifier, base]; | ||
| if (identifierBase === false) { | ||
| prerelease2 = [identifier]; | ||
| } | ||
| if (compareIdentifiers(this.prerelease[0], identifier) === 0) { | ||
| if (isNaN(this.prerelease[1])) { | ||
| this.prerelease = prerelease2; | ||
| } | ||
| } else { | ||
| this.prerelease = prerelease2; | ||
| } | ||
| } | ||
| break; | ||
| } | ||
| default: | ||
| throw new Error(`invalid increment argument: ${release}`); | ||
| } | ||
| this.raw = this.format(); | ||
| if (this.build.length) { | ||
| this.raw += `+${this.build.join(".")}`; | ||
| } | ||
| return this; | ||
| } | ||
| }; | ||
| var semver$2 = SemVer$d; | ||
| const SemVer$c = semver$2; | ||
| const parse$6 = (version, options, throwErrors = false) => { | ||
| if (version instanceof SemVer$c) { | ||
| return version; | ||
| } | ||
| try { | ||
| return new SemVer$c(version, options); | ||
| } catch (er) { | ||
| if (!throwErrors) { | ||
| return null; | ||
| } | ||
| throw er; | ||
| } | ||
| }; | ||
| var parse_1 = parse$6; | ||
| const parse$5 = parse_1; | ||
| const valid$2 = (version, options) => { | ||
| const v = parse$5(version, options); | ||
| return v ? v.version : null; | ||
| }; | ||
| var valid_1 = valid$2; | ||
| const parse$4 = parse_1; | ||
| const clean$1 = (version, options) => { | ||
| const s = parse$4(version.trim().replace(/^[=v]+/, ""), options); | ||
| return s ? s.version : null; | ||
| }; | ||
| var clean_1 = clean$1; | ||
| const SemVer$b = semver$2; | ||
| const inc$1 = (version, release, options, identifier, identifierBase) => { | ||
| if (typeof options === "string") { | ||
| identifierBase = identifier; | ||
| identifier = options; | ||
| options = void 0; | ||
| } | ||
| try { | ||
| return new SemVer$b( | ||
| version instanceof SemVer$b ? version.version : version, | ||
| options | ||
| ).inc(release, identifier, identifierBase).version; | ||
| } catch (er) { | ||
| return null; | ||
| } | ||
| }; | ||
| var inc_1 = inc$1; | ||
| const parse$3 = parse_1; | ||
| const diff$1 = (version1, version2) => { | ||
| const v1 = parse$3(version1, null, true); | ||
| const v2 = parse$3(version2, null, true); | ||
| const comparison = v1.compare(v2); | ||
| if (comparison === 0) { | ||
| return null; | ||
| } | ||
| const v1Higher = comparison > 0; | ||
| const highVersion = v1Higher ? v1 : v2; | ||
| const lowVersion = v1Higher ? v2 : v1; | ||
| const highHasPre = !!highVersion.prerelease.length; | ||
| const lowHasPre = !!lowVersion.prerelease.length; | ||
| if (lowHasPre && !highHasPre) { | ||
| if (!lowVersion.patch && !lowVersion.minor) { | ||
| return "major"; | ||
| } | ||
| if (highVersion.patch) { | ||
| return "patch"; | ||
| } | ||
| if (highVersion.minor) { | ||
| return "minor"; | ||
| } | ||
| return "major"; | ||
| } | ||
| const prefix = highHasPre ? "pre" : ""; | ||
| if (v1.major !== v2.major) { | ||
| return prefix + "major"; | ||
| } | ||
| if (v1.minor !== v2.minor) { | ||
| return prefix + "minor"; | ||
| } | ||
| if (v1.patch !== v2.patch) { | ||
| return prefix + "patch"; | ||
| } | ||
| return "prerelease"; | ||
| }; | ||
| var diff_1 = diff$1; | ||
| const SemVer$a = semver$2; | ||
| const major$1 = (a, loose) => new SemVer$a(a, loose).major; | ||
| var major_1 = major$1; | ||
| const SemVer$9 = semver$2; | ||
| const minor$1 = (a, loose) => new SemVer$9(a, loose).minor; | ||
| var minor_1 = minor$1; | ||
| const SemVer$8 = semver$2; | ||
| const patch$1 = (a, loose) => new SemVer$8(a, loose).patch; | ||
| var patch_1 = patch$1; | ||
| const parse$2 = parse_1; | ||
| const prerelease$1 = (version, options) => { | ||
| const parsed = parse$2(version, options); | ||
| return parsed && parsed.prerelease.length ? parsed.prerelease : null; | ||
| }; | ||
| var prerelease_1 = prerelease$1; | ||
| const SemVer$7 = semver$2; | ||
| const compare$b = (a, b, loose) => new SemVer$7(a, loose).compare(new SemVer$7(b, loose)); | ||
| var compare_1 = compare$b; | ||
| const compare$a = compare_1; | ||
| const rcompare$1 = (a, b, loose) => compare$a(b, a, loose); | ||
| var rcompare_1 = rcompare$1; | ||
| const compare$9 = compare_1; | ||
| const compareLoose$1 = (a, b) => compare$9(a, b, true); | ||
| var compareLoose_1 = compareLoose$1; | ||
| const SemVer$6 = semver$2; | ||
| const compareBuild$3 = (a, b, loose) => { | ||
| const versionA = new SemVer$6(a, loose); | ||
| const versionB = new SemVer$6(b, loose); | ||
| return versionA.compare(versionB) || versionA.compareBuild(versionB); | ||
| }; | ||
| var compareBuild_1 = compareBuild$3; | ||
| const compareBuild$2 = compareBuild_1; | ||
| const sort$1 = (list, loose) => list.sort((a, b) => compareBuild$2(a, b, loose)); | ||
| var sort_1 = sort$1; | ||
| const compareBuild$1 = compareBuild_1; | ||
| const rsort$1 = (list, loose) => list.sort((a, b) => compareBuild$1(b, a, loose)); | ||
| var rsort_1 = rsort$1; | ||
| const compare$8 = compare_1; | ||
| const gt$4 = (a, b, loose) => compare$8(a, b, loose) > 0; | ||
| var gt_1 = gt$4; | ||
| const compare$7 = compare_1; | ||
| const lt$3 = (a, b, loose) => compare$7(a, b, loose) < 0; | ||
| var lt_1 = lt$3; | ||
| const compare$6 = compare_1; | ||
| const eq$2 = (a, b, loose) => compare$6(a, b, loose) === 0; | ||
| var eq_1 = eq$2; | ||
| const compare$5 = compare_1; | ||
| const neq$2 = (a, b, loose) => compare$5(a, b, loose) !== 0; | ||
| var neq_1 = neq$2; | ||
| const compare$4 = compare_1; | ||
| const gte$3 = (a, b, loose) => compare$4(a, b, loose) >= 0; | ||
| var gte_1 = gte$3; | ||
| const compare$3 = compare_1; | ||
| const lte$3 = (a, b, loose) => compare$3(a, b, loose) <= 0; | ||
| var lte_1 = lte$3; | ||
| const eq$1 = eq_1; | ||
| const neq$1 = neq_1; | ||
| const gt$3 = gt_1; | ||
| const gte$2 = gte_1; | ||
| const lt$2 = lt_1; | ||
| const lte$2 = lte_1; | ||
| const cmp$1 = (a, op, b, loose) => { | ||
| switch (op) { | ||
| case "===": | ||
| if (typeof a === "object") { | ||
| a = a.version; | ||
| } | ||
| if (typeof b === "object") { | ||
| b = b.version; | ||
| } | ||
| return a === b; | ||
| case "!==": | ||
| if (typeof a === "object") { | ||
| a = a.version; | ||
| } | ||
| if (typeof b === "object") { | ||
| b = b.version; | ||
| } | ||
| return a !== b; | ||
| case "": | ||
| case "=": | ||
| case "==": | ||
| return eq$1(a, b, loose); | ||
| case "!=": | ||
| return neq$1(a, b, loose); | ||
| case ">": | ||
| return gt$3(a, b, loose); | ||
| case ">=": | ||
| return gte$2(a, b, loose); | ||
| case "<": | ||
| return lt$2(a, b, loose); | ||
| case "<=": | ||
| return lte$2(a, b, loose); | ||
| default: | ||
| throw new TypeError(`Invalid operator: ${op}`); | ||
| } | ||
| }; | ||
| var cmp_1 = cmp$1; | ||
| const SemVer$5 = semver$2; | ||
| const parse$1 = parse_1; | ||
| const { safeRe: re, t } = reExports; | ||
| const coerce$1 = (version, options) => { | ||
| if (version instanceof SemVer$5) { | ||
| return version; | ||
| } | ||
| if (typeof version === "number") { | ||
| version = String(version); | ||
| } | ||
| if (typeof version !== "string") { | ||
| return null; | ||
| } | ||
| options = options || {}; | ||
| let match = null; | ||
| if (!options.rtl) { | ||
| match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]); | ||
| } else { | ||
| const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]; | ||
| let next; | ||
| while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) { | ||
| if (!match || next.index + next[0].length !== match.index + match[0].length) { | ||
| match = next; | ||
| } | ||
| coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length; | ||
| } | ||
| coerceRtlRegex.lastIndex = -1; | ||
| } | ||
| if (match === null) { | ||
| return null; | ||
| } | ||
| const major2 = match[2]; | ||
| const minor2 = match[3] || "0"; | ||
| const patch2 = match[4] || "0"; | ||
| const prerelease2 = options.includePrerelease && match[5] ? `-${match[5]}` : ""; | ||
| const build = options.includePrerelease && match[6] ? `+${match[6]}` : ""; | ||
| return parse$1(`${major2}.${minor2}.${patch2}${prerelease2}${build}`, options); | ||
| }; | ||
| var coerce_1 = coerce$1; | ||
| class LRUCache { | ||
| constructor() { | ||
| this.max = 1e3; | ||
| this.map = /* @__PURE__ */ new Map(); | ||
| } | ||
| get(key) { | ||
| const value = this.map.get(key); | ||
| if (value === void 0) { | ||
| return void 0; | ||
| } else { | ||
| this.map.delete(key); | ||
| this.map.set(key, value); | ||
| return value; | ||
| } | ||
| } | ||
| delete(key) { | ||
| return this.map.delete(key); | ||
| } | ||
| set(key, value) { | ||
| const deleted = this.delete(key); | ||
| if (!deleted && value !== void 0) { | ||
| if (this.map.size >= this.max) { | ||
| const firstKey = this.map.keys().next().value; | ||
| this.delete(firstKey); | ||
| } | ||
| this.map.set(key, value); | ||
| } | ||
| return this; | ||
| } | ||
| } | ||
| var lrucache = LRUCache; | ||
| var range; | ||
| var hasRequiredRange; | ||
| function requireRange() { | ||
| if (hasRequiredRange) | ||
| return range; | ||
| hasRequiredRange = 1; | ||
| const SPACE_CHARACTERS = /\s+/g; | ||
| class Range2 { | ||
| constructor(range2, options) { | ||
| options = parseOptions2(options); | ||
| if (range2 instanceof Range2) { | ||
| if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) { | ||
| return range2; | ||
| } else { | ||
| return new Range2(range2.raw, options); | ||
| } | ||
| } | ||
| if (range2 instanceof Comparator2) { | ||
| this.raw = range2.value; | ||
| this.set = [[range2]]; | ||
| this.formatted = void 0; | ||
| return this; | ||
| } | ||
| this.options = options; | ||
| this.loose = !!options.loose; | ||
| this.includePrerelease = !!options.includePrerelease; | ||
| this.raw = range2.trim().replace(SPACE_CHARACTERS, " "); | ||
| this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length); | ||
| if (!this.set.length) { | ||
| throw new TypeError(`Invalid SemVer Range: ${this.raw}`); | ||
| } | ||
| if (this.set.length > 1) { | ||
| const first = this.set[0]; | ||
| this.set = this.set.filter((c) => !isNullSet(c[0])); | ||
| if (this.set.length === 0) { | ||
| this.set = [first]; | ||
| } else if (this.set.length > 1) { | ||
| for (const c of this.set) { | ||
| if (c.length === 1 && isAny(c[0])) { | ||
| this.set = [c]; | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| this.formatted = void 0; | ||
| } | ||
| get range() { | ||
| if (this.formatted === void 0) { | ||
| this.formatted = ""; | ||
| for (let i = 0; i < this.set.length; i++) { | ||
| if (i > 0) { | ||
| this.formatted += "||"; | ||
| } | ||
| const comps = this.set[i]; | ||
| for (let k = 0; k < comps.length; k++) { | ||
| if (k > 0) { | ||
| this.formatted += " "; | ||
| } | ||
| this.formatted += comps[k].toString().trim(); | ||
| } | ||
| } | ||
| } | ||
| return this.formatted; | ||
| } | ||
| format() { | ||
| return this.range; | ||
| } | ||
| toString() { | ||
| return this.range; | ||
| } | ||
| parseRange(range2) { | ||
| const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE); | ||
| const memoKey = memoOpts + ":" + range2; | ||
| const cached = cache.get(memoKey); | ||
| if (cached) { | ||
| return cached; | ||
| } | ||
| const loose = this.options.loose; | ||
| const hr = loose ? re2[t2.HYPHENRANGELOOSE] : re2[t2.HYPHENRANGE]; | ||
| range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease)); | ||
| debug2("hyphen replace", range2); | ||
| range2 = range2.replace(re2[t2.COMPARATORTRIM], comparatorTrimReplace); | ||
| debug2("comparator trim", range2); | ||
| range2 = range2.replace(re2[t2.TILDETRIM], tildeTrimReplace); | ||
| debug2("tilde trim", range2); | ||
| range2 = range2.replace(re2[t2.CARETTRIM], caretTrimReplace); | ||
| debug2("caret trim", range2); | ||
| let rangeList = range2.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options)); | ||
| if (loose) { | ||
| rangeList = rangeList.filter((comp) => { | ||
| debug2("loose invalid filter", comp, this.options); | ||
| return !!comp.match(re2[t2.COMPARATORLOOSE]); | ||
| }); | ||
| } | ||
| debug2("range list", rangeList); | ||
| const rangeMap = /* @__PURE__ */ new Map(); | ||
| const comparators = rangeList.map((comp) => new Comparator2(comp, this.options)); | ||
| for (const comp of comparators) { | ||
| if (isNullSet(comp)) { | ||
| return [comp]; | ||
| } | ||
| rangeMap.set(comp.value, comp); | ||
| } | ||
| if (rangeMap.size > 1 && rangeMap.has("")) { | ||
| rangeMap.delete(""); | ||
| } | ||
| const result = [...rangeMap.values()]; | ||
| cache.set(memoKey, result); | ||
| return result; | ||
| } | ||
| intersects(range2, options) { | ||
| if (!(range2 instanceof Range2)) { | ||
| throw new TypeError("a Range is required"); | ||
| } | ||
| return this.set.some((thisComparators) => { | ||
| return isSatisfiable(thisComparators, options) && range2.set.some((rangeComparators) => { | ||
| return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => { | ||
| return rangeComparators.every((rangeComparator) => { | ||
| return thisComparator.intersects(rangeComparator, options); | ||
| }); | ||
| }); | ||
| }); | ||
| }); | ||
| } | ||
| // if ANY of the sets match ALL of its comparators, then pass | ||
| test(version) { | ||
| if (!version) { | ||
| return false; | ||
| } | ||
| if (typeof version === "string") { | ||
| try { | ||
| version = new SemVer3(version, this.options); | ||
| } catch (er) { | ||
| return false; | ||
| } | ||
| } | ||
| for (let i = 0; i < this.set.length; i++) { | ||
| if (testSet(this.set[i], version, this.options)) { | ||
| return true; | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| range = Range2; | ||
| const LRU = lrucache; | ||
| const cache = new LRU(); | ||
| const parseOptions2 = parseOptions_1; | ||
| const Comparator2 = requireComparator(); | ||
| const debug2 = debug_1; | ||
| const SemVer3 = semver$2; | ||
| const { | ||
| safeRe: re2, | ||
| t: t2, | ||
| comparatorTrimReplace, | ||
| tildeTrimReplace, | ||
| caretTrimReplace | ||
| } = reExports; | ||
| const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = constants$1; | ||
| const isNullSet = (c) => c.value === "<0.0.0-0"; | ||
| const isAny = (c) => c.value === ""; | ||
| const isSatisfiable = (comparators, options) => { | ||
| let result = true; | ||
| const remainingComparators = comparators.slice(); | ||
| let testComparator = remainingComparators.pop(); | ||
| while (result && remainingComparators.length) { | ||
| result = remainingComparators.every((otherComparator) => { | ||
| return testComparator.intersects(otherComparator, options); | ||
| }); | ||
| testComparator = remainingComparators.pop(); | ||
| } | ||
| return result; | ||
| }; | ||
| const parseComparator = (comp, options) => { | ||
| debug2("comp", comp, options); | ||
| comp = replaceCarets(comp, options); | ||
| debug2("caret", comp); | ||
| comp = replaceTildes(comp, options); | ||
| debug2("tildes", comp); | ||
| comp = replaceXRanges(comp, options); | ||
| debug2("xrange", comp); | ||
| comp = replaceStars(comp, options); | ||
| debug2("stars", comp); | ||
| return comp; | ||
| }; | ||
| const isX = (id) => !id || id.toLowerCase() === "x" || id === "*"; | ||
| const replaceTildes = (comp, options) => { | ||
| return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" "); | ||
| }; | ||
| const replaceTilde = (comp, options) => { | ||
| const r = options.loose ? re2[t2.TILDELOOSE] : re2[t2.TILDE]; | ||
| return comp.replace(r, (_, M, m, p, pr) => { | ||
| debug2("tilde", comp, _, M, m, p, pr); | ||
| let ret; | ||
| if (isX(M)) { | ||
| ret = ""; | ||
| } else if (isX(m)) { | ||
| ret = `>=${M}.0.0 <${+M + 1}.0.0-0`; | ||
| } else if (isX(p)) { | ||
| ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`; | ||
| } else if (pr) { | ||
| debug2("replaceTilde pr", pr); | ||
| ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; | ||
| } else { | ||
| ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`; | ||
| } | ||
| debug2("tilde return", ret); | ||
| return ret; | ||
| }); | ||
| }; | ||
| const replaceCarets = (comp, options) => { | ||
| return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" "); | ||
| }; | ||
| const replaceCaret = (comp, options) => { | ||
| debug2("caret", comp, options); | ||
| const r = options.loose ? re2[t2.CARETLOOSE] : re2[t2.CARET]; | ||
| const z = options.includePrerelease ? "-0" : ""; | ||
| return comp.replace(r, (_, M, m, p, pr) => { | ||
| debug2("caret", comp, _, M, m, p, pr); | ||
| let ret; | ||
| if (isX(M)) { | ||
| ret = ""; | ||
| } else if (isX(m)) { | ||
| ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`; | ||
| } else if (isX(p)) { | ||
| if (M === "0") { | ||
| ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`; | ||
| } else { | ||
| ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`; | ||
| } | ||
| } else if (pr) { | ||
| debug2("replaceCaret pr", pr); | ||
| if (M === "0") { | ||
| if (m === "0") { | ||
| ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`; | ||
| } else { | ||
| ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; | ||
| } | ||
| } else { | ||
| ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`; | ||
| } | ||
| } else { | ||
| debug2("no pr"); | ||
| if (M === "0") { | ||
| if (m === "0") { | ||
| ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`; | ||
| } else { | ||
| ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`; | ||
| } | ||
| } else { | ||
| ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`; | ||
| } | ||
| } | ||
| debug2("caret return", ret); | ||
| return ret; | ||
| }); | ||
| }; | ||
| const replaceXRanges = (comp, options) => { | ||
| debug2("replaceXRanges", comp, options); | ||
| return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" "); | ||
| }; | ||
| const replaceXRange = (comp, options) => { | ||
| comp = comp.trim(); | ||
| const r = options.loose ? re2[t2.XRANGELOOSE] : re2[t2.XRANGE]; | ||
| return comp.replace(r, (ret, gtlt, M, m, p, pr) => { | ||
| debug2("xRange", comp, ret, gtlt, M, m, p, pr); | ||
| const xM = isX(M); | ||
| const xm = xM || isX(m); | ||
| const xp = xm || isX(p); | ||
| const anyX = xp; | ||
| if (gtlt === "=" && anyX) { | ||
| gtlt = ""; | ||
| } | ||
| pr = options.includePrerelease ? "-0" : ""; | ||
| if (xM) { | ||
| if (gtlt === ">" || gtlt === "<") { | ||
| ret = "<0.0.0-0"; | ||
| } else { | ||
| ret = "*"; | ||
| } | ||
| } else if (gtlt && anyX) { | ||
| if (xm) { | ||
| m = 0; | ||
| } | ||
| p = 0; | ||
| if (gtlt === ">") { | ||
| gtlt = ">="; | ||
| if (xm) { | ||
| M = +M + 1; | ||
| m = 0; | ||
| p = 0; | ||
| } else { | ||
| m = +m + 1; | ||
| p = 0; | ||
| } | ||
| } else if (gtlt === "<=") { | ||
| gtlt = "<"; | ||
| if (xm) { | ||
| M = +M + 1; | ||
| } else { | ||
| m = +m + 1; | ||
| } | ||
| } | ||
| if (gtlt === "<") { | ||
| pr = "-0"; | ||
| } | ||
| ret = `${gtlt + M}.${m}.${p}${pr}`; | ||
| } else if (xm) { | ||
| ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`; | ||
| } else if (xp) { | ||
| ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`; | ||
| } | ||
| debug2("xRange return", ret); | ||
| return ret; | ||
| }); | ||
| }; | ||
| const replaceStars = (comp, options) => { | ||
| debug2("replaceStars", comp, options); | ||
| return comp.trim().replace(re2[t2.STAR], ""); | ||
| }; | ||
| const replaceGTE0 = (comp, options) => { | ||
| debug2("replaceGTE0", comp, options); | ||
| return comp.trim().replace(re2[options.includePrerelease ? t2.GTE0PRE : t2.GTE0], ""); | ||
| }; | ||
| const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => { | ||
| if (isX(fM)) { | ||
| from = ""; | ||
| } else if (isX(fm)) { | ||
| from = `>=${fM}.0.0${incPr ? "-0" : ""}`; | ||
| } else if (isX(fp)) { | ||
| from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`; | ||
| } else if (fpr) { | ||
| from = `>=${from}`; | ||
| } else { | ||
| from = `>=${from}${incPr ? "-0" : ""}`; | ||
| } | ||
| if (isX(tM)) { | ||
| to = ""; | ||
| } else if (isX(tm)) { | ||
| to = `<${+tM + 1}.0.0-0`; | ||
| } else if (isX(tp)) { | ||
| to = `<${tM}.${+tm + 1}.0-0`; | ||
| } else if (tpr) { | ||
| to = `<=${tM}.${tm}.${tp}-${tpr}`; | ||
| } else if (incPr) { | ||
| to = `<${tM}.${tm}.${+tp + 1}-0`; | ||
| } else { | ||
| to = `<=${to}`; | ||
| } | ||
| return `${from} ${to}`.trim(); | ||
| }; | ||
| const testSet = (set, version, options) => { | ||
| for (let i = 0; i < set.length; i++) { | ||
| if (!set[i].test(version)) { | ||
| return false; | ||
| } | ||
| } | ||
| if (version.prerelease.length && !options.includePrerelease) { | ||
| for (let i = 0; i < set.length; i++) { | ||
| debug2(set[i].semver); | ||
| if (set[i].semver === Comparator2.ANY) { | ||
| continue; | ||
| } | ||
| if (set[i].semver.prerelease.length > 0) { | ||
| const allowed = set[i].semver; | ||
| if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) { | ||
| return true; | ||
| } | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
| return true; | ||
| }; | ||
| return range; | ||
| } | ||
| var comparator; | ||
| var hasRequiredComparator; | ||
| function requireComparator() { | ||
| if (hasRequiredComparator) | ||
| return comparator; | ||
| hasRequiredComparator = 1; | ||
| const ANY2 = Symbol("SemVer ANY"); | ||
| class Comparator2 { | ||
| static get ANY() { | ||
| return ANY2; | ||
| } | ||
| constructor(comp, options) { | ||
| options = parseOptions2(options); | ||
| if (comp instanceof Comparator2) { | ||
| if (comp.loose === !!options.loose) { | ||
| return comp; | ||
| } else { | ||
| comp = comp.value; | ||
| } | ||
| } | ||
| comp = comp.trim().split(/\s+/).join(" "); | ||
| debug2("comparator", comp, options); | ||
| this.options = options; | ||
| this.loose = !!options.loose; | ||
| this.parse(comp); | ||
| if (this.semver === ANY2) { | ||
| this.value = ""; | ||
| } else { | ||
| this.value = this.operator + this.semver.version; | ||
| } | ||
| debug2("comp", this); | ||
| } | ||
| parse(comp) { | ||
| const r = this.options.loose ? re2[t2.COMPARATORLOOSE] : re2[t2.COMPARATOR]; | ||
| const m = comp.match(r); | ||
| if (!m) { | ||
| throw new TypeError(`Invalid comparator: ${comp}`); | ||
| } | ||
| this.operator = m[1] !== void 0 ? m[1] : ""; | ||
| if (this.operator === "=") { | ||
| this.operator = ""; | ||
| } | ||
| if (!m[2]) { | ||
| this.semver = ANY2; | ||
| } else { | ||
| this.semver = new SemVer3(m[2], this.options.loose); | ||
| } | ||
| } | ||
| toString() { | ||
| return this.value; | ||
| } | ||
| test(version) { | ||
| debug2("Comparator.test", version, this.options.loose); | ||
| if (this.semver === ANY2 || version === ANY2) { | ||
| return true; | ||
| } | ||
| if (typeof version === "string") { | ||
| try { | ||
| version = new SemVer3(version, this.options); | ||
| } catch (er) { | ||
| return false; | ||
| } | ||
| } | ||
| return cmp2(version, this.operator, this.semver, this.options); | ||
| } | ||
| intersects(comp, options) { | ||
| if (!(comp instanceof Comparator2)) { | ||
| throw new TypeError("a Comparator is required"); | ||
| } | ||
| if (this.operator === "") { | ||
| if (this.value === "") { | ||
| return true; | ||
| } | ||
| return new Range2(comp.value, options).test(this.value); | ||
| } else if (comp.operator === "") { | ||
| if (comp.value === "") { | ||
| return true; | ||
| } | ||
| return new Range2(this.value, options).test(comp.semver); | ||
| } | ||
| options = parseOptions2(options); | ||
| if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) { | ||
| return false; | ||
| } | ||
| if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) { | ||
| return false; | ||
| } | ||
| if (this.operator.startsWith(">") && comp.operator.startsWith(">")) { | ||
| return true; | ||
| } | ||
| if (this.operator.startsWith("<") && comp.operator.startsWith("<")) { | ||
| return true; | ||
| } | ||
| if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) { | ||
| return true; | ||
| } | ||
| if (cmp2(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) { | ||
| return true; | ||
| } | ||
| if (cmp2(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) { | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| comparator = Comparator2; | ||
| const parseOptions2 = parseOptions_1; | ||
| const { safeRe: re2, t: t2 } = reExports; | ||
| const cmp2 = cmp_1; | ||
| const debug2 = debug_1; | ||
| const SemVer3 = semver$2; | ||
| const Range2 = requireRange(); | ||
| return comparator; | ||
| } | ||
| const Range$9 = requireRange(); | ||
| const satisfies$4 = (version, range2, options) => { | ||
| try { | ||
| range2 = new Range$9(range2, options); | ||
| } catch (er) { | ||
| return false; | ||
| } | ||
| return range2.test(version); | ||
| }; | ||
| var satisfies_1 = satisfies$4; | ||
| const Range$8 = requireRange(); | ||
| const toComparators$1 = (range2, options) => new Range$8(range2, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" ")); | ||
| var toComparators_1 = toComparators$1; | ||
| const SemVer$4 = semver$2; | ||
| const Range$7 = requireRange(); | ||
| const maxSatisfying$1 = (versions, range2, options) => { | ||
| let max = null; | ||
| let maxSV = null; | ||
| let rangeObj = null; | ||
| try { | ||
| rangeObj = new Range$7(range2, options); | ||
| } catch (er) { | ||
| return null; | ||
| } | ||
| versions.forEach((v) => { | ||
| if (rangeObj.test(v)) { | ||
| if (!max || maxSV.compare(v) === -1) { | ||
| max = v; | ||
| maxSV = new SemVer$4(max, options); | ||
| } | ||
| } | ||
| }); | ||
| return max; | ||
| }; | ||
| var maxSatisfying_1 = maxSatisfying$1; | ||
| const SemVer$3 = semver$2; | ||
| const Range$6 = requireRange(); | ||
| const minSatisfying$1 = (versions, range2, options) => { | ||
| let min = null; | ||
| let minSV = null; | ||
| let rangeObj = null; | ||
| try { | ||
| rangeObj = new Range$6(range2, options); | ||
| } catch (er) { | ||
| return null; | ||
| } | ||
| versions.forEach((v) => { | ||
| if (rangeObj.test(v)) { | ||
| if (!min || minSV.compare(v) === 1) { | ||
| min = v; | ||
| minSV = new SemVer$3(min, options); | ||
| } | ||
| } | ||
| }); | ||
| return min; | ||
| }; | ||
| var minSatisfying_1 = minSatisfying$1; | ||
| const SemVer$2 = semver$2; | ||
| const Range$5 = requireRange(); | ||
| const gt$2 = gt_1; | ||
| const minVersion$1 = (range2, loose) => { | ||
| range2 = new Range$5(range2, loose); | ||
| let minver = new SemVer$2("0.0.0"); | ||
| if (range2.test(minver)) { | ||
| return minver; | ||
| } | ||
| minver = new SemVer$2("0.0.0-0"); | ||
| if (range2.test(minver)) { | ||
| return minver; | ||
| } | ||
| minver = null; | ||
| for (let i = 0; i < range2.set.length; ++i) { | ||
| const comparators = range2.set[i]; | ||
| let setMin = null; | ||
| comparators.forEach((comparator2) => { | ||
| const compver = new SemVer$2(comparator2.semver.version); | ||
| switch (comparator2.operator) { | ||
| case ">": | ||
| if (compver.prerelease.length === 0) { | ||
| compver.patch++; | ||
| } else { | ||
| compver.prerelease.push(0); | ||
| } | ||
| compver.raw = compver.format(); | ||
| case "": | ||
| case ">=": | ||
| if (!setMin || gt$2(compver, setMin)) { | ||
| setMin = compver; | ||
| } | ||
| break; | ||
| case "<": | ||
| case "<=": | ||
| break; | ||
| default: | ||
| throw new Error(`Unexpected operation: ${comparator2.operator}`); | ||
| } | ||
| }); | ||
| if (setMin && (!minver || gt$2(minver, setMin))) { | ||
| minver = setMin; | ||
| } | ||
| } | ||
| if (minver && range2.test(minver)) { | ||
| return minver; | ||
| } | ||
| return null; | ||
| }; | ||
| var minVersion_1 = minVersion$1; | ||
| const Range$4 = requireRange(); | ||
| const validRange$1 = (range2, options) => { | ||
| try { | ||
| return new Range$4(range2, options).range || "*"; | ||
| } catch (er) { | ||
| return null; | ||
| } | ||
| }; | ||
| var valid$1 = validRange$1; | ||
| const SemVer$1 = semver$2; | ||
| const Comparator$2 = requireComparator(); | ||
| const { ANY: ANY$1 } = Comparator$2; | ||
| const Range$3 = requireRange(); | ||
| const satisfies$3 = satisfies_1; | ||
| const gt$1 = gt_1; | ||
| const lt$1 = lt_1; | ||
| const lte$1 = lte_1; | ||
| const gte$1 = gte_1; | ||
| const outside$3 = (version, range2, hilo, options) => { | ||
| version = new SemVer$1(version, options); | ||
| range2 = new Range$3(range2, options); | ||
| let gtfn, ltefn, ltfn, comp, ecomp; | ||
| switch (hilo) { | ||
| case ">": | ||
| gtfn = gt$1; | ||
| ltefn = lte$1; | ||
| ltfn = lt$1; | ||
| comp = ">"; | ||
| ecomp = ">="; | ||
| break; | ||
| case "<": | ||
| gtfn = lt$1; | ||
| ltefn = gte$1; | ||
| ltfn = gt$1; | ||
| comp = "<"; | ||
| ecomp = "<="; | ||
| break; | ||
| default: | ||
| throw new TypeError('Must provide a hilo val of "<" or ">"'); | ||
| } | ||
| if (satisfies$3(version, range2, options)) { | ||
| return false; | ||
| } | ||
| for (let i = 0; i < range2.set.length; ++i) { | ||
| const comparators = range2.set[i]; | ||
| let high = null; | ||
| let low = null; | ||
| comparators.forEach((comparator2) => { | ||
| if (comparator2.semver === ANY$1) { | ||
| comparator2 = new Comparator$2(">=0.0.0"); | ||
| } | ||
| high = high || comparator2; | ||
| low = low || comparator2; | ||
| if (gtfn(comparator2.semver, high.semver, options)) { | ||
| high = comparator2; | ||
| } else if (ltfn(comparator2.semver, low.semver, options)) { | ||
| low = comparator2; | ||
| } | ||
| }); | ||
| if (high.operator === comp || high.operator === ecomp) { | ||
| return false; | ||
| } | ||
| if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) { | ||
| return false; | ||
| } else if (low.operator === ecomp && ltfn(version, low.semver)) { | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| }; | ||
| var outside_1 = outside$3; | ||
| const outside$2 = outside_1; | ||
| const gtr$1 = (version, range2, options) => outside$2(version, range2, ">", options); | ||
| var gtr_1 = gtr$1; | ||
| const outside$1 = outside_1; | ||
| const ltr$1 = (version, range2, options) => outside$1(version, range2, "<", options); | ||
| var ltr_1 = ltr$1; | ||
| const Range$2 = requireRange(); | ||
| const intersects$1 = (r1, r2, options) => { | ||
| r1 = new Range$2(r1, options); | ||
| r2 = new Range$2(r2, options); | ||
| return r1.intersects(r2, options); | ||
| }; | ||
| var intersects_1 = intersects$1; | ||
| const satisfies$2 = satisfies_1; | ||
| const compare$2 = compare_1; | ||
| var simplify = (versions, range2, options) => { | ||
| const set = []; | ||
| let first = null; | ||
| let prev = null; | ||
| const v = versions.sort((a, b) => compare$2(a, b, options)); | ||
| for (const version of v) { | ||
| const included = satisfies$2(version, range2, options); | ||
| if (included) { | ||
| prev = version; | ||
| if (!first) { | ||
| first = version; | ||
| } | ||
| } else { | ||
| if (prev) { | ||
| set.push([first, prev]); | ||
| } | ||
| prev = null; | ||
| first = null; | ||
| } | ||
| } | ||
| if (first) { | ||
| set.push([first, null]); | ||
| } | ||
| const ranges = []; | ||
| for (const [min, max] of set) { | ||
| if (min === max) { | ||
| ranges.push(min); | ||
| } else if (!max && min === v[0]) { | ||
| ranges.push("*"); | ||
| } else if (!max) { | ||
| ranges.push(`>=${min}`); | ||
| } else if (min === v[0]) { | ||
| ranges.push(`<=${max}`); | ||
| } else { | ||
| ranges.push(`${min} - ${max}`); | ||
| } | ||
| } | ||
| const simplified = ranges.join(" || "); | ||
| const original = typeof range2.raw === "string" ? range2.raw : String(range2); | ||
| return simplified.length < original.length ? simplified : range2; | ||
| }; | ||
| const Range$1 = requireRange(); | ||
| const Comparator$1 = requireComparator(); | ||
| const { ANY } = Comparator$1; | ||
| const satisfies$1 = satisfies_1; | ||
| const compare$1 = compare_1; | ||
| const subset$1 = (sub, dom, options = {}) => { | ||
| if (sub === dom) { | ||
| return true; | ||
| } | ||
| sub = new Range$1(sub, options); | ||
| dom = new Range$1(dom, options); | ||
| let sawNonNull = false; | ||
| OUTER: | ||
| for (const simpleSub of sub.set) { | ||
| for (const simpleDom of dom.set) { | ||
| const isSub = simpleSubset(simpleSub, simpleDom, options); | ||
| sawNonNull = sawNonNull || isSub !== null; | ||
| if (isSub) { | ||
| continue OUTER; | ||
| } | ||
| } | ||
| if (sawNonNull) { | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| }; | ||
| const minimumVersionWithPreRelease = [new Comparator$1(">=0.0.0-0")]; | ||
| const minimumVersion = [new Comparator$1(">=0.0.0")]; | ||
| const simpleSubset = (sub, dom, options) => { | ||
| if (sub === dom) { | ||
| return true; | ||
| } | ||
| if (sub.length === 1 && sub[0].semver === ANY) { | ||
| if (dom.length === 1 && dom[0].semver === ANY) { | ||
| return true; | ||
| } else if (options.includePrerelease) { | ||
| sub = minimumVersionWithPreRelease; | ||
| } else { | ||
| sub = minimumVersion; | ||
| } | ||
| } | ||
| if (dom.length === 1 && dom[0].semver === ANY) { | ||
| if (options.includePrerelease) { | ||
| return true; | ||
| } else { | ||
| dom = minimumVersion; | ||
| } | ||
| } | ||
| const eqSet = /* @__PURE__ */ new Set(); | ||
| let gt2, lt2; | ||
| for (const c of sub) { | ||
| if (c.operator === ">" || c.operator === ">=") { | ||
| gt2 = higherGT(gt2, c, options); | ||
| } else if (c.operator === "<" || c.operator === "<=") { | ||
| lt2 = lowerLT(lt2, c, options); | ||
| } else { | ||
| eqSet.add(c.semver); | ||
| } | ||
| } | ||
| if (eqSet.size > 1) { | ||
| return null; | ||
| } | ||
| let gtltComp; | ||
| if (gt2 && lt2) { | ||
| gtltComp = compare$1(gt2.semver, lt2.semver, options); | ||
| if (gtltComp > 0) { | ||
| return null; | ||
| } else if (gtltComp === 0 && (gt2.operator !== ">=" || lt2.operator !== "<=")) { | ||
| return null; | ||
| } | ||
| } | ||
| for (const eq2 of eqSet) { | ||
| if (gt2 && !satisfies$1(eq2, String(gt2), options)) { | ||
| return null; | ||
| } | ||
| if (lt2 && !satisfies$1(eq2, String(lt2), options)) { | ||
| return null; | ||
| } | ||
| for (const c of dom) { | ||
| if (!satisfies$1(eq2, String(c), options)) { | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| } | ||
| let higher, lower; | ||
| let hasDomLT, hasDomGT; | ||
| let needDomLTPre = lt2 && !options.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false; | ||
| let needDomGTPre = gt2 && !options.includePrerelease && gt2.semver.prerelease.length ? gt2.semver : false; | ||
| if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt2.operator === "<" && needDomLTPre.prerelease[0] === 0) { | ||
| needDomLTPre = false; | ||
| } | ||
| for (const c of dom) { | ||
| hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">="; | ||
| hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<="; | ||
| if (gt2) { | ||
| if (needDomGTPre) { | ||
| if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) { | ||
| needDomGTPre = false; | ||
| } | ||
| } | ||
| if (c.operator === ">" || c.operator === ">=") { | ||
| higher = higherGT(gt2, c, options); | ||
| if (higher === c && higher !== gt2) { | ||
| return false; | ||
| } | ||
| } else if (gt2.operator === ">=" && !satisfies$1(gt2.semver, String(c), options)) { | ||
| return false; | ||
| } | ||
| } | ||
| if (lt2) { | ||
| if (needDomLTPre) { | ||
| if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) { | ||
| needDomLTPre = false; | ||
| } | ||
| } | ||
| if (c.operator === "<" || c.operator === "<=") { | ||
| lower = lowerLT(lt2, c, options); | ||
| if (lower === c && lower !== lt2) { | ||
| return false; | ||
| } | ||
| } else if (lt2.operator === "<=" && !satisfies$1(lt2.semver, String(c), options)) { | ||
| return false; | ||
| } | ||
| } | ||
| if (!c.operator && (lt2 || gt2) && gtltComp !== 0) { | ||
| return false; | ||
| } | ||
| } | ||
| if (gt2 && hasDomLT && !lt2 && gtltComp !== 0) { | ||
| return false; | ||
| } | ||
| if (lt2 && hasDomGT && !gt2 && gtltComp !== 0) { | ||
| return false; | ||
| } | ||
| if (needDomGTPre || needDomLTPre) { | ||
| return false; | ||
| } | ||
| return true; | ||
| }; | ||
| const higherGT = (a, b, options) => { | ||
| if (!a) { | ||
| return b; | ||
| } | ||
| const comp = compare$1(a.semver, b.semver, options); | ||
| return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a; | ||
| }; | ||
| const lowerLT = (a, b, options) => { | ||
| if (!a) { | ||
| return b; | ||
| } | ||
| const comp = compare$1(a.semver, b.semver, options); | ||
| return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a; | ||
| }; | ||
| var subset_1 = subset$1; | ||
| const internalRe = reExports; | ||
| const constants = constants$1; | ||
| const SemVer2 = semver$2; | ||
| const identifiers = identifiers$1; | ||
| const parse = parse_1; | ||
| const valid = valid_1; | ||
| const clean = clean_1; | ||
| const inc = inc_1; | ||
| const diff = diff_1; | ||
| const major = major_1; | ||
| const minor = minor_1; | ||
| const patch = patch_1; | ||
| const prerelease = prerelease_1; | ||
| const compare = compare_1; | ||
| const rcompare = rcompare_1; | ||
| const compareLoose = compareLoose_1; | ||
| const compareBuild = compareBuild_1; | ||
| const sort = sort_1; | ||
| const rsort = rsort_1; | ||
| const gt = gt_1; | ||
| const lt = lt_1; | ||
| const eq = eq_1; | ||
| const neq = neq_1; | ||
| const gte = gte_1; | ||
| const lte = lte_1; | ||
| const cmp = cmp_1; | ||
| const coerce = coerce_1; | ||
| const Comparator = requireComparator(); | ||
| const Range = requireRange(); | ||
| const satisfies = satisfies_1; | ||
| const toComparators = toComparators_1; | ||
| const maxSatisfying = maxSatisfying_1; | ||
| const minSatisfying = minSatisfying_1; | ||
| const minVersion = minVersion_1; | ||
| const validRange = valid$1; | ||
| const outside = outside_1; | ||
| const gtr = gtr_1; | ||
| const ltr = ltr_1; | ||
| const intersects = intersects_1; | ||
| const simplifyRange = simplify; | ||
| const subset = subset_1; | ||
| var semver = { | ||
| parse, | ||
| valid, | ||
| clean, | ||
| inc, | ||
| diff, | ||
| major, | ||
| minor, | ||
| patch, | ||
| prerelease, | ||
| compare, | ||
| rcompare, | ||
| compareLoose, | ||
| compareBuild, | ||
| sort, | ||
| rsort, | ||
| gt, | ||
| lt, | ||
| eq, | ||
| neq, | ||
| gte, | ||
| lte, | ||
| cmp, | ||
| coerce, | ||
| Comparator, | ||
| Range, | ||
| satisfies, | ||
| toComparators, | ||
| maxSatisfying, | ||
| minSatisfying, | ||
| minVersion, | ||
| validRange, | ||
| outside, | ||
| gtr, | ||
| ltr, | ||
| intersects, | ||
| simplifyRange, | ||
| subset, | ||
| SemVer: SemVer2, | ||
| re: internalRe.re, | ||
| src: internalRe.src, | ||
| tokens: internalRe.t, | ||
| SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION, | ||
| RELEASE_TYPES: constants.RELEASE_TYPES, | ||
| compareIdentifiers: identifiers.compareIdentifiers, | ||
| rcompareIdentifiers: identifiers.rcompareIdentifiers | ||
| }; | ||
| const semver$1 = /* @__PURE__ */ getDefaultExportFromCjs(semver); | ||
| const getBridgeRouterAlias = (originalAlias) => { | ||
| const userPackageJsonPath = path.resolve(process.cwd(), "package.json"); | ||
| let userDependencies = {}; | ||
| if (fs.existsSync(userPackageJsonPath)) { | ||
| const userPackageJson = JSON.parse( | ||
| fs.readFileSync(userPackageJsonPath, "utf-8") | ||
| ); | ||
| userDependencies = { | ||
| ...userPackageJson.dependencies, | ||
| ...userPackageJson.devDependencies | ||
| }; | ||
| } | ||
| const hasBridgeReact = "@module-federation/bridge-react" in userDependencies; | ||
| let bridgeRouterAlias = {}; | ||
| if (hasBridgeReact) { | ||
| const reactRouterDomVersion = userDependencies["react-router-dom"]; | ||
| let majorVersion = 0; | ||
| let reactRouterDomPath = ""; | ||
| if (reactRouterDomVersion) { | ||
| majorVersion = semver$1.major( | ||
| semver$1.coerce(reactRouterDomVersion || "0.0.0") ?? "0.0.0" | ||
| ); | ||
| reactRouterDomPath = require.resolve("react-router-dom"); | ||
| } else { | ||
| reactRouterDomPath = require.resolve("react-router-dom"); | ||
| const packageJsonPath = path.resolve( | ||
| reactRouterDomPath, | ||
| "../../package.json" | ||
| ); | ||
| const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")); | ||
| majorVersion = parseInt(packageJson.version.split(".")[0]); | ||
| } | ||
| reactRouterDomPath = originalAlias || reactRouterDomPath; | ||
| if (majorVersion === 5) { | ||
| bridgeRouterAlias = { | ||
| "react-router-dom$": "@module-federation/bridge-react/dist/router-v5.es.js" | ||
| }; | ||
| try { | ||
| require.resolve("react-router-dom/index.js"); | ||
| } catch (error) { | ||
| bridgeRouterAlias = { | ||
| ...bridgeRouterAlias, | ||
| "react-router-dom/index.js": reactRouterDomPath | ||
| }; | ||
| } | ||
| } else if (majorVersion === 6) { | ||
| bridgeRouterAlias = { | ||
| "react-router-dom$": "@module-federation/bridge-react/dist/router-v6.es.js" | ||
| }; | ||
| try { | ||
| require.resolve("react-router-dom/dist/index.js"); | ||
| } catch (error) { | ||
| bridgeRouterAlias = { | ||
| ...bridgeRouterAlias, | ||
| "react-router-dom/dist/index.js": reactRouterDomPath | ||
| }; | ||
| } | ||
| } else { | ||
| console.warn("react-router-dom version is not supported"); | ||
| } | ||
| } | ||
| console.log( | ||
| "<<<<<<<<<<<<< bridgeRouterAlias >>>>>>>>>>>>>", | ||
| bridgeRouterAlias | ||
| ); | ||
| return bridgeRouterAlias; | ||
| }; | ||
| class ReactBridgeAliasChangerPlugin { | ||
@@ -42,3 +1727,8 @@ constructor(info) { | ||
| const originalAlias = originalResolve.alias || {}; | ||
| const updatedAlias = { ...originalAlias, [this.alias]: targetFilePath }; | ||
| const updatedAlias = { | ||
| // allow `alias` can be override | ||
| // [this.alias]: targetFilePath, | ||
| ...getBridgeRouterAlias(originalAlias["react-router-dom"]), | ||
| ...originalAlias | ||
| }; | ||
| compiler.options.resolve = { | ||
@@ -45,0 +1735,0 @@ ...originalResolve, |
1671
dist/index.es.js
@@ -9,2 +9,1666 @@ var __defProp = Object.defineProperty; | ||
| import path from "node:path"; | ||
| function getDefaultExportFromCjs(x) { | ||
| return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; | ||
| } | ||
| var re$2 = { exports: {} }; | ||
| const SEMVER_SPEC_VERSION = "2.0.0"; | ||
| const MAX_LENGTH$1 = 256; | ||
| const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */ | ||
| 9007199254740991; | ||
| const MAX_SAFE_COMPONENT_LENGTH = 16; | ||
| const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6; | ||
| const RELEASE_TYPES = [ | ||
| "major", | ||
| "premajor", | ||
| "minor", | ||
| "preminor", | ||
| "patch", | ||
| "prepatch", | ||
| "prerelease" | ||
| ]; | ||
| var constants$1 = { | ||
| MAX_LENGTH: MAX_LENGTH$1, | ||
| MAX_SAFE_COMPONENT_LENGTH, | ||
| MAX_SAFE_BUILD_LENGTH, | ||
| MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1, | ||
| RELEASE_TYPES, | ||
| SEMVER_SPEC_VERSION, | ||
| FLAG_INCLUDE_PRERELEASE: 1, | ||
| FLAG_LOOSE: 2 | ||
| }; | ||
| const debug$1 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => { | ||
| }; | ||
| var debug_1 = debug$1; | ||
| (function(module, exports) { | ||
| const { | ||
| MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2, | ||
| MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH2, | ||
| MAX_LENGTH: MAX_LENGTH2 | ||
| } = constants$1; | ||
| const debug2 = debug_1; | ||
| exports = module.exports = {}; | ||
| const re2 = exports.re = []; | ||
| const safeRe = exports.safeRe = []; | ||
| const src = exports.src = []; | ||
| const t2 = exports.t = {}; | ||
| let R = 0; | ||
| const LETTERDASHNUMBER = "[a-zA-Z0-9-]"; | ||
| const safeRegexReplacements = [ | ||
| ["\\s", 1], | ||
| ["\\d", MAX_LENGTH2], | ||
| [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH2] | ||
| ]; | ||
| const makeSafeRegex = (value) => { | ||
| for (const [token, max] of safeRegexReplacements) { | ||
| value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`); | ||
| } | ||
| return value; | ||
| }; | ||
| const createToken = (name, value, isGlobal) => { | ||
| const safe = makeSafeRegex(value); | ||
| const index = R++; | ||
| debug2(name, index, value); | ||
| t2[name] = index; | ||
| src[index] = value; | ||
| re2[index] = new RegExp(value, isGlobal ? "g" : void 0); | ||
| safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0); | ||
| }; | ||
| createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*"); | ||
| createToken("NUMERICIDENTIFIERLOOSE", "\\d+"); | ||
| createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`); | ||
| createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`); | ||
| createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`); | ||
| createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NUMERICIDENTIFIER]}|${src[t2.NONNUMERICIDENTIFIER]})`); | ||
| createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NUMERICIDENTIFIERLOOSE]}|${src[t2.NONNUMERICIDENTIFIER]})`); | ||
| createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`); | ||
| createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`); | ||
| createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`); | ||
| createToken("BUILD", `(?:\\+(${src[t2.BUILDIDENTIFIER]}(?:\\.${src[t2.BUILDIDENTIFIER]})*))`); | ||
| createToken("FULLPLAIN", `v?${src[t2.MAINVERSION]}${src[t2.PRERELEASE]}?${src[t2.BUILD]}?`); | ||
| createToken("FULL", `^${src[t2.FULLPLAIN]}$`); | ||
| createToken("LOOSEPLAIN", `[v=\\s]*${src[t2.MAINVERSIONLOOSE]}${src[t2.PRERELEASELOOSE]}?${src[t2.BUILD]}?`); | ||
| createToken("LOOSE", `^${src[t2.LOOSEPLAIN]}$`); | ||
| createToken("GTLT", "((?:<|>)?=?)"); | ||
| createToken("XRANGEIDENTIFIERLOOSE", `${src[t2.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`); | ||
| createToken("XRANGEIDENTIFIER", `${src[t2.NUMERICIDENTIFIER]}|x|X|\\*`); | ||
| createToken("XRANGEPLAIN", `[v=\\s]*(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:\\.(${src[t2.XRANGEIDENTIFIER]})(?:${src[t2.PRERELEASE]})?${src[t2.BUILD]}?)?)?`); | ||
| createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`); | ||
| createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`); | ||
| createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`); | ||
| createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?`); | ||
| createToken("COERCE", `${src[t2.COERCEPLAIN]}(?:$|[^\\d])`); | ||
| createToken("COERCEFULL", src[t2.COERCEPLAIN] + `(?:${src[t2.PRERELEASE]})?(?:${src[t2.BUILD]})?(?:$|[^\\d])`); | ||
| createToken("COERCERTL", src[t2.COERCE], true); | ||
| createToken("COERCERTLFULL", src[t2.COERCEFULL], true); | ||
| createToken("LONETILDE", "(?:~>?)"); | ||
| createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true); | ||
| exports.tildeTrimReplace = "$1~"; | ||
| createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`); | ||
| createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`); | ||
| createToken("LONECARET", "(?:\\^)"); | ||
| createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true); | ||
| exports.caretTrimReplace = "$1^"; | ||
| createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`); | ||
| createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`); | ||
| createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`); | ||
| createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`); | ||
| createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true); | ||
| exports.comparatorTrimReplace = "$1$2$3"; | ||
| createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`); | ||
| createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`); | ||
| createToken("STAR", "(<|>)?=?\\s*\\*"); | ||
| createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"); | ||
| createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$"); | ||
| })(re$2, re$2.exports); | ||
| var reExports = re$2.exports; | ||
| const looseOption = Object.freeze({ loose: true }); | ||
| const emptyOpts = Object.freeze({}); | ||
| const parseOptions$1 = (options) => { | ||
| if (!options) { | ||
| return emptyOpts; | ||
| } | ||
| if (typeof options !== "object") { | ||
| return looseOption; | ||
| } | ||
| return options; | ||
| }; | ||
| var parseOptions_1 = parseOptions$1; | ||
| const numeric = /^[0-9]+$/; | ||
| const compareIdentifiers$1 = (a, b) => { | ||
| const anum = numeric.test(a); | ||
| const bnum = numeric.test(b); | ||
| if (anum && bnum) { | ||
| a = +a; | ||
| b = +b; | ||
| } | ||
| return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1; | ||
| }; | ||
| const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a); | ||
| var identifiers$1 = { | ||
| compareIdentifiers: compareIdentifiers$1, | ||
| rcompareIdentifiers | ||
| }; | ||
| const debug = debug_1; | ||
| const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants$1; | ||
| const { safeRe: re$1, t: t$1 } = reExports; | ||
| const parseOptions = parseOptions_1; | ||
| const { compareIdentifiers } = identifiers$1; | ||
| let SemVer$d = class SemVer { | ||
| constructor(version, options) { | ||
| options = parseOptions(options); | ||
| if (version instanceof SemVer) { | ||
| if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) { | ||
| return version; | ||
| } else { | ||
| version = version.version; | ||
| } | ||
| } else if (typeof version !== "string") { | ||
| throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`); | ||
| } | ||
| if (version.length > MAX_LENGTH) { | ||
| throw new TypeError( | ||
| `version is longer than ${MAX_LENGTH} characters` | ||
| ); | ||
| } | ||
| debug("SemVer", version, options); | ||
| this.options = options; | ||
| this.loose = !!options.loose; | ||
| this.includePrerelease = !!options.includePrerelease; | ||
| const m = version.trim().match(options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL]); | ||
| if (!m) { | ||
| throw new TypeError(`Invalid Version: ${version}`); | ||
| } | ||
| this.raw = version; | ||
| this.major = +m[1]; | ||
| this.minor = +m[2]; | ||
| this.patch = +m[3]; | ||
| if (this.major > MAX_SAFE_INTEGER || this.major < 0) { | ||
| throw new TypeError("Invalid major version"); | ||
| } | ||
| if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { | ||
| throw new TypeError("Invalid minor version"); | ||
| } | ||
| if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { | ||
| throw new TypeError("Invalid patch version"); | ||
| } | ||
| if (!m[4]) { | ||
| this.prerelease = []; | ||
| } else { | ||
| this.prerelease = m[4].split(".").map((id) => { | ||
| if (/^[0-9]+$/.test(id)) { | ||
| const num = +id; | ||
| if (num >= 0 && num < MAX_SAFE_INTEGER) { | ||
| return num; | ||
| } | ||
| } | ||
| return id; | ||
| }); | ||
| } | ||
| this.build = m[5] ? m[5].split(".") : []; | ||
| this.format(); | ||
| } | ||
| format() { | ||
| this.version = `${this.major}.${this.minor}.${this.patch}`; | ||
| if (this.prerelease.length) { | ||
| this.version += `-${this.prerelease.join(".")}`; | ||
| } | ||
| return this.version; | ||
| } | ||
| toString() { | ||
| return this.version; | ||
| } | ||
| compare(other) { | ||
| debug("SemVer.compare", this.version, this.options, other); | ||
| if (!(other instanceof SemVer)) { | ||
| if (typeof other === "string" && other === this.version) { | ||
| return 0; | ||
| } | ||
| other = new SemVer(other, this.options); | ||
| } | ||
| if (other.version === this.version) { | ||
| return 0; | ||
| } | ||
| return this.compareMain(other) || this.comparePre(other); | ||
| } | ||
| compareMain(other) { | ||
| if (!(other instanceof SemVer)) { | ||
| other = new SemVer(other, this.options); | ||
| } | ||
| return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch); | ||
| } | ||
| comparePre(other) { | ||
| if (!(other instanceof SemVer)) { | ||
| other = new SemVer(other, this.options); | ||
| } | ||
| if (this.prerelease.length && !other.prerelease.length) { | ||
| return -1; | ||
| } else if (!this.prerelease.length && other.prerelease.length) { | ||
| return 1; | ||
| } else if (!this.prerelease.length && !other.prerelease.length) { | ||
| return 0; | ||
| } | ||
| let i = 0; | ||
| do { | ||
| const a = this.prerelease[i]; | ||
| const b = other.prerelease[i]; | ||
| debug("prerelease compare", i, a, b); | ||
| if (a === void 0 && b === void 0) { | ||
| return 0; | ||
| } else if (b === void 0) { | ||
| return 1; | ||
| } else if (a === void 0) { | ||
| return -1; | ||
| } else if (a === b) { | ||
| continue; | ||
| } else { | ||
| return compareIdentifiers(a, b); | ||
| } | ||
| } while (++i); | ||
| } | ||
| compareBuild(other) { | ||
| if (!(other instanceof SemVer)) { | ||
| other = new SemVer(other, this.options); | ||
| } | ||
| let i = 0; | ||
| do { | ||
| const a = this.build[i]; | ||
| const b = other.build[i]; | ||
| debug("build compare", i, a, b); | ||
| if (a === void 0 && b === void 0) { | ||
| return 0; | ||
| } else if (b === void 0) { | ||
| return 1; | ||
| } else if (a === void 0) { | ||
| return -1; | ||
| } else if (a === b) { | ||
| continue; | ||
| } else { | ||
| return compareIdentifiers(a, b); | ||
| } | ||
| } while (++i); | ||
| } | ||
| // preminor will bump the version up to the next minor release, and immediately | ||
| // down to pre-release. premajor and prepatch work the same way. | ||
| inc(release, identifier, identifierBase) { | ||
| switch (release) { | ||
| case "premajor": | ||
| this.prerelease.length = 0; | ||
| this.patch = 0; | ||
| this.minor = 0; | ||
| this.major++; | ||
| this.inc("pre", identifier, identifierBase); | ||
| break; | ||
| case "preminor": | ||
| this.prerelease.length = 0; | ||
| this.patch = 0; | ||
| this.minor++; | ||
| this.inc("pre", identifier, identifierBase); | ||
| break; | ||
| case "prepatch": | ||
| this.prerelease.length = 0; | ||
| this.inc("patch", identifier, identifierBase); | ||
| this.inc("pre", identifier, identifierBase); | ||
| break; | ||
| case "prerelease": | ||
| if (this.prerelease.length === 0) { | ||
| this.inc("patch", identifier, identifierBase); | ||
| } | ||
| this.inc("pre", identifier, identifierBase); | ||
| break; | ||
| case "major": | ||
| if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) { | ||
| this.major++; | ||
| } | ||
| this.minor = 0; | ||
| this.patch = 0; | ||
| this.prerelease = []; | ||
| break; | ||
| case "minor": | ||
| if (this.patch !== 0 || this.prerelease.length === 0) { | ||
| this.minor++; | ||
| } | ||
| this.patch = 0; | ||
| this.prerelease = []; | ||
| break; | ||
| case "patch": | ||
| if (this.prerelease.length === 0) { | ||
| this.patch++; | ||
| } | ||
| this.prerelease = []; | ||
| break; | ||
| case "pre": { | ||
| const base = Number(identifierBase) ? 1 : 0; | ||
| if (!identifier && identifierBase === false) { | ||
| throw new Error("invalid increment argument: identifier is empty"); | ||
| } | ||
| if (this.prerelease.length === 0) { | ||
| this.prerelease = [base]; | ||
| } else { | ||
| let i = this.prerelease.length; | ||
| while (--i >= 0) { | ||
| if (typeof this.prerelease[i] === "number") { | ||
| this.prerelease[i]++; | ||
| i = -2; | ||
| } | ||
| } | ||
| if (i === -1) { | ||
| if (identifier === this.prerelease.join(".") && identifierBase === false) { | ||
| throw new Error("invalid increment argument: identifier already exists"); | ||
| } | ||
| this.prerelease.push(base); | ||
| } | ||
| } | ||
| if (identifier) { | ||
| let prerelease2 = [identifier, base]; | ||
| if (identifierBase === false) { | ||
| prerelease2 = [identifier]; | ||
| } | ||
| if (compareIdentifiers(this.prerelease[0], identifier) === 0) { | ||
| if (isNaN(this.prerelease[1])) { | ||
| this.prerelease = prerelease2; | ||
| } | ||
| } else { | ||
| this.prerelease = prerelease2; | ||
| } | ||
| } | ||
| break; | ||
| } | ||
| default: | ||
| throw new Error(`invalid increment argument: ${release}`); | ||
| } | ||
| this.raw = this.format(); | ||
| if (this.build.length) { | ||
| this.raw += `+${this.build.join(".")}`; | ||
| } | ||
| return this; | ||
| } | ||
| }; | ||
| var semver$2 = SemVer$d; | ||
| const SemVer$c = semver$2; | ||
| const parse$6 = (version, options, throwErrors = false) => { | ||
| if (version instanceof SemVer$c) { | ||
| return version; | ||
| } | ||
| try { | ||
| return new SemVer$c(version, options); | ||
| } catch (er) { | ||
| if (!throwErrors) { | ||
| return null; | ||
| } | ||
| throw er; | ||
| } | ||
| }; | ||
| var parse_1 = parse$6; | ||
| const parse$5 = parse_1; | ||
| const valid$2 = (version, options) => { | ||
| const v = parse$5(version, options); | ||
| return v ? v.version : null; | ||
| }; | ||
| var valid_1 = valid$2; | ||
| const parse$4 = parse_1; | ||
| const clean$1 = (version, options) => { | ||
| const s = parse$4(version.trim().replace(/^[=v]+/, ""), options); | ||
| return s ? s.version : null; | ||
| }; | ||
| var clean_1 = clean$1; | ||
| const SemVer$b = semver$2; | ||
| const inc$1 = (version, release, options, identifier, identifierBase) => { | ||
| if (typeof options === "string") { | ||
| identifierBase = identifier; | ||
| identifier = options; | ||
| options = void 0; | ||
| } | ||
| try { | ||
| return new SemVer$b( | ||
| version instanceof SemVer$b ? version.version : version, | ||
| options | ||
| ).inc(release, identifier, identifierBase).version; | ||
| } catch (er) { | ||
| return null; | ||
| } | ||
| }; | ||
| var inc_1 = inc$1; | ||
| const parse$3 = parse_1; | ||
| const diff$1 = (version1, version2) => { | ||
| const v1 = parse$3(version1, null, true); | ||
| const v2 = parse$3(version2, null, true); | ||
| const comparison = v1.compare(v2); | ||
| if (comparison === 0) { | ||
| return null; | ||
| } | ||
| const v1Higher = comparison > 0; | ||
| const highVersion = v1Higher ? v1 : v2; | ||
| const lowVersion = v1Higher ? v2 : v1; | ||
| const highHasPre = !!highVersion.prerelease.length; | ||
| const lowHasPre = !!lowVersion.prerelease.length; | ||
| if (lowHasPre && !highHasPre) { | ||
| if (!lowVersion.patch && !lowVersion.minor) { | ||
| return "major"; | ||
| } | ||
| if (highVersion.patch) { | ||
| return "patch"; | ||
| } | ||
| if (highVersion.minor) { | ||
| return "minor"; | ||
| } | ||
| return "major"; | ||
| } | ||
| const prefix = highHasPre ? "pre" : ""; | ||
| if (v1.major !== v2.major) { | ||
| return prefix + "major"; | ||
| } | ||
| if (v1.minor !== v2.minor) { | ||
| return prefix + "minor"; | ||
| } | ||
| if (v1.patch !== v2.patch) { | ||
| return prefix + "patch"; | ||
| } | ||
| return "prerelease"; | ||
| }; | ||
| var diff_1 = diff$1; | ||
| const SemVer$a = semver$2; | ||
| const major$1 = (a, loose) => new SemVer$a(a, loose).major; | ||
| var major_1 = major$1; | ||
| const SemVer$9 = semver$2; | ||
| const minor$1 = (a, loose) => new SemVer$9(a, loose).minor; | ||
| var minor_1 = minor$1; | ||
| const SemVer$8 = semver$2; | ||
| const patch$1 = (a, loose) => new SemVer$8(a, loose).patch; | ||
| var patch_1 = patch$1; | ||
| const parse$2 = parse_1; | ||
| const prerelease$1 = (version, options) => { | ||
| const parsed = parse$2(version, options); | ||
| return parsed && parsed.prerelease.length ? parsed.prerelease : null; | ||
| }; | ||
| var prerelease_1 = prerelease$1; | ||
| const SemVer$7 = semver$2; | ||
| const compare$b = (a, b, loose) => new SemVer$7(a, loose).compare(new SemVer$7(b, loose)); | ||
| var compare_1 = compare$b; | ||
| const compare$a = compare_1; | ||
| const rcompare$1 = (a, b, loose) => compare$a(b, a, loose); | ||
| var rcompare_1 = rcompare$1; | ||
| const compare$9 = compare_1; | ||
| const compareLoose$1 = (a, b) => compare$9(a, b, true); | ||
| var compareLoose_1 = compareLoose$1; | ||
| const SemVer$6 = semver$2; | ||
| const compareBuild$3 = (a, b, loose) => { | ||
| const versionA = new SemVer$6(a, loose); | ||
| const versionB = new SemVer$6(b, loose); | ||
| return versionA.compare(versionB) || versionA.compareBuild(versionB); | ||
| }; | ||
| var compareBuild_1 = compareBuild$3; | ||
| const compareBuild$2 = compareBuild_1; | ||
| const sort$1 = (list, loose) => list.sort((a, b) => compareBuild$2(a, b, loose)); | ||
| var sort_1 = sort$1; | ||
| const compareBuild$1 = compareBuild_1; | ||
| const rsort$1 = (list, loose) => list.sort((a, b) => compareBuild$1(b, a, loose)); | ||
| var rsort_1 = rsort$1; | ||
| const compare$8 = compare_1; | ||
| const gt$4 = (a, b, loose) => compare$8(a, b, loose) > 0; | ||
| var gt_1 = gt$4; | ||
| const compare$7 = compare_1; | ||
| const lt$3 = (a, b, loose) => compare$7(a, b, loose) < 0; | ||
| var lt_1 = lt$3; | ||
| const compare$6 = compare_1; | ||
| const eq$2 = (a, b, loose) => compare$6(a, b, loose) === 0; | ||
| var eq_1 = eq$2; | ||
| const compare$5 = compare_1; | ||
| const neq$2 = (a, b, loose) => compare$5(a, b, loose) !== 0; | ||
| var neq_1 = neq$2; | ||
| const compare$4 = compare_1; | ||
| const gte$3 = (a, b, loose) => compare$4(a, b, loose) >= 0; | ||
| var gte_1 = gte$3; | ||
| const compare$3 = compare_1; | ||
| const lte$3 = (a, b, loose) => compare$3(a, b, loose) <= 0; | ||
| var lte_1 = lte$3; | ||
| const eq$1 = eq_1; | ||
| const neq$1 = neq_1; | ||
| const gt$3 = gt_1; | ||
| const gte$2 = gte_1; | ||
| const lt$2 = lt_1; | ||
| const lte$2 = lte_1; | ||
| const cmp$1 = (a, op, b, loose) => { | ||
| switch (op) { | ||
| case "===": | ||
| if (typeof a === "object") { | ||
| a = a.version; | ||
| } | ||
| if (typeof b === "object") { | ||
| b = b.version; | ||
| } | ||
| return a === b; | ||
| case "!==": | ||
| if (typeof a === "object") { | ||
| a = a.version; | ||
| } | ||
| if (typeof b === "object") { | ||
| b = b.version; | ||
| } | ||
| return a !== b; | ||
| case "": | ||
| case "=": | ||
| case "==": | ||
| return eq$1(a, b, loose); | ||
| case "!=": | ||
| return neq$1(a, b, loose); | ||
| case ">": | ||
| return gt$3(a, b, loose); | ||
| case ">=": | ||
| return gte$2(a, b, loose); | ||
| case "<": | ||
| return lt$2(a, b, loose); | ||
| case "<=": | ||
| return lte$2(a, b, loose); | ||
| default: | ||
| throw new TypeError(`Invalid operator: ${op}`); | ||
| } | ||
| }; | ||
| var cmp_1 = cmp$1; | ||
| const SemVer$5 = semver$2; | ||
| const parse$1 = parse_1; | ||
| const { safeRe: re, t } = reExports; | ||
| const coerce$1 = (version, options) => { | ||
| if (version instanceof SemVer$5) { | ||
| return version; | ||
| } | ||
| if (typeof version === "number") { | ||
| version = String(version); | ||
| } | ||
| if (typeof version !== "string") { | ||
| return null; | ||
| } | ||
| options = options || {}; | ||
| let match = null; | ||
| if (!options.rtl) { | ||
| match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]); | ||
| } else { | ||
| const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]; | ||
| let next; | ||
| while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) { | ||
| if (!match || next.index + next[0].length !== match.index + match[0].length) { | ||
| match = next; | ||
| } | ||
| coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length; | ||
| } | ||
| coerceRtlRegex.lastIndex = -1; | ||
| } | ||
| if (match === null) { | ||
| return null; | ||
| } | ||
| const major2 = match[2]; | ||
| const minor2 = match[3] || "0"; | ||
| const patch2 = match[4] || "0"; | ||
| const prerelease2 = options.includePrerelease && match[5] ? `-${match[5]}` : ""; | ||
| const build = options.includePrerelease && match[6] ? `+${match[6]}` : ""; | ||
| return parse$1(`${major2}.${minor2}.${patch2}${prerelease2}${build}`, options); | ||
| }; | ||
| var coerce_1 = coerce$1; | ||
| class LRUCache { | ||
| constructor() { | ||
| this.max = 1e3; | ||
| this.map = /* @__PURE__ */ new Map(); | ||
| } | ||
| get(key) { | ||
| const value = this.map.get(key); | ||
| if (value === void 0) { | ||
| return void 0; | ||
| } else { | ||
| this.map.delete(key); | ||
| this.map.set(key, value); | ||
| return value; | ||
| } | ||
| } | ||
| delete(key) { | ||
| return this.map.delete(key); | ||
| } | ||
| set(key, value) { | ||
| const deleted = this.delete(key); | ||
| if (!deleted && value !== void 0) { | ||
| if (this.map.size >= this.max) { | ||
| const firstKey = this.map.keys().next().value; | ||
| this.delete(firstKey); | ||
| } | ||
| this.map.set(key, value); | ||
| } | ||
| return this; | ||
| } | ||
| } | ||
| var lrucache = LRUCache; | ||
| var range; | ||
| var hasRequiredRange; | ||
| function requireRange() { | ||
| if (hasRequiredRange) | ||
| return range; | ||
| hasRequiredRange = 1; | ||
| const SPACE_CHARACTERS = /\s+/g; | ||
| class Range2 { | ||
| constructor(range2, options) { | ||
| options = parseOptions2(options); | ||
| if (range2 instanceof Range2) { | ||
| if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) { | ||
| return range2; | ||
| } else { | ||
| return new Range2(range2.raw, options); | ||
| } | ||
| } | ||
| if (range2 instanceof Comparator2) { | ||
| this.raw = range2.value; | ||
| this.set = [[range2]]; | ||
| this.formatted = void 0; | ||
| return this; | ||
| } | ||
| this.options = options; | ||
| this.loose = !!options.loose; | ||
| this.includePrerelease = !!options.includePrerelease; | ||
| this.raw = range2.trim().replace(SPACE_CHARACTERS, " "); | ||
| this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length); | ||
| if (!this.set.length) { | ||
| throw new TypeError(`Invalid SemVer Range: ${this.raw}`); | ||
| } | ||
| if (this.set.length > 1) { | ||
| const first = this.set[0]; | ||
| this.set = this.set.filter((c) => !isNullSet(c[0])); | ||
| if (this.set.length === 0) { | ||
| this.set = [first]; | ||
| } else if (this.set.length > 1) { | ||
| for (const c of this.set) { | ||
| if (c.length === 1 && isAny(c[0])) { | ||
| this.set = [c]; | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| this.formatted = void 0; | ||
| } | ||
| get range() { | ||
| if (this.formatted === void 0) { | ||
| this.formatted = ""; | ||
| for (let i = 0; i < this.set.length; i++) { | ||
| if (i > 0) { | ||
| this.formatted += "||"; | ||
| } | ||
| const comps = this.set[i]; | ||
| for (let k = 0; k < comps.length; k++) { | ||
| if (k > 0) { | ||
| this.formatted += " "; | ||
| } | ||
| this.formatted += comps[k].toString().trim(); | ||
| } | ||
| } | ||
| } | ||
| return this.formatted; | ||
| } | ||
| format() { | ||
| return this.range; | ||
| } | ||
| toString() { | ||
| return this.range; | ||
| } | ||
| parseRange(range2) { | ||
| const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE); | ||
| const memoKey = memoOpts + ":" + range2; | ||
| const cached = cache.get(memoKey); | ||
| if (cached) { | ||
| return cached; | ||
| } | ||
| const loose = this.options.loose; | ||
| const hr = loose ? re2[t2.HYPHENRANGELOOSE] : re2[t2.HYPHENRANGE]; | ||
| range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease)); | ||
| debug2("hyphen replace", range2); | ||
| range2 = range2.replace(re2[t2.COMPARATORTRIM], comparatorTrimReplace); | ||
| debug2("comparator trim", range2); | ||
| range2 = range2.replace(re2[t2.TILDETRIM], tildeTrimReplace); | ||
| debug2("tilde trim", range2); | ||
| range2 = range2.replace(re2[t2.CARETTRIM], caretTrimReplace); | ||
| debug2("caret trim", range2); | ||
| let rangeList = range2.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options)); | ||
| if (loose) { | ||
| rangeList = rangeList.filter((comp) => { | ||
| debug2("loose invalid filter", comp, this.options); | ||
| return !!comp.match(re2[t2.COMPARATORLOOSE]); | ||
| }); | ||
| } | ||
| debug2("range list", rangeList); | ||
| const rangeMap = /* @__PURE__ */ new Map(); | ||
| const comparators = rangeList.map((comp) => new Comparator2(comp, this.options)); | ||
| for (const comp of comparators) { | ||
| if (isNullSet(comp)) { | ||
| return [comp]; | ||
| } | ||
| rangeMap.set(comp.value, comp); | ||
| } | ||
| if (rangeMap.size > 1 && rangeMap.has("")) { | ||
| rangeMap.delete(""); | ||
| } | ||
| const result = [...rangeMap.values()]; | ||
| cache.set(memoKey, result); | ||
| return result; | ||
| } | ||
| intersects(range2, options) { | ||
| if (!(range2 instanceof Range2)) { | ||
| throw new TypeError("a Range is required"); | ||
| } | ||
| return this.set.some((thisComparators) => { | ||
| return isSatisfiable(thisComparators, options) && range2.set.some((rangeComparators) => { | ||
| return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => { | ||
| return rangeComparators.every((rangeComparator) => { | ||
| return thisComparator.intersects(rangeComparator, options); | ||
| }); | ||
| }); | ||
| }); | ||
| }); | ||
| } | ||
| // if ANY of the sets match ALL of its comparators, then pass | ||
| test(version) { | ||
| if (!version) { | ||
| return false; | ||
| } | ||
| if (typeof version === "string") { | ||
| try { | ||
| version = new SemVer3(version, this.options); | ||
| } catch (er) { | ||
| return false; | ||
| } | ||
| } | ||
| for (let i = 0; i < this.set.length; i++) { | ||
| if (testSet(this.set[i], version, this.options)) { | ||
| return true; | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| range = Range2; | ||
| const LRU = lrucache; | ||
| const cache = new LRU(); | ||
| const parseOptions2 = parseOptions_1; | ||
| const Comparator2 = requireComparator(); | ||
| const debug2 = debug_1; | ||
| const SemVer3 = semver$2; | ||
| const { | ||
| safeRe: re2, | ||
| t: t2, | ||
| comparatorTrimReplace, | ||
| tildeTrimReplace, | ||
| caretTrimReplace | ||
| } = reExports; | ||
| const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = constants$1; | ||
| const isNullSet = (c) => c.value === "<0.0.0-0"; | ||
| const isAny = (c) => c.value === ""; | ||
| const isSatisfiable = (comparators, options) => { | ||
| let result = true; | ||
| const remainingComparators = comparators.slice(); | ||
| let testComparator = remainingComparators.pop(); | ||
| while (result && remainingComparators.length) { | ||
| result = remainingComparators.every((otherComparator) => { | ||
| return testComparator.intersects(otherComparator, options); | ||
| }); | ||
| testComparator = remainingComparators.pop(); | ||
| } | ||
| return result; | ||
| }; | ||
| const parseComparator = (comp, options) => { | ||
| debug2("comp", comp, options); | ||
| comp = replaceCarets(comp, options); | ||
| debug2("caret", comp); | ||
| comp = replaceTildes(comp, options); | ||
| debug2("tildes", comp); | ||
| comp = replaceXRanges(comp, options); | ||
| debug2("xrange", comp); | ||
| comp = replaceStars(comp, options); | ||
| debug2("stars", comp); | ||
| return comp; | ||
| }; | ||
| const isX = (id) => !id || id.toLowerCase() === "x" || id === "*"; | ||
| const replaceTildes = (comp, options) => { | ||
| return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" "); | ||
| }; | ||
| const replaceTilde = (comp, options) => { | ||
| const r = options.loose ? re2[t2.TILDELOOSE] : re2[t2.TILDE]; | ||
| return comp.replace(r, (_, M, m, p, pr) => { | ||
| debug2("tilde", comp, _, M, m, p, pr); | ||
| let ret; | ||
| if (isX(M)) { | ||
| ret = ""; | ||
| } else if (isX(m)) { | ||
| ret = `>=${M}.0.0 <${+M + 1}.0.0-0`; | ||
| } else if (isX(p)) { | ||
| ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`; | ||
| } else if (pr) { | ||
| debug2("replaceTilde pr", pr); | ||
| ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; | ||
| } else { | ||
| ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`; | ||
| } | ||
| debug2("tilde return", ret); | ||
| return ret; | ||
| }); | ||
| }; | ||
| const replaceCarets = (comp, options) => { | ||
| return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" "); | ||
| }; | ||
| const replaceCaret = (comp, options) => { | ||
| debug2("caret", comp, options); | ||
| const r = options.loose ? re2[t2.CARETLOOSE] : re2[t2.CARET]; | ||
| const z = options.includePrerelease ? "-0" : ""; | ||
| return comp.replace(r, (_, M, m, p, pr) => { | ||
| debug2("caret", comp, _, M, m, p, pr); | ||
| let ret; | ||
| if (isX(M)) { | ||
| ret = ""; | ||
| } else if (isX(m)) { | ||
| ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`; | ||
| } else if (isX(p)) { | ||
| if (M === "0") { | ||
| ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`; | ||
| } else { | ||
| ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`; | ||
| } | ||
| } else if (pr) { | ||
| debug2("replaceCaret pr", pr); | ||
| if (M === "0") { | ||
| if (m === "0") { | ||
| ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`; | ||
| } else { | ||
| ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`; | ||
| } | ||
| } else { | ||
| ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`; | ||
| } | ||
| } else { | ||
| debug2("no pr"); | ||
| if (M === "0") { | ||
| if (m === "0") { | ||
| ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`; | ||
| } else { | ||
| ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`; | ||
| } | ||
| } else { | ||
| ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`; | ||
| } | ||
| } | ||
| debug2("caret return", ret); | ||
| return ret; | ||
| }); | ||
| }; | ||
| const replaceXRanges = (comp, options) => { | ||
| debug2("replaceXRanges", comp, options); | ||
| return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" "); | ||
| }; | ||
| const replaceXRange = (comp, options) => { | ||
| comp = comp.trim(); | ||
| const r = options.loose ? re2[t2.XRANGELOOSE] : re2[t2.XRANGE]; | ||
| return comp.replace(r, (ret, gtlt, M, m, p, pr) => { | ||
| debug2("xRange", comp, ret, gtlt, M, m, p, pr); | ||
| const xM = isX(M); | ||
| const xm = xM || isX(m); | ||
| const xp = xm || isX(p); | ||
| const anyX = xp; | ||
| if (gtlt === "=" && anyX) { | ||
| gtlt = ""; | ||
| } | ||
| pr = options.includePrerelease ? "-0" : ""; | ||
| if (xM) { | ||
| if (gtlt === ">" || gtlt === "<") { | ||
| ret = "<0.0.0-0"; | ||
| } else { | ||
| ret = "*"; | ||
| } | ||
| } else if (gtlt && anyX) { | ||
| if (xm) { | ||
| m = 0; | ||
| } | ||
| p = 0; | ||
| if (gtlt === ">") { | ||
| gtlt = ">="; | ||
| if (xm) { | ||
| M = +M + 1; | ||
| m = 0; | ||
| p = 0; | ||
| } else { | ||
| m = +m + 1; | ||
| p = 0; | ||
| } | ||
| } else if (gtlt === "<=") { | ||
| gtlt = "<"; | ||
| if (xm) { | ||
| M = +M + 1; | ||
| } else { | ||
| m = +m + 1; | ||
| } | ||
| } | ||
| if (gtlt === "<") { | ||
| pr = "-0"; | ||
| } | ||
| ret = `${gtlt + M}.${m}.${p}${pr}`; | ||
| } else if (xm) { | ||
| ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`; | ||
| } else if (xp) { | ||
| ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`; | ||
| } | ||
| debug2("xRange return", ret); | ||
| return ret; | ||
| }); | ||
| }; | ||
| const replaceStars = (comp, options) => { | ||
| debug2("replaceStars", comp, options); | ||
| return comp.trim().replace(re2[t2.STAR], ""); | ||
| }; | ||
| const replaceGTE0 = (comp, options) => { | ||
| debug2("replaceGTE0", comp, options); | ||
| return comp.trim().replace(re2[options.includePrerelease ? t2.GTE0PRE : t2.GTE0], ""); | ||
| }; | ||
| const hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => { | ||
| if (isX(fM)) { | ||
| from = ""; | ||
| } else if (isX(fm)) { | ||
| from = `>=${fM}.0.0${incPr ? "-0" : ""}`; | ||
| } else if (isX(fp)) { | ||
| from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`; | ||
| } else if (fpr) { | ||
| from = `>=${from}`; | ||
| } else { | ||
| from = `>=${from}${incPr ? "-0" : ""}`; | ||
| } | ||
| if (isX(tM)) { | ||
| to = ""; | ||
| } else if (isX(tm)) { | ||
| to = `<${+tM + 1}.0.0-0`; | ||
| } else if (isX(tp)) { | ||
| to = `<${tM}.${+tm + 1}.0-0`; | ||
| } else if (tpr) { | ||
| to = `<=${tM}.${tm}.${tp}-${tpr}`; | ||
| } else if (incPr) { | ||
| to = `<${tM}.${tm}.${+tp + 1}-0`; | ||
| } else { | ||
| to = `<=${to}`; | ||
| } | ||
| return `${from} ${to}`.trim(); | ||
| }; | ||
| const testSet = (set, version, options) => { | ||
| for (let i = 0; i < set.length; i++) { | ||
| if (!set[i].test(version)) { | ||
| return false; | ||
| } | ||
| } | ||
| if (version.prerelease.length && !options.includePrerelease) { | ||
| for (let i = 0; i < set.length; i++) { | ||
| debug2(set[i].semver); | ||
| if (set[i].semver === Comparator2.ANY) { | ||
| continue; | ||
| } | ||
| if (set[i].semver.prerelease.length > 0) { | ||
| const allowed = set[i].semver; | ||
| if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) { | ||
| return true; | ||
| } | ||
| } | ||
| } | ||
| return false; | ||
| } | ||
| return true; | ||
| }; | ||
| return range; | ||
| } | ||
| var comparator; | ||
| var hasRequiredComparator; | ||
| function requireComparator() { | ||
| if (hasRequiredComparator) | ||
| return comparator; | ||
| hasRequiredComparator = 1; | ||
| const ANY2 = Symbol("SemVer ANY"); | ||
| class Comparator2 { | ||
| static get ANY() { | ||
| return ANY2; | ||
| } | ||
| constructor(comp, options) { | ||
| options = parseOptions2(options); | ||
| if (comp instanceof Comparator2) { | ||
| if (comp.loose === !!options.loose) { | ||
| return comp; | ||
| } else { | ||
| comp = comp.value; | ||
| } | ||
| } | ||
| comp = comp.trim().split(/\s+/).join(" "); | ||
| debug2("comparator", comp, options); | ||
| this.options = options; | ||
| this.loose = !!options.loose; | ||
| this.parse(comp); | ||
| if (this.semver === ANY2) { | ||
| this.value = ""; | ||
| } else { | ||
| this.value = this.operator + this.semver.version; | ||
| } | ||
| debug2("comp", this); | ||
| } | ||
| parse(comp) { | ||
| const r = this.options.loose ? re2[t2.COMPARATORLOOSE] : re2[t2.COMPARATOR]; | ||
| const m = comp.match(r); | ||
| if (!m) { | ||
| throw new TypeError(`Invalid comparator: ${comp}`); | ||
| } | ||
| this.operator = m[1] !== void 0 ? m[1] : ""; | ||
| if (this.operator === "=") { | ||
| this.operator = ""; | ||
| } | ||
| if (!m[2]) { | ||
| this.semver = ANY2; | ||
| } else { | ||
| this.semver = new SemVer3(m[2], this.options.loose); | ||
| } | ||
| } | ||
| toString() { | ||
| return this.value; | ||
| } | ||
| test(version) { | ||
| debug2("Comparator.test", version, this.options.loose); | ||
| if (this.semver === ANY2 || version === ANY2) { | ||
| return true; | ||
| } | ||
| if (typeof version === "string") { | ||
| try { | ||
| version = new SemVer3(version, this.options); | ||
| } catch (er) { | ||
| return false; | ||
| } | ||
| } | ||
| return cmp2(version, this.operator, this.semver, this.options); | ||
| } | ||
| intersects(comp, options) { | ||
| if (!(comp instanceof Comparator2)) { | ||
| throw new TypeError("a Comparator is required"); | ||
| } | ||
| if (this.operator === "") { | ||
| if (this.value === "") { | ||
| return true; | ||
| } | ||
| return new Range2(comp.value, options).test(this.value); | ||
| } else if (comp.operator === "") { | ||
| if (comp.value === "") { | ||
| return true; | ||
| } | ||
| return new Range2(this.value, options).test(comp.semver); | ||
| } | ||
| options = parseOptions2(options); | ||
| if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) { | ||
| return false; | ||
| } | ||
| if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) { | ||
| return false; | ||
| } | ||
| if (this.operator.startsWith(">") && comp.operator.startsWith(">")) { | ||
| return true; | ||
| } | ||
| if (this.operator.startsWith("<") && comp.operator.startsWith("<")) { | ||
| return true; | ||
| } | ||
| if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) { | ||
| return true; | ||
| } | ||
| if (cmp2(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) { | ||
| return true; | ||
| } | ||
| if (cmp2(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) { | ||
| return true; | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| comparator = Comparator2; | ||
| const parseOptions2 = parseOptions_1; | ||
| const { safeRe: re2, t: t2 } = reExports; | ||
| const cmp2 = cmp_1; | ||
| const debug2 = debug_1; | ||
| const SemVer3 = semver$2; | ||
| const Range2 = requireRange(); | ||
| return comparator; | ||
| } | ||
| const Range$9 = requireRange(); | ||
| const satisfies$4 = (version, range2, options) => { | ||
| try { | ||
| range2 = new Range$9(range2, options); | ||
| } catch (er) { | ||
| return false; | ||
| } | ||
| return range2.test(version); | ||
| }; | ||
| var satisfies_1 = satisfies$4; | ||
| const Range$8 = requireRange(); | ||
| const toComparators$1 = (range2, options) => new Range$8(range2, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" ")); | ||
| var toComparators_1 = toComparators$1; | ||
| const SemVer$4 = semver$2; | ||
| const Range$7 = requireRange(); | ||
| const maxSatisfying$1 = (versions, range2, options) => { | ||
| let max = null; | ||
| let maxSV = null; | ||
| let rangeObj = null; | ||
| try { | ||
| rangeObj = new Range$7(range2, options); | ||
| } catch (er) { | ||
| return null; | ||
| } | ||
| versions.forEach((v) => { | ||
| if (rangeObj.test(v)) { | ||
| if (!max || maxSV.compare(v) === -1) { | ||
| max = v; | ||
| maxSV = new SemVer$4(max, options); | ||
| } | ||
| } | ||
| }); | ||
| return max; | ||
| }; | ||
| var maxSatisfying_1 = maxSatisfying$1; | ||
| const SemVer$3 = semver$2; | ||
| const Range$6 = requireRange(); | ||
| const minSatisfying$1 = (versions, range2, options) => { | ||
| let min = null; | ||
| let minSV = null; | ||
| let rangeObj = null; | ||
| try { | ||
| rangeObj = new Range$6(range2, options); | ||
| } catch (er) { | ||
| return null; | ||
| } | ||
| versions.forEach((v) => { | ||
| if (rangeObj.test(v)) { | ||
| if (!min || minSV.compare(v) === 1) { | ||
| min = v; | ||
| minSV = new SemVer$3(min, options); | ||
| } | ||
| } | ||
| }); | ||
| return min; | ||
| }; | ||
| var minSatisfying_1 = minSatisfying$1; | ||
| const SemVer$2 = semver$2; | ||
| const Range$5 = requireRange(); | ||
| const gt$2 = gt_1; | ||
| const minVersion$1 = (range2, loose) => { | ||
| range2 = new Range$5(range2, loose); | ||
| let minver = new SemVer$2("0.0.0"); | ||
| if (range2.test(minver)) { | ||
| return minver; | ||
| } | ||
| minver = new SemVer$2("0.0.0-0"); | ||
| if (range2.test(minver)) { | ||
| return minver; | ||
| } | ||
| minver = null; | ||
| for (let i = 0; i < range2.set.length; ++i) { | ||
| const comparators = range2.set[i]; | ||
| let setMin = null; | ||
| comparators.forEach((comparator2) => { | ||
| const compver = new SemVer$2(comparator2.semver.version); | ||
| switch (comparator2.operator) { | ||
| case ">": | ||
| if (compver.prerelease.length === 0) { | ||
| compver.patch++; | ||
| } else { | ||
| compver.prerelease.push(0); | ||
| } | ||
| compver.raw = compver.format(); | ||
| case "": | ||
| case ">=": | ||
| if (!setMin || gt$2(compver, setMin)) { | ||
| setMin = compver; | ||
| } | ||
| break; | ||
| case "<": | ||
| case "<=": | ||
| break; | ||
| default: | ||
| throw new Error(`Unexpected operation: ${comparator2.operator}`); | ||
| } | ||
| }); | ||
| if (setMin && (!minver || gt$2(minver, setMin))) { | ||
| minver = setMin; | ||
| } | ||
| } | ||
| if (minver && range2.test(minver)) { | ||
| return minver; | ||
| } | ||
| return null; | ||
| }; | ||
| var minVersion_1 = minVersion$1; | ||
| const Range$4 = requireRange(); | ||
| const validRange$1 = (range2, options) => { | ||
| try { | ||
| return new Range$4(range2, options).range || "*"; | ||
| } catch (er) { | ||
| return null; | ||
| } | ||
| }; | ||
| var valid$1 = validRange$1; | ||
| const SemVer$1 = semver$2; | ||
| const Comparator$2 = requireComparator(); | ||
| const { ANY: ANY$1 } = Comparator$2; | ||
| const Range$3 = requireRange(); | ||
| const satisfies$3 = satisfies_1; | ||
| const gt$1 = gt_1; | ||
| const lt$1 = lt_1; | ||
| const lte$1 = lte_1; | ||
| const gte$1 = gte_1; | ||
| const outside$3 = (version, range2, hilo, options) => { | ||
| version = new SemVer$1(version, options); | ||
| range2 = new Range$3(range2, options); | ||
| let gtfn, ltefn, ltfn, comp, ecomp; | ||
| switch (hilo) { | ||
| case ">": | ||
| gtfn = gt$1; | ||
| ltefn = lte$1; | ||
| ltfn = lt$1; | ||
| comp = ">"; | ||
| ecomp = ">="; | ||
| break; | ||
| case "<": | ||
| gtfn = lt$1; | ||
| ltefn = gte$1; | ||
| ltfn = gt$1; | ||
| comp = "<"; | ||
| ecomp = "<="; | ||
| break; | ||
| default: | ||
| throw new TypeError('Must provide a hilo val of "<" or ">"'); | ||
| } | ||
| if (satisfies$3(version, range2, options)) { | ||
| return false; | ||
| } | ||
| for (let i = 0; i < range2.set.length; ++i) { | ||
| const comparators = range2.set[i]; | ||
| let high = null; | ||
| let low = null; | ||
| comparators.forEach((comparator2) => { | ||
| if (comparator2.semver === ANY$1) { | ||
| comparator2 = new Comparator$2(">=0.0.0"); | ||
| } | ||
| high = high || comparator2; | ||
| low = low || comparator2; | ||
| if (gtfn(comparator2.semver, high.semver, options)) { | ||
| high = comparator2; | ||
| } else if (ltfn(comparator2.semver, low.semver, options)) { | ||
| low = comparator2; | ||
| } | ||
| }); | ||
| if (high.operator === comp || high.operator === ecomp) { | ||
| return false; | ||
| } | ||
| if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) { | ||
| return false; | ||
| } else if (low.operator === ecomp && ltfn(version, low.semver)) { | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| }; | ||
| var outside_1 = outside$3; | ||
| const outside$2 = outside_1; | ||
| const gtr$1 = (version, range2, options) => outside$2(version, range2, ">", options); | ||
| var gtr_1 = gtr$1; | ||
| const outside$1 = outside_1; | ||
| const ltr$1 = (version, range2, options) => outside$1(version, range2, "<", options); | ||
| var ltr_1 = ltr$1; | ||
| const Range$2 = requireRange(); | ||
| const intersects$1 = (r1, r2, options) => { | ||
| r1 = new Range$2(r1, options); | ||
| r2 = new Range$2(r2, options); | ||
| return r1.intersects(r2, options); | ||
| }; | ||
| var intersects_1 = intersects$1; | ||
| const satisfies$2 = satisfies_1; | ||
| const compare$2 = compare_1; | ||
| var simplify = (versions, range2, options) => { | ||
| const set = []; | ||
| let first = null; | ||
| let prev = null; | ||
| const v = versions.sort((a, b) => compare$2(a, b, options)); | ||
| for (const version of v) { | ||
| const included = satisfies$2(version, range2, options); | ||
| if (included) { | ||
| prev = version; | ||
| if (!first) { | ||
| first = version; | ||
| } | ||
| } else { | ||
| if (prev) { | ||
| set.push([first, prev]); | ||
| } | ||
| prev = null; | ||
| first = null; | ||
| } | ||
| } | ||
| if (first) { | ||
| set.push([first, null]); | ||
| } | ||
| const ranges = []; | ||
| for (const [min, max] of set) { | ||
| if (min === max) { | ||
| ranges.push(min); | ||
| } else if (!max && min === v[0]) { | ||
| ranges.push("*"); | ||
| } else if (!max) { | ||
| ranges.push(`>=${min}`); | ||
| } else if (min === v[0]) { | ||
| ranges.push(`<=${max}`); | ||
| } else { | ||
| ranges.push(`${min} - ${max}`); | ||
| } | ||
| } | ||
| const simplified = ranges.join(" || "); | ||
| const original = typeof range2.raw === "string" ? range2.raw : String(range2); | ||
| return simplified.length < original.length ? simplified : range2; | ||
| }; | ||
| const Range$1 = requireRange(); | ||
| const Comparator$1 = requireComparator(); | ||
| const { ANY } = Comparator$1; | ||
| const satisfies$1 = satisfies_1; | ||
| const compare$1 = compare_1; | ||
| const subset$1 = (sub, dom, options = {}) => { | ||
| if (sub === dom) { | ||
| return true; | ||
| } | ||
| sub = new Range$1(sub, options); | ||
| dom = new Range$1(dom, options); | ||
| let sawNonNull = false; | ||
| OUTER: | ||
| for (const simpleSub of sub.set) { | ||
| for (const simpleDom of dom.set) { | ||
| const isSub = simpleSubset(simpleSub, simpleDom, options); | ||
| sawNonNull = sawNonNull || isSub !== null; | ||
| if (isSub) { | ||
| continue OUTER; | ||
| } | ||
| } | ||
| if (sawNonNull) { | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| }; | ||
| const minimumVersionWithPreRelease = [new Comparator$1(">=0.0.0-0")]; | ||
| const minimumVersion = [new Comparator$1(">=0.0.0")]; | ||
| const simpleSubset = (sub, dom, options) => { | ||
| if (sub === dom) { | ||
| return true; | ||
| } | ||
| if (sub.length === 1 && sub[0].semver === ANY) { | ||
| if (dom.length === 1 && dom[0].semver === ANY) { | ||
| return true; | ||
| } else if (options.includePrerelease) { | ||
| sub = minimumVersionWithPreRelease; | ||
| } else { | ||
| sub = minimumVersion; | ||
| } | ||
| } | ||
| if (dom.length === 1 && dom[0].semver === ANY) { | ||
| if (options.includePrerelease) { | ||
| return true; | ||
| } else { | ||
| dom = minimumVersion; | ||
| } | ||
| } | ||
| const eqSet = /* @__PURE__ */ new Set(); | ||
| let gt2, lt2; | ||
| for (const c of sub) { | ||
| if (c.operator === ">" || c.operator === ">=") { | ||
| gt2 = higherGT(gt2, c, options); | ||
| } else if (c.operator === "<" || c.operator === "<=") { | ||
| lt2 = lowerLT(lt2, c, options); | ||
| } else { | ||
| eqSet.add(c.semver); | ||
| } | ||
| } | ||
| if (eqSet.size > 1) { | ||
| return null; | ||
| } | ||
| let gtltComp; | ||
| if (gt2 && lt2) { | ||
| gtltComp = compare$1(gt2.semver, lt2.semver, options); | ||
| if (gtltComp > 0) { | ||
| return null; | ||
| } else if (gtltComp === 0 && (gt2.operator !== ">=" || lt2.operator !== "<=")) { | ||
| return null; | ||
| } | ||
| } | ||
| for (const eq2 of eqSet) { | ||
| if (gt2 && !satisfies$1(eq2, String(gt2), options)) { | ||
| return null; | ||
| } | ||
| if (lt2 && !satisfies$1(eq2, String(lt2), options)) { | ||
| return null; | ||
| } | ||
| for (const c of dom) { | ||
| if (!satisfies$1(eq2, String(c), options)) { | ||
| return false; | ||
| } | ||
| } | ||
| return true; | ||
| } | ||
| let higher, lower; | ||
| let hasDomLT, hasDomGT; | ||
| let needDomLTPre = lt2 && !options.includePrerelease && lt2.semver.prerelease.length ? lt2.semver : false; | ||
| let needDomGTPre = gt2 && !options.includePrerelease && gt2.semver.prerelease.length ? gt2.semver : false; | ||
| if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt2.operator === "<" && needDomLTPre.prerelease[0] === 0) { | ||
| needDomLTPre = false; | ||
| } | ||
| for (const c of dom) { | ||
| hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">="; | ||
| hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<="; | ||
| if (gt2) { | ||
| if (needDomGTPre) { | ||
| if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) { | ||
| needDomGTPre = false; | ||
| } | ||
| } | ||
| if (c.operator === ">" || c.operator === ">=") { | ||
| higher = higherGT(gt2, c, options); | ||
| if (higher === c && higher !== gt2) { | ||
| return false; | ||
| } | ||
| } else if (gt2.operator === ">=" && !satisfies$1(gt2.semver, String(c), options)) { | ||
| return false; | ||
| } | ||
| } | ||
| if (lt2) { | ||
| if (needDomLTPre) { | ||
| if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) { | ||
| needDomLTPre = false; | ||
| } | ||
| } | ||
| if (c.operator === "<" || c.operator === "<=") { | ||
| lower = lowerLT(lt2, c, options); | ||
| if (lower === c && lower !== lt2) { | ||
| return false; | ||
| } | ||
| } else if (lt2.operator === "<=" && !satisfies$1(lt2.semver, String(c), options)) { | ||
| return false; | ||
| } | ||
| } | ||
| if (!c.operator && (lt2 || gt2) && gtltComp !== 0) { | ||
| return false; | ||
| } | ||
| } | ||
| if (gt2 && hasDomLT && !lt2 && gtltComp !== 0) { | ||
| return false; | ||
| } | ||
| if (lt2 && hasDomGT && !gt2 && gtltComp !== 0) { | ||
| return false; | ||
| } | ||
| if (needDomGTPre || needDomLTPre) { | ||
| return false; | ||
| } | ||
| return true; | ||
| }; | ||
| const higherGT = (a, b, options) => { | ||
| if (!a) { | ||
| return b; | ||
| } | ||
| const comp = compare$1(a.semver, b.semver, options); | ||
| return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a; | ||
| }; | ||
| const lowerLT = (a, b, options) => { | ||
| if (!a) { | ||
| return b; | ||
| } | ||
| const comp = compare$1(a.semver, b.semver, options); | ||
| return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a; | ||
| }; | ||
| var subset_1 = subset$1; | ||
| const internalRe = reExports; | ||
| const constants = constants$1; | ||
| const SemVer2 = semver$2; | ||
| const identifiers = identifiers$1; | ||
| const parse = parse_1; | ||
| const valid = valid_1; | ||
| const clean = clean_1; | ||
| const inc = inc_1; | ||
| const diff = diff_1; | ||
| const major = major_1; | ||
| const minor = minor_1; | ||
| const patch = patch_1; | ||
| const prerelease = prerelease_1; | ||
| const compare = compare_1; | ||
| const rcompare = rcompare_1; | ||
| const compareLoose = compareLoose_1; | ||
| const compareBuild = compareBuild_1; | ||
| const sort = sort_1; | ||
| const rsort = rsort_1; | ||
| const gt = gt_1; | ||
| const lt = lt_1; | ||
| const eq = eq_1; | ||
| const neq = neq_1; | ||
| const gte = gte_1; | ||
| const lte = lte_1; | ||
| const cmp = cmp_1; | ||
| const coerce = coerce_1; | ||
| const Comparator = requireComparator(); | ||
| const Range = requireRange(); | ||
| const satisfies = satisfies_1; | ||
| const toComparators = toComparators_1; | ||
| const maxSatisfying = maxSatisfying_1; | ||
| const minSatisfying = minSatisfying_1; | ||
| const minVersion = minVersion_1; | ||
| const validRange = valid$1; | ||
| const outside = outside_1; | ||
| const gtr = gtr_1; | ||
| const ltr = ltr_1; | ||
| const intersects = intersects_1; | ||
| const simplifyRange = simplify; | ||
| const subset = subset_1; | ||
| var semver = { | ||
| parse, | ||
| valid, | ||
| clean, | ||
| inc, | ||
| diff, | ||
| major, | ||
| minor, | ||
| patch, | ||
| prerelease, | ||
| compare, | ||
| rcompare, | ||
| compareLoose, | ||
| compareBuild, | ||
| sort, | ||
| rsort, | ||
| gt, | ||
| lt, | ||
| eq, | ||
| neq, | ||
| gte, | ||
| lte, | ||
| cmp, | ||
| coerce, | ||
| Comparator, | ||
| Range, | ||
| satisfies, | ||
| toComparators, | ||
| maxSatisfying, | ||
| minSatisfying, | ||
| minVersion, | ||
| validRange, | ||
| outside, | ||
| gtr, | ||
| ltr, | ||
| intersects, | ||
| simplifyRange, | ||
| subset, | ||
| SemVer: SemVer2, | ||
| re: internalRe.re, | ||
| src: internalRe.src, | ||
| tokens: internalRe.t, | ||
| SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION, | ||
| RELEASE_TYPES: constants.RELEASE_TYPES, | ||
| compareIdentifiers: identifiers.compareIdentifiers, | ||
| rcompareIdentifiers: identifiers.rcompareIdentifiers | ||
| }; | ||
| const semver$1 = /* @__PURE__ */ getDefaultExportFromCjs(semver); | ||
| const getBridgeRouterAlias = (originalAlias) => { | ||
| const userPackageJsonPath = path.resolve(process.cwd(), "package.json"); | ||
| let userDependencies = {}; | ||
| if (fs.existsSync(userPackageJsonPath)) { | ||
| const userPackageJson = JSON.parse( | ||
| fs.readFileSync(userPackageJsonPath, "utf-8") | ||
| ); | ||
| userDependencies = { | ||
| ...userPackageJson.dependencies, | ||
| ...userPackageJson.devDependencies | ||
| }; | ||
| } | ||
| const hasBridgeReact = "@module-federation/bridge-react" in userDependencies; | ||
| let bridgeRouterAlias = {}; | ||
| if (hasBridgeReact) { | ||
| const reactRouterDomVersion = userDependencies["react-router-dom"]; | ||
| let majorVersion = 0; | ||
| let reactRouterDomPath = ""; | ||
| if (reactRouterDomVersion) { | ||
| majorVersion = semver$1.major( | ||
| semver$1.coerce(reactRouterDomVersion || "0.0.0") ?? "0.0.0" | ||
| ); | ||
| reactRouterDomPath = require.resolve("react-router-dom"); | ||
| } else { | ||
| reactRouterDomPath = require.resolve("react-router-dom"); | ||
| const packageJsonPath = path.resolve( | ||
| reactRouterDomPath, | ||
| "../../package.json" | ||
| ); | ||
| const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")); | ||
| majorVersion = parseInt(packageJson.version.split(".")[0]); | ||
| } | ||
| reactRouterDomPath = originalAlias || reactRouterDomPath; | ||
| if (majorVersion === 5) { | ||
| bridgeRouterAlias = { | ||
| "react-router-dom$": "@module-federation/bridge-react/dist/router-v5.es.js" | ||
| }; | ||
| try { | ||
| require.resolve("react-router-dom/index.js"); | ||
| } catch (error) { | ||
| bridgeRouterAlias = { | ||
| ...bridgeRouterAlias, | ||
| "react-router-dom/index.js": reactRouterDomPath | ||
| }; | ||
| } | ||
| } else if (majorVersion === 6) { | ||
| bridgeRouterAlias = { | ||
| "react-router-dom$": "@module-federation/bridge-react/dist/router-v6.es.js" | ||
| }; | ||
| try { | ||
| require.resolve("react-router-dom/dist/index.js"); | ||
| } catch (error) { | ||
| bridgeRouterAlias = { | ||
| ...bridgeRouterAlias, | ||
| "react-router-dom/dist/index.js": reactRouterDomPath | ||
| }; | ||
| } | ||
| } else { | ||
| console.warn("react-router-dom version is not supported"); | ||
| } | ||
| } | ||
| console.log( | ||
| "<<<<<<<<<<<<< bridgeRouterAlias >>>>>>>>>>>>>", | ||
| bridgeRouterAlias | ||
| ); | ||
| return bridgeRouterAlias; | ||
| }; | ||
| class ReactBridgeAliasChangerPlugin { | ||
@@ -41,3 +1705,8 @@ constructor(info) { | ||
| const originalAlias = originalResolve.alias || {}; | ||
| const updatedAlias = { ...originalAlias, [this.alias]: targetFilePath }; | ||
| const updatedAlias = { | ||
| // allow `alias` can be override | ||
| // [this.alias]: targetFilePath, | ||
| ...getBridgeRouterAlias(originalAlias["react-router-dom"]), | ||
| ...originalAlias | ||
| }; | ||
| compiler.options.resolve = { | ||
@@ -44,0 +1713,0 @@ ...originalResolve, |
| { | ||
| "name": "@module-federation/bridge-react-webpack-plugin", | ||
| "version": "0.0.0-next-20240822090000", | ||
| "version": "0.0.0-next-20240822101913", | ||
| "publishConfig": { | ||
@@ -9,3 +9,3 @@ "access": "public" | ||
| "main": "./dist/index.cjs.js", | ||
| "module": "./dist/index.esm.js", | ||
| "module": "./dist/index.es.js", | ||
| "types": "./dist/index.cjs.d.ts", | ||
@@ -15,3 +15,3 @@ "exports": { | ||
| "types": "./dist/index.cjs.d.ts", | ||
| "import": "./dist/index.esm.js", | ||
| "import": "./dist/index.es.js", | ||
| "require": "./dist/index.cjs.js" | ||
@@ -22,3 +22,5 @@ }, | ||
| "dependencies": { | ||
| "@module-federation/sdk": "0.0.0-next-20240822090000" | ||
| "semver": "7.6.3", | ||
| "@types/semver": "7.5.8", | ||
| "@module-federation/sdk": "0.0.0-next-20240822101913" | ||
| }, | ||
@@ -25,0 +27,0 @@ "devDependencies": { |
| import fs from 'node:fs'; | ||
| import path from 'node:path'; | ||
| import type { moduleFederationPlugin } from '@module-federation/sdk'; | ||
| import { getBridgeRouterAlias } from './utis'; | ||
@@ -15,2 +16,3 @@ class ReactBridgeAliasChangerPlugin { | ||
| this.targetFile = '@module-federation/bridge-react/dist/router.es.js'; | ||
| if (this.moduleFederationOptions.shared) { | ||
@@ -44,3 +46,8 @@ if (Array.isArray(this.moduleFederationOptions.shared)) { | ||
| // Update alias | ||
| const updatedAlias = { ...originalAlias, [this.alias]: targetFilePath }; | ||
| const updatedAlias = { | ||
| // allow `alias` can be override | ||
| // [this.alias]: targetFilePath, | ||
| ...getBridgeRouterAlias(originalAlias['react-router-dom']), | ||
| ...originalAlias, | ||
| }; | ||
@@ -47,0 +54,0 @@ // Update the webpack configuration |
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Environment variable access
Supply chain riskPackage accesses environment variables, which may be a sign of credential stuffing or data theft.
Found 2 instances in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by740.21%
123847
- Number of package files
- increased by8.33%
13
- Lines of code
- increased by1367.46%
3698
Worsened metrics
- Dependency count
- increased by200%
3
- Number of low supply chain risk alerts
- increased by600%
7
Dependency changes
+ Added@types/semver@7.5.8
+ Addedsemver@7.6.3
+ Added@module-federation/sdk@0.0.0-next-20240822101913(transitive)
+ Added@types/semver@7.5.8(transitive)
+ Addedsemver@7.6.3(transitive)
- Removed@module-federation/sdk@0.0.0-next-20240822090000(transitive)