@sbee/vite-federation 0.0.1

package/dist/runtime/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Dynamic Remote Loading Utility
+ *
+ * Cho phép host-app tải remote modules khi chạy (runtime) mà **không cần**
+ * khai báo trước trong `vite.config.ts`.
+ *
+ * @example
+ * ```ts
+ * import { loadRemote, registerRemote, preloadRemote } from '@sbee/vite-federation/runtime'
+ *
+ * // Cách 1: Load thẳng không cần đăng ký trước
+ * const Button = await loadRemote('https://remote.example.com/remoteEntry.js', './Button')
+ *
+ * // Cách 2: Đăng ký trước rồi load sau
+ * registerRemote('my-remote', { url: 'https://remote.example.com/remoteEntry.js' })
+ * const Button = await loadRemote('my-remote', './Button')
+ *
+ * // Cách 3: Preload trước để init sẵn
+ * const remote = await preloadRemote('my-remote', { url: 'https://remote.example.com/remoteEntry.js' })
+ * const Button = await remote.get('./Button')
+ * ```
+ */
+export interface RemoteConfig {
+    /** URL tới remote entry file (remoteEntry.js) hoặc function trả về URL */
+    url: string | (() => Promise<string>);
+    /** Định dạng remote: 'esm' (import()) hay 'var' (script tag + window global) */
+    format?: 'esm' | 'var';
+    /** Hệ thống build của remote: 'vite' (mặc định) hay 'webpack' */
+    from?: 'vite' | 'webpack';
+    /** Share scope name, mặc định 'default' */
+    shareScope?: string;
+}
+export interface RemoteHandle {
+    /** Tải một module đã expose từ remote */
+    get<T = any>(moduleName: string): Promise<T>;
+    /** Init lại share scope cho remote */
+    init(shareScope: Record<string, any>): void;
+    /** Remote đã được init chưa */
+    readonly inited: boolean;
+}
+/** Lấy hoặc khởi tạo global share scope */
+export declare function getShareScope(scopeName?: string): Record<string, any>;
+/** Đăng ký shared packages vào share scope (thường dùng bởi host) */
+export declare function provideShared(scopeName: string, packages: Record<string, Record<string, {
+    get: () => Promise<() => any>;
+}>>): void;
+/**
+ * Đăng ký một remote để dùng sau này.
+ * Hàm này đồng bộ, không tải gì cả — chỉ lưu config.
+ */
+export declare function registerRemote(name: string, config: RemoteConfig): void;
+/**
+ * Preload & init một remote, trả về handle để gọi `.get()`.
+ * Cache lại — gọi nhiều lần với cùng `name` chỉ tải & init một lần,
+ * kể cả khi gọi đồng thời (dedup promise in-flight).
+ */
+export declare function preloadRemote(name: string, config?: RemoteConfig): Promise<RemoteHandle>;
+/**
+ * Tải một module từ remote (có thể chưa đăng ký trước).
+ *
+ * @param remoteUrlOrName - URL tới remoteEntry.js HOẶC tên đã đăng ký qua `registerRemote()`
+ * @param moduleName - Đường dẫn module đã expose, VD: `'./Button'`, `'./App'`
+ *
+ * @example
+ * ```ts
+ * // Dùng URL trực tiếp
+ * const Button = await loadRemote('https://my-app.com/remoteEntry.js', './Button')
+ *
+ * // Dùng tên đã đăng ký
+ * registerRemote('my-remote', { url: 'https://my-app.com/remoteEntry.js' })
+ * const Button = await loadRemote('my-remote', './Button')
+ * ```
+ */
+export declare function loadRemote<T = any>(remoteUrlOrName: string, moduleName: string, config?: RemoteConfig): Promise<T>;
+/**
+ * Tải nhiều module cùng lúc từ một remote.
+ */
+export declare function loadRemoteModules<T extends Record<string, string>>(remoteUrlOrName: string, modules: T, config?: RemoteConfig): Promise<{
+    [K in keyof T]: any;
+}>;

package/dist/runtime.js

@@ -0,0 +1,176 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/runtime/index.ts
+var _remoteMap = /* @__PURE__ */ new Map();
+var _remoteConfigMap = /* @__PURE__ */ new Map();
+var _pendingMap = /* @__PURE__ */ new Map();
+/** Lấy hoặc khởi tạo global share scope */
+function getShareScope(scopeName = "default") {
+	const g = globalThis;
+	g.__federation_shared__ = g.__federation_shared__ || {};
+	g.__federation_shared__[scopeName] = g.__federation_shared__[scopeName] || {};
+	return g.__federation_shared__[scopeName];
+}
+/** Đăng ký shared packages vào share scope (thường dùng bởi host) */
+function provideShared(scopeName, packages) {
+	const scope = getShareScope(scopeName);
+	for (const [pkgName, versions] of Object.entries(packages)) {
+		scope[pkgName] = scope[pkgName] || {};
+		Object.assign(scope[pkgName], versions);
+	}
+}
+function resolveUrl(url) {
+	return typeof url === "function" ? url() : Promise.resolve(url);
+}
+function unwrapModule(module, from) {
+	if (from === "webpack") return Object.prototype.toString.call(module).indexOf("Module") > -1 && module.default ? module.default : module;
+	return module?.__esModule || module?.[Symbol.toStringTag] === "Module" ? module.default : module;
+}
+function mergeShareScope(target, source) {
+	const merged = Object.assign({}, target, source);
+	for (const key of Object.keys(merged)) if (typeof merged[key] === "object" && typeof source[key] === "object") merged[key] = mergeShareScope(merged[key], source[key]);
+	return merged;
+}
+/**
+* Đăng ký một remote để dùng sau này.
+* Hàm này đồng bộ, không tải gì cả — chỉ lưu config.
+*/
+function registerRemote(name, config) {
+	_remoteConfigMap.set(name, config);
+}
+/** Tải + init một remote entry đúng MỘT lần cho mỗi name (dedup promise in-flight). */
+function ensureLoaded(name, cfg, shareScope) {
+	const existingEntry = _remoteMap.get(name);
+	if (existingEntry?.inited) return Promise.resolve(existingEntry);
+	const pending = _pendingMap.get(name);
+	if (pending) return pending;
+	const tracked = (async () => {
+		if (cfg.format === "var") {
+			const url = await resolveUrl(cfg.url);
+			return await new Promise((resolve, reject) => {
+				const finish = (lib) => {
+					const wrapped = Object.assign(lib, { inited: false });
+					wrapped.init(shareScope);
+					wrapped.inited = true;
+					resolve(wrapped);
+				};
+				const existing = window[name];
+				if (existing) {
+					finish(existing);
+					return;
+				}
+				const script = document.createElement("script");
+				script.type = "text/javascript";
+				script.onload = () => {
+					const lib = window[name];
+					if (!lib) return reject(/* @__PURE__ */ new Error(`[mf-runtime] Remote "${name}" không expose global "${name}"`));
+					finish(lib);
+				};
+				script.onerror = () => reject(/* @__PURE__ */ new Error(`[mf-runtime] Không thể tải remote "${name}" từ ${url}`));
+				script.src = url;
+				document.head.appendChild(script);
+			});
+		}
+		const lib = await import(
+			/* @vite-ignore */
+			await resolveUrl(cfg.url)
+);
+		const wrapped = Object.assign(lib, { inited: false });
+		wrapped.init(shareScope);
+		wrapped.inited = true;
+		return wrapped;
+	})().then((entry) => {
+		_remoteMap.set(name, entry);
+		return entry;
+	}).finally(() => {
+		_pendingMap.delete(name);
+	});
+	_pendingMap.set(name, tracked);
+	return tracked;
+}
+/**
+* Preload & init một remote, trả về handle để gọi `.get()`.
+* Cache lại — gọi nhiều lần với cùng `name` chỉ tải & init một lần,
+* kể cả khi gọi đồng thời (dedup promise in-flight).
+*/
+async function preloadRemote(name, config) {
+	const cfg = config ?? _remoteConfigMap.get(name);
+	if (!cfg) throw new Error(`[mf-runtime] Remote "${name}" chưa được đăng ký. Gọi registerRemote() trước hoặc truyền config.`);
+	const shareScope = getShareScope(cfg.shareScope || "default");
+	await ensureLoaded(name, cfg, shareScope);
+	return {
+		async get(moduleName) {
+			const e = _remoteMap.get(name);
+			if (!e) throw new Error(`[mf-runtime] Remote "${name}" chưa được load`);
+			return unwrapModule((await e.get(moduleName))(), cfg.from);
+		},
+		init(shareScopeInput) {
+			const e = _remoteMap.get(name);
+			if (e) {
+				const merged = mergeShareScope(shareScope, shareScopeInput);
+				e.init(merged);
+			}
+		},
+		get inited() {
+			return _remoteMap.get(name)?.inited ?? false;
+		}
+	};
+}
+/**
+* Phân giải `remoteUrlOrName` thành `{ name, cfg }`:
+* - Nếu là tên đã đăng ký qua `registerRemote()` → dùng config đã lưu (trừ khi truyền `config` override).
+* - Nếu là URL → tạo tên tự động và đăng ký config `{ url }`.
+*/
+function resolveRemote(remoteUrlOrName, config) {
+	if (_remoteConfigMap.has(remoteUrlOrName)) return {
+		name: remoteUrlOrName,
+		cfg: config ?? _remoteConfigMap.get(remoteUrlOrName)
+	};
+	const name = `__dynamic__${remoteUrlOrName}`;
+	const cfg = config ?? { url: remoteUrlOrName };
+	if (!_remoteConfigMap.has(name)) registerRemote(name, cfg);
+	return {
+		name,
+		cfg
+	};
+}
+/**
+* Tải một module từ remote (có thể chưa đăng ký trước).
+*
+* @param remoteUrlOrName - URL tới remoteEntry.js HOẶC tên đã đăng ký qua `registerRemote()`
+* @param moduleName - Đường dẫn module đã expose, VD: `'./Button'`, `'./App'`
+*
+* @example
+* ```ts
+* // Dùng URL trực tiếp
+* const Button = await loadRemote('https://my-app.com/remoteEntry.js', './Button')
+*
+* // Dùng tên đã đăng ký
+* registerRemote('my-remote', { url: 'https://my-app.com/remoteEntry.js' })
+* const Button = await loadRemote('my-remote', './Button')
+* ```
+*/
+async function loadRemote(remoteUrlOrName, moduleName, config) {
+	const { name, cfg } = resolveRemote(remoteUrlOrName, config);
+	return (await preloadRemote(name, cfg)).get(moduleName);
+}
+/**
+* Tải nhiều module cùng lúc từ một remote.
+*/
+async function loadRemoteModules(remoteUrlOrName, modules, config) {
+	const { name, cfg } = resolveRemote(remoteUrlOrName, config);
+	const remote = await preloadRemote(name, cfg);
+	const entries = Object.entries(modules);
+	const results = await Promise.all(entries.map(([, mod]) => remote.get(mod)));
+	const result = {};
+	entries.forEach(([key], i) => {
+		result[key] = results[i];
+	});
+	return result;
+}
+//#endregion
+exports.getShareScope = getShareScope;
+exports.loadRemote = loadRemote;
+exports.loadRemoteModules = loadRemoteModules;
+exports.preloadRemote = preloadRemote;
+exports.provideShared = provideShared;
+exports.registerRemote = registerRemote;

package/dist/runtime.mjs

@@ -0,0 +1,170 @@
+//#region src/runtime/index.ts
+var _remoteMap = /* @__PURE__ */ new Map();
+var _remoteConfigMap = /* @__PURE__ */ new Map();
+var _pendingMap = /* @__PURE__ */ new Map();
+/** Lấy hoặc khởi tạo global share scope */
+function getShareScope(scopeName = "default") {
+	const g = globalThis;
+	g.__federation_shared__ = g.__federation_shared__ || {};
+	g.__federation_shared__[scopeName] = g.__federation_shared__[scopeName] || {};
+	return g.__federation_shared__[scopeName];
+}
+/** Đăng ký shared packages vào share scope (thường dùng bởi host) */
+function provideShared(scopeName, packages) {
+	const scope = getShareScope(scopeName);
+	for (const [pkgName, versions] of Object.entries(packages)) {
+		scope[pkgName] = scope[pkgName] || {};
+		Object.assign(scope[pkgName], versions);
+	}
+}
+function resolveUrl(url) {
+	return typeof url === "function" ? url() : Promise.resolve(url);
+}
+function unwrapModule(module, from) {
+	if (from === "webpack") return Object.prototype.toString.call(module).indexOf("Module") > -1 && module.default ? module.default : module;
+	return module?.__esModule || module?.[Symbol.toStringTag] === "Module" ? module.default : module;
+}
+function mergeShareScope(target, source) {
+	const merged = Object.assign({}, target, source);
+	for (const key of Object.keys(merged)) if (typeof merged[key] === "object" && typeof source[key] === "object") merged[key] = mergeShareScope(merged[key], source[key]);
+	return merged;
+}
+/**
+* Đăng ký một remote để dùng sau này.
+* Hàm này đồng bộ, không tải gì cả — chỉ lưu config.
+*/
+function registerRemote(name, config) {
+	_remoteConfigMap.set(name, config);
+}
+/** Tải + init một remote entry đúng MỘT lần cho mỗi name (dedup promise in-flight). */
+function ensureLoaded(name, cfg, shareScope) {
+	const existingEntry = _remoteMap.get(name);
+	if (existingEntry?.inited) return Promise.resolve(existingEntry);
+	const pending = _pendingMap.get(name);
+	if (pending) return pending;
+	const tracked = (async () => {
+		if (cfg.format === "var") {
+			const url = await resolveUrl(cfg.url);
+			return await new Promise((resolve, reject) => {
+				const finish = (lib) => {
+					const wrapped = Object.assign(lib, { inited: false });
+					wrapped.init(shareScope);
+					wrapped.inited = true;
+					resolve(wrapped);
+				};
+				const existing = window[name];
+				if (existing) {
+					finish(existing);
+					return;
+				}
+				const script = document.createElement("script");
+				script.type = "text/javascript";
+				script.onload = () => {
+					const lib = window[name];
+					if (!lib) return reject(/* @__PURE__ */ new Error(`[mf-runtime] Remote "${name}" không expose global "${name}"`));
+					finish(lib);
+				};
+				script.onerror = () => reject(/* @__PURE__ */ new Error(`[mf-runtime] Không thể tải remote "${name}" từ ${url}`));
+				script.src = url;
+				document.head.appendChild(script);
+			});
+		}
+		const lib = await import(
+			/* @vite-ignore */
+			await resolveUrl(cfg.url)
+);
+		const wrapped = Object.assign(lib, { inited: false });
+		wrapped.init(shareScope);
+		wrapped.inited = true;
+		return wrapped;
+	})().then((entry) => {
+		_remoteMap.set(name, entry);
+		return entry;
+	}).finally(() => {
+		_pendingMap.delete(name);
+	});
+	_pendingMap.set(name, tracked);
+	return tracked;
+}
+/**
+* Preload & init một remote, trả về handle để gọi `.get()`.
+* Cache lại — gọi nhiều lần với cùng `name` chỉ tải & init một lần,
+* kể cả khi gọi đồng thời (dedup promise in-flight).
+*/
+async function preloadRemote(name, config) {
+	const cfg = config ?? _remoteConfigMap.get(name);
+	if (!cfg) throw new Error(`[mf-runtime] Remote "${name}" chưa được đăng ký. Gọi registerRemote() trước hoặc truyền config.`);
+	const shareScope = getShareScope(cfg.shareScope || "default");
+	await ensureLoaded(name, cfg, shareScope);
+	return {
+		async get(moduleName) {
+			const e = _remoteMap.get(name);
+			if (!e) throw new Error(`[mf-runtime] Remote "${name}" chưa được load`);
+			return unwrapModule((await e.get(moduleName))(), cfg.from);
+		},
+		init(shareScopeInput) {
+			const e = _remoteMap.get(name);
+			if (e) {
+				const merged = mergeShareScope(shareScope, shareScopeInput);
+				e.init(merged);
+			}
+		},
+		get inited() {
+			return _remoteMap.get(name)?.inited ?? false;
+		}
+	};
+}
+/**
+* Phân giải `remoteUrlOrName` thành `{ name, cfg }`:
+* - Nếu là tên đã đăng ký qua `registerRemote()` → dùng config đã lưu (trừ khi truyền `config` override).
+* - Nếu là URL → tạo tên tự động và đăng ký config `{ url }`.
+*/
+function resolveRemote(remoteUrlOrName, config) {
+	if (_remoteConfigMap.has(remoteUrlOrName)) return {
+		name: remoteUrlOrName,
+		cfg: config ?? _remoteConfigMap.get(remoteUrlOrName)
+	};
+	const name = `__dynamic__${remoteUrlOrName}`;
+	const cfg = config ?? { url: remoteUrlOrName };
+	if (!_remoteConfigMap.has(name)) registerRemote(name, cfg);
+	return {
+		name,
+		cfg
+	};
+}
+/**
+* Tải một module từ remote (có thể chưa đăng ký trước).
+*
+* @param remoteUrlOrName - URL tới remoteEntry.js HOẶC tên đã đăng ký qua `registerRemote()`
+* @param moduleName - Đường dẫn module đã expose, VD: `'./Button'`, `'./App'`
+*
+* @example
+* ```ts
+* // Dùng URL trực tiếp
+* const Button = await loadRemote('https://my-app.com/remoteEntry.js', './Button')
+*
+* // Dùng tên đã đăng ký
+* registerRemote('my-remote', { url: 'https://my-app.com/remoteEntry.js' })
+* const Button = await loadRemote('my-remote', './Button')
+* ```
+*/
+async function loadRemote(remoteUrlOrName, moduleName, config) {
+	const { name, cfg } = resolveRemote(remoteUrlOrName, config);
+	return (await preloadRemote(name, cfg)).get(moduleName);
+}
+/**
+* Tải nhiều module cùng lúc từ một remote.
+*/
+async function loadRemoteModules(remoteUrlOrName, modules, config) {
+	const { name, cfg } = resolveRemote(remoteUrlOrName, config);
+	const remote = await preloadRemote(name, cfg);
+	const entries = Object.entries(modules);
+	const results = await Promise.all(entries.map(([, mod]) => remote.get(mod)));
+	const result = {};
+	entries.forEach(([key], i) => {
+		result[key] = results[i];
+	});
+	return result;
+}
+//#endregion
+export { getShareScope, loadRemote, loadRemoteModules, preloadRemote, provideShared, registerRemote };

package/dist/satisfy.js

@@ -0,0 +1,223 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/utils/semver/constants.ts
+var buildIdentifier = "[0-9A-Za-z-]+";
+var build = `(?:\\+(${buildIdentifier}(?:\\.${buildIdentifier})*))`;
+var numericIdentifier = "0|[1-9]\\d*";
+var numericIdentifierLoose = "[0-9]+";
+var nonNumericIdentifier = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+var preReleaseIdentifierLoose = `(?:${numericIdentifierLoose}|${nonNumericIdentifier})`;
+var preReleaseLoose = `(?:-?(${preReleaseIdentifierLoose}(?:\\.${preReleaseIdentifierLoose})*))`;
+var preReleaseIdentifier = `(?:${numericIdentifier}|${nonNumericIdentifier})`;
+var preRelease = `(?:-(${preReleaseIdentifier}(?:\\.${preReleaseIdentifier})*))`;
+var xRangeIdentifier = `${numericIdentifier}|x|X|\\*`;
+var xRangePlain = `[v=\\s]*(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:${preRelease})?${build}?)?)?`;
+var hyphenRange = new RegExp(`^\\s*(${xRangePlain})\\s+-\\s+(${xRangePlain})\\s*$`);
+var loosePlain = `[v=\\s]*${`(${numericIdentifierLoose})\\.(${numericIdentifierLoose})\\.(${numericIdentifierLoose})`}${preReleaseLoose}?${build}?`;
+var gtlt = "((?:<|>)?=?)";
+var comparatorTrim = new RegExp(`(\\s*)${gtlt}\\s*(${loosePlain}|${xRangePlain})`);
+var loneTilde = "(?:~>?)";
+var tildeTrim = new RegExp(`(\\s*)${loneTilde}\\s+`);
+var loneCaret = "(?:\\^)";
+var caretTrim = new RegExp(`(\\s*)${loneCaret}\\s+`);
+var star = /* @__PURE__ */ new RegExp("(<|>)?=?\\s*\\*");
+var caret = new RegExp(`^${loneCaret}${xRangePlain}$`);
+var fullPlain = `v?${`(${numericIdentifier})\\.(${numericIdentifier})\\.(${numericIdentifier})`}${preRelease}?${build}?`;
+var tilde = new RegExp(`^${loneTilde}${xRangePlain}$`);
+var xRange = new RegExp(`^${gtlt}\\s*${xRangePlain}$`);
+var comparator = new RegExp(`^${gtlt}\\s*(${fullPlain})$|^$`);
+var gte0 = /* @__PURE__ */ new RegExp("^\\s*>=\\s*0.0.0\\s*$");
+//#endregion
+//#region src/utils/semver/utils.ts
+function isXVersion(version) {
+	return !version || version.toLowerCase() === "x" || version === "*";
+}
+function pipe(...fns) {
+	return (x) => fns.reduce((v, f) => f(v), x);
+}
+function extractComparator(comparatorString) {
+	return comparatorString.match(comparator);
+}
+function combineVersion(major, minor, patch, preRelease) {
+	const mainVersion = `${major}.${minor}.${patch}`;
+	if (preRelease) return `${mainVersion}-${preRelease}`;
+	return mainVersion;
+}
+//#endregion
+//#region src/utils/semver/parser.ts
+function parseHyphen(range) {
+	return range.replace(hyphenRange, (_range, from, fromMajor, fromMinor, fromPatch, _fromPreRelease, _fromBuild, to, toMajor, toMinor, toPatch, toPreRelease) => {
+		if (isXVersion(fromMajor)) from = "";
+		else if (isXVersion(fromMinor)) from = `>=${fromMajor}.0.0`;
+		else if (isXVersion(fromPatch)) from = `>=${fromMajor}.${fromMinor}.0`;
+		else from = `>=${from}`;
+		if (isXVersion(toMajor)) to = "";
+		else if (isXVersion(toMinor)) to = `<${+toMajor + 1}.0.0-0`;
+		else if (isXVersion(toPatch)) to = `<${toMajor}.${+toMinor + 1}.0-0`;
+		else if (toPreRelease) to = `<=${toMajor}.${toMinor}.${toPatch}-${toPreRelease}`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	});
+}
+function parseComparatorTrim(range) {
+	return range.replace(comparatorTrim, "$1$2$3");
+}
+function parseTildeTrim(range) {
+	return range.replace(tildeTrim, "$1~");
+}
+function parseCaretTrim(range) {
+	return range.replace(caretTrim, "$1^");
+}
+function parseCarets(range) {
+	return range.trim().split(/\s+/).map((rangeVersion) => {
+		return rangeVersion.replace(caret, (_, major, minor, patch, preRelease) => {
+			if (isXVersion(major)) return "";
+			else if (isXVersion(minor)) return `>=${major}.0.0 <${+major + 1}.0.0-0`;
+			else if (isXVersion(patch)) if (major === "0") return `>=${major}.${minor}.0 <${major}.${+minor + 1}.0-0`;
+			else return `>=${major}.${minor}.0 <${+major + 1}.0.0-0`;
+			else if (preRelease) if (major === "0") if (minor === "0") return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${minor}.${+patch + 1}-0`;
+			else return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${+minor + 1}.0-0`;
+			else return `>=${major}.${minor}.${patch}-${preRelease} <${+major + 1}.0.0-0`;
+			else {
+				if (major === "0") if (minor === "0") return `>=${major}.${minor}.${patch} <${major}.${minor}.${+patch + 1}-0`;
+				else return `>=${major}.${minor}.${patch} <${major}.${+minor + 1}.0-0`;
+				return `>=${major}.${minor}.${patch} <${+major + 1}.0.0-0`;
+			}
+		});
+	}).join(" ");
+}
+function parseTildes(range) {
+	return range.trim().split(/\s+/).map((rangeVersion) => {
+		return rangeVersion.replace(tilde, (_, major, minor, patch, preRelease) => {
+			if (isXVersion(major)) return "";
+			else if (isXVersion(minor)) return `>=${major}.0.0 <${+major + 1}.0.0-0`;
+			else if (isXVersion(patch)) return `>=${major}.${minor}.0 <${major}.${+minor + 1}.0-0`;
+			else if (preRelease) return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${+minor + 1}.0-0`;
+			return `>=${major}.${minor}.${patch} <${major}.${+minor + 1}.0-0`;
+		});
+	}).join(" ");
+}
+function parseXRanges(range) {
+	return range.split(/\s+/).map((rangeVersion) => {
+		return rangeVersion.trim().replace(xRange, (ret, gtlt, major, minor, patch, preRelease) => {
+			const isXMajor = isXVersion(major);
+			const isXMinor = isXMajor || isXVersion(minor);
+			const isXPatch = isXMinor || isXVersion(patch);
+			if (gtlt === "=" && isXPatch) gtlt = "";
+			preRelease = "";
+			if (isXMajor) if (gtlt === ">" || gtlt === "<") return "<0.0.0-0";
+			else return "*";
+			else if (gtlt && isXPatch) {
+				if (isXMinor) minor = 0;
+				patch = 0;
+				if (gtlt === ">") {
+					gtlt = ">=";
+					if (isXMinor) {
+						major = +major + 1;
+						minor = 0;
+						patch = 0;
+					} else {
+						minor = +minor + 1;
+						patch = 0;
+					}
+				} else if (gtlt === "<=") {
+					gtlt = "<";
+					if (isXMinor) major = +major + 1;
+					else minor = +minor + 1;
+				}
+				if (gtlt === "<") preRelease = "-0";
+				return `${gtlt + major}.${minor}.${patch}${preRelease}`;
+			} else if (isXMinor) return `>=${major}.0.0${preRelease} <${+major + 1}.0.0-0`;
+			else if (isXPatch) return `>=${major}.${minor}.0${preRelease} <${major}.${+minor + 1}.0-0`;
+			return ret;
+		});
+	}).join(" ");
+}
+function parseStar(range) {
+	return range.trim().replace(star, "");
+}
+function parseGTE0(comparatorString) {
+	return comparatorString.trim().replace(gte0, "");
+}
+//#endregion
+//#region src/utils/semver/compare.ts
+function compareAtom(rangeAtom, versionAtom) {
+	rangeAtom = +rangeAtom || rangeAtom;
+	versionAtom = +versionAtom || versionAtom;
+	if (rangeAtom > versionAtom) return 1;
+	if (rangeAtom === versionAtom) return 0;
+	return -1;
+}
+function comparePreRelease(rangeAtom, versionAtom) {
+	const { preRelease: rangePreRelease } = rangeAtom;
+	const { preRelease: versionPreRelease } = versionAtom;
+	if (rangePreRelease === void 0 && !!versionPreRelease) return 1;
+	if (!!rangePreRelease && versionPreRelease === void 0) return -1;
+	if (rangePreRelease === void 0 && versionPreRelease === void 0) return 0;
+	for (let i = 0, n = rangePreRelease.length; i <= n; i++) {
+		const rangeElement = rangePreRelease[i];
+		const versionElement = versionPreRelease[i];
+		if (rangeElement === versionElement) continue;
+		if (rangeElement === void 0 && versionElement === void 0) return 0;
+		if (!rangeElement) return 1;
+		if (!versionElement) return -1;
+		return compareAtom(rangeElement, versionElement);
+	}
+	return 0;
+}
+function compareVersion(rangeAtom, versionAtom) {
+	return compareAtom(rangeAtom.major, versionAtom.major) || compareAtom(rangeAtom.minor, versionAtom.minor) || compareAtom(rangeAtom.patch, versionAtom.patch) || comparePreRelease(rangeAtom, versionAtom);
+}
+function eq(rangeAtom, versionAtom) {
+	return rangeAtom.version === versionAtom.version;
+}
+function compare(rangeAtom, versionAtom) {
+	switch (rangeAtom.operator) {
+		case "":
+		case "=": return eq(rangeAtom, versionAtom);
+		case ">": return compareVersion(rangeAtom, versionAtom) < 0;
+		case ">=": return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) < 0;
+		case "<": return compareVersion(rangeAtom, versionAtom) > 0;
+		case "<=": return eq(rangeAtom, versionAtom) || compareVersion(rangeAtom, versionAtom) > 0;
+		case void 0: return true;
+		default: return false;
+	}
+}
+//#endregion
+//#region src/utils/semver/satisfy.ts
+function parseComparatorString(range) {
+	return pipe(parseCarets, parseTildes, parseXRanges, parseStar)(range);
+}
+function parseRange(range) {
+	return pipe(parseHyphen, parseComparatorTrim, parseTildeTrim, parseCaretTrim)(range.trim()).split(/\s+/).join(" ");
+}
+function satisfy(version, range) {
+	if (!version) return false;
+	const comparators = parseRange(range).split(" ").map((rangeVersion) => parseComparatorString(rangeVersion)).join(" ").split(/\s+/).map((comparator) => parseGTE0(comparator));
+	const extractedVersion = extractComparator(version);
+	if (!extractedVersion) return false;
+	const [, versionOperator, , versionMajor, versionMinor, versionPatch, versionPreRelease] = extractedVersion;
+	const versionAtom = {
+		operator: versionOperator,
+		version: combineVersion(versionMajor, versionMinor, versionPatch, versionPreRelease),
+		major: versionMajor,
+		minor: versionMinor,
+		patch: versionPatch,
+		preRelease: versionPreRelease?.split(".")
+	};
+	for (const comparator of comparators) {
+		const extractedComparator = extractComparator(comparator);
+		if (!extractedComparator) return false;
+		const [, rangeOperator, , rangeMajor, rangeMinor, rangePatch, rangePreRelease] = extractedComparator;
+		if (!compare({
+			operator: rangeOperator,
+			version: combineVersion(rangeMajor, rangeMinor, rangePatch, rangePreRelease),
+			major: rangeMajor,
+			minor: rangeMinor,
+			patch: rangePatch,
+			preRelease: rangePreRelease?.split(".")
+		}, versionAtom)) return false;
+	}
+	return true;
+}
+//#endregion
+exports.satisfy = satisfy;