@module-federation/runtime 1.0.0-canary.1

package/share.esm.js

@@ -0,0 +1,741 @@
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+
+function getBuilderId() {
+    return typeof FEDERATION_BUILD_IDENTIFIER !== 'undefined' ? FEDERATION_BUILD_IDENTIFIER : '';
+}
+function isDebugMode() {
+    return Boolean('');
+}
+function isBrowserEnv() {
+    return typeof window !== 'undefined';
+}
+
+const LOG_CATEGORY = '[ Federation Runtime ]';
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function assert(condition, msg) {
+    if (!condition) {
+        error(msg);
+    }
+}
+function error(msg) {
+    throw new Error(`${LOG_CATEGORY}: ${msg}`);
+}
+function warn(msg) {
+    console.warn(`${LOG_CATEGORY}: ${msg}`);
+}
+
+function addUniqueItem(arr, item) {
+    if (arr.findIndex((name)=>name === item) === -1) {
+        arr.push(item);
+    }
+    return arr;
+}
+function getFMId(remoteInfo) {
+    if ('version' in remoteInfo && remoteInfo.version) {
+        return `${remoteInfo.name}:${remoteInfo.version}`;
+    } else if ('entry' in remoteInfo && remoteInfo.entry) {
+        return `${remoteInfo.name}:${remoteInfo.entry}`;
+    } else {
+        return `${remoteInfo.name}`;
+    }
+}
+function isRemoteInfoWithEntry(remote) {
+    return typeof remote.entry !== 'undefined';
+}
+function isPureRemoteEntry(remote) {
+    return remote.entry.endsWith('.js');
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function safeWrapper(callback, disableWarn) {
+    try {
+        const res = await callback();
+        return res;
+    } catch (e) {
+        !disableWarn && warn(e);
+        return;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+function safeToString(info) {
+    try {
+        return JSON.stringify(info, null, 2);
+    } catch (e) {
+        return '';
+    }
+}
+function isObject(val) {
+    return val && typeof val === 'object';
+}
+const objectToString = Object.prototype.toString;
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isPlainObject(val) {
+    return objectToString.call(val) === '[object Object]';
+}
+function isStaticResourcesEqual(url1, url2) {
+    const REG_EXP = /^(https?:)?\/\//i;
+    // Convert both url1 and url2 to relative paths
+    const relativeUrl1 = url1.replace(REG_EXP, '').replace(/\/$/, '');
+    const relativeUrl2 = url2.replace(REG_EXP, '').replace(/\/$/, '');
+    // Determines whether relative paths are equal
+    return relativeUrl1 === relativeUrl2;
+}
+
+var _nativeGlobal___FEDERATION__, _nativeGlobal___FEDERATION__1, _nativeGlobal___FEDERATION__2, _nativeGlobal___FEDERATION__3, _nativeGlobal___FEDERATION__4, _nativeGlobal___FEDERATION__5, _nativeGlobal___FEDERATION__6;
+// export const nativeGlobal: typeof global = new Function('return this')();
+const nativeGlobal = new Function('return this')();
+// Avoid being windowed by some microfront end frameworks, but sandbox escapes due to reuse policies
+// The sandbox in the microfront does not copy the value of configurable
+// If no loading content exists on the global object, the loading object is defined
+if (!Object.hasOwnProperty.call(globalThis, '__GLOBAL_LOADING_REMOTE_ENTRY__')) {
+    Object.defineProperty(globalThis, '__GLOBAL_LOADING_REMOTE_ENTRY__', {
+        value: {},
+        configurable: false
+    });
+}
+const globalLoading = globalThis.__GLOBAL_LOADING_REMOTE_ENTRY__;
+//
+if (nativeGlobal.__VMOK__) {
+    nativeGlobal.__FEDERATION__ = nativeGlobal.__VMOK__;
+} else if (!nativeGlobal.__FEDERATION__) {
+    nativeGlobal.__FEDERATION__ = {
+        __GLOBAL_PLUGIN__: [],
+        __INSTANCES__: [],
+        moduleInfo: {},
+        __SHARE__: {},
+        __MANIFEST_LOADING__: {},
+        __SHARE_SCOPE_LOADING__: {},
+        __PRELOADED_MAP__: new Map()
+    };
+    nativeGlobal.__VMOK__ = nativeGlobal.__FEDERATION__;
+}
+var ___GLOBAL_PLUGIN__;
+(___GLOBAL_PLUGIN__ = (_nativeGlobal___FEDERATION__ = nativeGlobal.__FEDERATION__).__GLOBAL_PLUGIN__) != null ? ___GLOBAL_PLUGIN__ : _nativeGlobal___FEDERATION__.__GLOBAL_PLUGIN__ = [];
+var ___INSTANCES__;
+(___INSTANCES__ = (_nativeGlobal___FEDERATION__1 = nativeGlobal.__FEDERATION__).__INSTANCES__) != null ? ___INSTANCES__ : _nativeGlobal___FEDERATION__1.__INSTANCES__ = [];
+var _moduleInfo;
+(_moduleInfo = (_nativeGlobal___FEDERATION__2 = nativeGlobal.__FEDERATION__).moduleInfo) != null ? _moduleInfo : _nativeGlobal___FEDERATION__2.moduleInfo = {};
+var ___SHARE__;
+(___SHARE__ = (_nativeGlobal___FEDERATION__3 = nativeGlobal.__FEDERATION__).__SHARE__) != null ? ___SHARE__ : _nativeGlobal___FEDERATION__3.__SHARE__ = {};
+var ___MANIFEST_LOADING__;
+(___MANIFEST_LOADING__ = (_nativeGlobal___FEDERATION__4 = nativeGlobal.__FEDERATION__).__MANIFEST_LOADING__) != null ? ___MANIFEST_LOADING__ : _nativeGlobal___FEDERATION__4.__MANIFEST_LOADING__ = {};
+var ___SHARE_SCOPE_LOADING__;
+(___SHARE_SCOPE_LOADING__ = (_nativeGlobal___FEDERATION__5 = nativeGlobal.__FEDERATION__).__SHARE_SCOPE_LOADING__) != null ? ___SHARE_SCOPE_LOADING__ : _nativeGlobal___FEDERATION__5.__SHARE_SCOPE_LOADING__ = {};
+var ___PRELOADED_MAP__;
+(___PRELOADED_MAP__ = (_nativeGlobal___FEDERATION__6 = nativeGlobal.__FEDERATION__).__PRELOADED_MAP__) != null ? ___PRELOADED_MAP__ : _nativeGlobal___FEDERATION__6.__PRELOADED_MAP__ = new Map();
+const Global = {
+    get __FEDERATION__ () {
+        const globalThisVal = new Function('return globalThis')();
+        return globalThisVal.__FEDERATION__;
+    }
+};
+function resetFederationGlobalInfo() {
+    nativeGlobal.__FEDERATION__.__GLOBAL_PLUGIN__ = [];
+    nativeGlobal.__FEDERATION__.__INSTANCES__ = [];
+    nativeGlobal.__FEDERATION__.moduleInfo = {};
+    nativeGlobal.__FEDERATION__.__SHARE__ = {};
+    nativeGlobal.__FEDERATION__.__MANIFEST_LOADING__ = {};
+    nativeGlobal.__FEDERATION__.__SHARE_SCOPE_LOADING__ = {};
+}
+function getGlobalFederationInstance(name, version) {
+    const buildId = getBuilderId();
+    return Global.__FEDERATION__.__INSTANCES__.find((GMInstance)=>{
+        if (buildId && GMInstance.options.id === getBuilderId()) {
+            return true;
+        }
+        if (GMInstance.options.name === name && !version) {
+            return true;
+        }
+        if (GMInstance.options.name === name && version && GMInstance.options.version === version) {
+            return true;
+        }
+        return false;
+    });
+}
+function setGlobalFederationInstance(FederationInstance) {
+    Global.__FEDERATION__.__INSTANCES__.push(FederationInstance);
+}
+function getGlobalFederationConstructor() {
+    return Global.__FEDERATION__.__DEBUG_CONSTRUCTOR__;
+}
+function setGlobalFederationConstructor(FederationConstructor) {
+    if (isDebugMode()) {
+        Global.__FEDERATION__.__DEBUG_CONSTRUCTOR__ = FederationConstructor;
+        Global.__FEDERATION__.__DEBUG_CONSTRUCTOR_VERSION__ = '0.0.1';
+    }
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+function getInfoWithoutType(target, key, getModuleInfoHook) {
+    let res;
+    if (target[key]) {
+        res = {
+            value: target[key],
+            key: key
+        };
+    } else {
+        res = {
+            value: undefined,
+            key: key
+        };
+    }
+    if (getModuleInfoHook) {
+        const hookRes = getModuleInfoHook(target, key);
+        res = hookRes || res;
+    }
+    return res;
+}
+const getGlobalSnapshot = ()=>Global.__FEDERATION__.moduleInfo;
+const getTargetSnapshotInfoByModuleInfo = (moduleInfo, snapshot, getModuleInfoHook)=>{
+    // remote include in hostSnapshot
+    const moduleKey = getFMId(moduleInfo);
+    const getModuleInfo = getInfoWithoutType(snapshot, moduleKey, getModuleInfoHook).value;
+    // remoteSnapshot may don't include version
+    if (getModuleInfo && !getModuleInfo.version && 'version' in moduleInfo && moduleInfo['version']) {
+        getModuleInfo.version = moduleInfo['version'];
+    }
+    if (getModuleInfo) {
+        return getModuleInfo;
+    }
+    // remote don't include in hostSnapshot
+    // deploy micro app snapshot
+    if ('version' in moduleInfo && moduleInfo['version']) {
+        const { version } = moduleInfo, resModuleInfo = _object_without_properties_loose(moduleInfo, [
+            "version"
+        ]);
+        const moduleKeyWithoutVersion = getFMId(resModuleInfo);
+        const getModuleInfoWithoutVersion = getInfoWithoutType(Global.__FEDERATION__.moduleInfo, moduleKeyWithoutVersion, getModuleInfoHook).value;
+        if ((getModuleInfoWithoutVersion == null ? void 0 : getModuleInfoWithoutVersion.version) === version) {
+            return getModuleInfoWithoutVersion;
+        }
+    }
+    return;
+};
+const getGlobalSnapshotInfoByModuleInfo = (moduleInfo, extraOptions)=>getTargetSnapshotInfoByModuleInfo(moduleInfo, Global.__FEDERATION__.moduleInfo, extraOptions == null ? void 0 : extraOptions.getModuleInfoHook);
+const setGlobalSnapshotInfoByModuleInfo = (remoteInfo, moduleDetailInfo)=>{
+    const moduleKey = getFMId(remoteInfo);
+    Global.__FEDERATION__.moduleInfo[moduleKey] = moduleDetailInfo;
+    return Global.__FEDERATION__.moduleInfo;
+};
+const addGlobalSnapshot = (moduleInfos)=>{
+    Global.__FEDERATION__.moduleInfo = _extends({}, Global.__FEDERATION__.moduleInfo, moduleInfos);
+    return ()=>{
+        Object.keys(moduleInfos).forEach((key)=>{
+            delete Global.__FEDERATION__.moduleInfo[key];
+        });
+    };
+};
+const getRemoteEntryExports = (name, globalName)=>{
+    const remoteEntryKey = globalName || `__FEDERATION_${name}:custom__`;
+    const entryExports = globalThis[remoteEntryKey];
+    return {
+        remoteEntryKey,
+        entryExports
+    };
+};
+// global hooks
+const registerGlobalPlugins = (plugins)=>{
+    const { __GLOBAL_PLUGIN__ } = Global.__FEDERATION__;
+    plugins.forEach((plugin)=>{
+        if (__GLOBAL_PLUGIN__.findIndex((p)=>p.name === plugin.name) === -1) {
+            __GLOBAL_PLUGIN__.push(plugin);
+        } else {
+            warn(`The plugin ${plugin.name} has been registered.`);
+        }
+    });
+};
+const getGlobalHostPlugins = ()=>Global.__FEDERATION__.__GLOBAL_PLUGIN__;
+const getPreloaded = (id)=>Global.__FEDERATION__.__PRELOADED_MAP__.get(id);
+const setPreloaded = (id)=>Global.__FEDERATION__.__PRELOADED_MAP__.set(id, true);
+
+const DEFAULT_SCOPE = 'default';
+const DEFAULT_REMOTE_TYPE = 'global';
+
+// those constants are based on https://www.rubydoc.info/gems/semantic_range/3.0.0/SemanticRange#BUILDIDENTIFIER-constant
+const buildIdentifier = '[0-9A-Za-z-]+';
+const build = `(?:\\+(${buildIdentifier}(?:\\.${buildIdentifier})*))`;
+const numericIdentifier = '0|[1-9]\\d*';
+const numericIdentifierLoose = '[0-9]+';
+const nonNumericIdentifier = '\\d*[a-zA-Z-][a-zA-Z0-9-]*';
+const preReleaseIdentifierLoose = `(?:${numericIdentifierLoose}|${nonNumericIdentifier})`;
+const preReleaseLoose = `(?:-?(${preReleaseIdentifierLoose}(?:\\.${preReleaseIdentifierLoose})*))`;
+const preReleaseIdentifier = `(?:${numericIdentifier}|${nonNumericIdentifier})`;
+const preRelease = `(?:-(${preReleaseIdentifier}(?:\\.${preReleaseIdentifier})*))`;
+const xRangeIdentifier = `${numericIdentifier}|x|X|\\*`;
+const xRangePlain = `[v=\\s]*(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:\\.(${xRangeIdentifier})(?:${preRelease})?${build}?)?)?`;
+const hyphenRange = `^\\s*(${xRangePlain})\\s+-\\s+(${xRangePlain})\\s*$`;
+const mainVersionLoose = `(${numericIdentifierLoose})\\.(${numericIdentifierLoose})\\.(${numericIdentifierLoose})`;
+const loosePlain = `[v=\\s]*${mainVersionLoose}${preReleaseLoose}?${build}?`;
+const gtlt = '((?:<|>)?=?)';
+const comparatorTrim = `(\\s*)${gtlt}\\s*(${loosePlain}|${xRangePlain})`;
+const loneTilde = '(?:~>?)';
+const tildeTrim = `(\\s*)${loneTilde}\\s+`;
+const loneCaret = '(?:\\^)';
+const caretTrim = `(\\s*)${loneCaret}\\s+`;
+const star = '(<|>)?=?\\s*\\*';
+const caret = `^${loneCaret}${xRangePlain}$`;
+const mainVersion = `(${numericIdentifier})\\.(${numericIdentifier})\\.(${numericIdentifier})`;
+const fullPlain = `v?${mainVersion}${preRelease}?${build}?`;
+const tilde = `^${loneTilde}${xRangePlain}$`;
+const xRange = `^${gtlt}\\s*${xRangePlain}$`;
+const comparator = `^${gtlt}\\s*(${fullPlain})$|^$`;
+// copy from semver package
+const gte0 = '^\\s*>=\\s*0.0.0\\s*$';
+
+function parseRegex(source) {
+    return new RegExp(source);
+}
+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(parseRegex(comparator));
+}
+function combineVersion(major, minor, patch, preRelease) {
+    const mainVersion = `${major}.${minor}.${patch}`;
+    if (preRelease) {
+        return `${mainVersion}-${preRelease}`;
+    }
+    return mainVersion;
+}
+
+function parseHyphen(range) {
+    return range.replace(parseRegex(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 = `<${Number(toMajor) + 1}.0.0-0`;
+        } else if (isXVersion(toPatch)) {
+            to = `<${toMajor}.${Number(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(parseRegex(comparatorTrim), '$1$2$3');
+}
+function parseTildeTrim(range) {
+    return range.replace(parseRegex(tildeTrim), '$1~');
+}
+function parseCaretTrim(range) {
+    return range.replace(parseRegex(caretTrim), '$1^');
+}
+function parseCarets(range) {
+    return range.trim().split(/\s+/).map((rangeVersion)=>rangeVersion.replace(parseRegex(caret), (_, major, minor, patch, preRelease)=>{
+            if (isXVersion(major)) {
+                return '';
+            } else if (isXVersion(minor)) {
+                return `>=${major}.0.0 <${Number(major) + 1}.0.0-0`;
+            } else if (isXVersion(patch)) {
+                if (major === '0') {
+                    return `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0-0`;
+                } else {
+                    return `>=${major}.${minor}.0 <${Number(major) + 1}.0.0-0`;
+                }
+            } else if (preRelease) {
+                if (major === '0') {
+                    if (minor === '0') {
+                        return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${minor}.${Number(patch) + 1}-0`;
+                    } else {
+                        return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${Number(minor) + 1}.0-0`;
+                    }
+                } else {
+                    return `>=${major}.${minor}.${patch}-${preRelease} <${Number(major) + 1}.0.0-0`;
+                }
+            } else {
+                if (major === '0') {
+                    if (minor === '0') {
+                        return `>=${major}.${minor}.${patch} <${major}.${minor}.${Number(patch) + 1}-0`;
+                    } else {
+                        return `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
+                    }
+                }
+                return `>=${major}.${minor}.${patch} <${Number(major) + 1}.0.0-0`;
+            }
+        })).join(' ');
+}
+function parseTildes(range) {
+    return range.trim().split(/\s+/).map((rangeVersion)=>rangeVersion.replace(parseRegex(tilde), (_, major, minor, patch, preRelease)=>{
+            if (isXVersion(major)) {
+                return '';
+            } else if (isXVersion(minor)) {
+                return `>=${major}.0.0 <${Number(major) + 1}.0.0-0`;
+            } else if (isXVersion(patch)) {
+                return `>=${major}.${minor}.0 <${major}.${Number(minor) + 1}.0-0`;
+            } else if (preRelease) {
+                return `>=${major}.${minor}.${patch}-${preRelease} <${major}.${Number(minor) + 1}.0-0`;
+            }
+            return `>=${major}.${minor}.${patch} <${major}.${Number(minor) + 1}.0-0`;
+        })).join(' ');
+}
+function parseXRanges(range) {
+    return range.split(/\s+/).map((rangeVersion)=>rangeVersion.trim().replace(parseRegex(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 === '<') {
+                    // nothing is allowed
+                    return '<0.0.0-0';
+                } else {
+                    // nothing is forbidden
+                    return '*';
+                }
+            } else if (gtlt && isXPatch) {
+                // replace X with 0
+                if (isXMinor) {
+                    minor = 0;
+                }
+                patch = 0;
+                if (gtlt === '>') {
+                    // >1 => >=2.0.0
+                    // >1.2 => >=1.3.0
+                    gtlt = '>=';
+                    if (isXMinor) {
+                        major = Number(major) + 1;
+                        minor = 0;
+                        patch = 0;
+                    } else {
+                        minor = Number(minor) + 1;
+                        patch = 0;
+                    }
+                } else if (gtlt === '<=') {
+                    // <=0.7.x is actually <0.8.0, since any 0.7.x should pass
+                    // Similarly, <=7.x is actually <8.0.0, etc.
+                    gtlt = '<';
+                    if (isXMinor) {
+                        major = Number(major) + 1;
+                    } else {
+                        minor = Number(minor) + 1;
+                    }
+                }
+                if (gtlt === '<') {
+                    preRelease = '-0';
+                }
+                return `${gtlt + major}.${minor}.${patch}${preRelease}`;
+            } else if (isXMinor) {
+                return `>=${major}.0.0${preRelease} <${Number(major) + 1}.0.0-0`;
+            } else if (isXPatch) {
+                return `>=${major}.${minor}.0${preRelease} <${major}.${Number(minor) + 1}.0-0`;
+            }
+            return ret;
+        })).join(' ');
+}
+function parseStar(range) {
+    return range.trim().replace(parseRegex(star), '');
+}
+function parseGTE0(comparatorString) {
+    return comparatorString.trim().replace(parseRegex(gte0), '');
+}
+
+function compareAtom(rangeAtom, versionAtom) {
+    rangeAtom = Number(rangeAtom) || rangeAtom;
+    versionAtom = Number(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 === undefined && Boolean(versionPreRelease)) {
+        return 1;
+    }
+    if (Boolean(rangePreRelease) && versionPreRelease === undefined) {
+        return -1;
+    }
+    if (rangePreRelease === undefined && versionPreRelease === undefined) {
+        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 === undefined && versionElement === undefined) {
+            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 undefined:
+            {
+                // mean * or x -> all versions
+                return true;
+            }
+        default:
+            return false;
+    }
+}
+
+// fork from https://github.com/originjs/vite-plugin-federation/blob/v1.1.12/packages/lib/src/utils/semver/index.ts
+function parseComparatorString(range) {
+    return pipe(// handle caret
+    // ^ --> * (any, kinda silly)
+    // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+    // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+    // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+    // ^1.2.3 --> >=1.2.3 <2.0.0-0
+    // ^1.2.0 --> >=1.2.0 <2.0.0-0
+    parseCarets, // handle tilde
+    // ~, ~> --> * (any, kinda silly)
+    // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+    // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+    // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+    // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+    // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+    parseTildes, parseXRanges, parseStar)(range);
+}
+function parseRange(range) {
+    return pipe(// handle hyphenRange
+    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+    parseHyphen, // handle trim comparator
+    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+    parseComparatorTrim, // handle trim tilde
+    // `~ 1.2.3` => `~1.2.3`
+    parseTildeTrim, // handle trim caret
+    // `^ 1.2.3` => `^1.2.3`
+    parseCaretTrim)(range.trim()).split(/\s+/).join(' ');
+}
+function satisfy(version, range) {
+    if (!version) {
+        return false;
+    }
+    const parsedRange = parseRange(range);
+    const parsedComparator = parsedRange.split(' ').map((rangeVersion)=>parseComparatorString(rangeVersion)).join(' ');
+    const comparators = parsedComparator.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 == null ? void 0 : versionPreRelease.split('.')
+    };
+    for (const comparator of comparators){
+        const extractedComparator = extractComparator(comparator);
+        if (!extractedComparator) {
+            return false;
+        }
+        const [, rangeOperator, , rangeMajor, rangeMinor, rangePatch, rangePreRelease] = extractedComparator;
+        const rangeAtom = {
+            operator: rangeOperator,
+            version: combineVersion(rangeMajor, rangeMinor, rangePatch, rangePreRelease),
+            major: rangeMajor,
+            minor: rangeMinor,
+            patch: rangePatch,
+            preRelease: rangePreRelease == null ? void 0 : rangePreRelease.split('.')
+        };
+        if (!compare(rangeAtom, versionAtom)) {
+            return false; // early return
+        }
+    }
+    return true;
+}
+
+function formatShare(shareArgs, from) {
+    let get;
+    if ('get' in shareArgs) {
+        // eslint-disable-next-line prefer-destructuring
+        get = shareArgs.get;
+    } else {
+        // @ts-ignore ignore
+        get = ()=>Promise.resolve(shareArgs.lib);
+    }
+    return _extends({
+        deps: [],
+        useIn: [],
+        from,
+        shareConfig: {
+            requiredVersion: `^${shareArgs.version}`,
+            singleton: false,
+            eager: false
+        },
+        loading: null
+    }, shareArgs, {
+        get,
+        scope: Array.isArray(shareArgs.scope) ? shareArgs.scope : [
+            'default'
+        ],
+        strategy: shareArgs.strategy || 'version-first'
+    });
+}
+function formatShareConfigs(shareArgs, from) {
+    if (!shareArgs) {
+        return {};
+    }
+    return Object.keys(shareArgs).reduce((res, pkgName)=>{
+        res[pkgName] = formatShare(shareArgs[pkgName], from);
+        return res;
+    }, {});
+}
+function versionLt(a, b) {
+    if (satisfy(a, `<=${b}`)) {
+        return true;
+    } else {
+        return false;
+    }
+}
+const findVersion = (scope, pkgName, cb)=>{
+    const globalShares = Global.__FEDERATION__.__SHARE__;
+    const versions = globalShares[scope][pkgName];
+    const callback = cb || function(prev, cur) {
+        return versionLt(prev, cur);
+    };
+    return Object.keys(versions).reduce((prev, cur)=>{
+        if (!prev) {
+            return cur;
+        }
+        if (callback(prev, cur)) {
+            return cur;
+        }
+        return prev;
+    }, 0);
+};
+function findSingletonVersionOrderByVersion(scope, pkgName) {
+    const globalShares = Global.__FEDERATION__.__SHARE__;
+    const versions = globalShares[scope][pkgName];
+    const callback = function(prev, cur) {
+        return !versions[prev].loaded && versionLt(prev, cur);
+    };
+    return findVersion(scope, pkgName, callback);
+}
+function findSingletonVersionOrderByLoaded(scope, pkgName) {
+    const globalShares = Global.__FEDERATION__.__SHARE__;
+    const versions = globalShares[scope][pkgName];
+    const callback = function(prev, cur) {
+        if (versions[cur].loaded) {
+            if (versions[prev].loaded) {
+                return Boolean(versionLt(prev, cur));
+            } else {
+                return true;
+            }
+        }
+        if (versions[prev].loaded) {
+            return false;
+        }
+        return versionLt(prev, cur);
+    };
+    return findVersion(scope, pkgName, callback);
+}
+// Information about sharing
+// TODO: Add strictVersion for consistency with mf.
+function getGlobalShare(pkgName, shareInfo) {
+    const globalShares = Global.__FEDERATION__.__SHARE__;
+    const { shareConfig, scope = DEFAULT_SCOPE, strategy } = shareInfo;
+    const scopes = Array.isArray(scope) ? scope : [
+        scope
+    ];
+    for (const sc of scopes){
+        if (shareConfig && globalShares[sc] && globalShares[sc][pkgName]) {
+            const { requiredVersion } = shareConfig;
+            // eslint-disable-next-line max-depth
+            if (shareConfig.singleton) {
+                const singletonVersion = strategy === 'loaded-first' ? findSingletonVersionOrderByLoaded(sc, pkgName) : findSingletonVersionOrderByVersion(sc, pkgName);
+                // eslint-disable-next-line max-depth
+                if (typeof requiredVersion === 'string' && !satisfy(singletonVersion, requiredVersion)) {
+                    warn(`Unsatisfied version ${singletonVersion} from ${singletonVersion && globalShares[sc][pkgName][singletonVersion].from} of shared singleton module ${pkgName} (${shareInfo.from} required ${requiredVersion})`);
+                }
+                return globalShares[sc][pkgName][singletonVersion];
+            } else {
+                const maxVersion = findSingletonVersionOrderByLoaded(sc, pkgName);
+                // eslint-disable-next-line max-depth
+                if (requiredVersion === false || requiredVersion === '*') {
+                    return globalShares[sc][pkgName][maxVersion];
+                }
+                // eslint-disable-next-line max-depth
+                if (satisfy(maxVersion, requiredVersion)) {
+                    return globalShares[sc][pkgName][maxVersion];
+                }
+                // eslint-disable-next-line max-depth
+                for (const [versionKey, versionValue] of Object.entries(globalShares[sc][pkgName])){
+                    // eslint-disable-next-line max-depth
+                    if (satisfy(versionKey, requiredVersion)) {
+                        return versionValue;
+                    }
+                }
+            }
+        }
+    }
+}
+function getGlobalShareScope() {
+    return Global.__FEDERATION__.__SHARE__;
+}
+
+export { _object_without_properties_loose as A, getBuilderId as B, setGlobalFederationConstructor as C, DEFAULT_REMOTE_TYPE as D, getGlobalFederationInstance as E, getGlobalFederationConstructor as F, Global as G, setGlobalFederationInstance as H, registerGlobalPlugins as I, nativeGlobal as J, resetFederationGlobalInfo as K, getTargetSnapshotInfoByModuleInfo as L, addGlobalSnapshot as M, _extends as _, DEFAULT_SCOPE as a, globalLoading as b, getRemoteEntryExports as c, assert as d, safeToString as e, getFMId as f, getGlobalHostPlugins as g, isObject as h, isStaticResourcesEqual as i, error as j, isPlainObject as k, isRemoteInfoWithEntry as l, isPureRemoteEntry as m, getGlobalShare as n, getInfoWithoutType as o, getPreloaded as p, setPreloaded as q, getGlobalSnapshotInfoByModuleInfo as r, safeWrapper as s, setGlobalSnapshotInfoByModuleInfo as t, getGlobalSnapshot as u, addUniqueItem as v, warn as w, formatShareConfigs as x, isBrowserEnv as y, getGlobalShareScope as z };