xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/harmony/HarmonyExportImportedSpecifierDependency.js

@@ -0,0 +1,763 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HarmonyStarExportsList = exports.HarmonyExportImportedSpecifierDependency = void 0;
+const Dependency_1 = __importDefault(require("@/dependencies/Dependency"));
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const HarmonyLinkingError_1 = __importDefault(require("@/base/errors/HarmonyLinkingError"));
+const InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const IterableHelpers_1 = require("@/base/IterableHelpers");
+const SetHelpers_1 = require("@/base/SetHelpers");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const propertyName_1 = require("@/base/propertyName");
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const processExportInfo_1 = __importDefault(require("@/dependencies/processExportInfo"));
+const HarmonyExportInitFragment_1 = __importDefault(require("./HarmonyExportInitFragment"));
+const HarmonyImportDependency_1 = require("./HarmonyImportDependency");
+const idsSymbol = Symbol('HarmonyExportImportedSpecifierDependency.ids');
+class NormalReexportItem {
+    constructor(name, ids, exportInfo, checked, hidden) {
+        this.name = name;
+        this.ids = ids;
+        this.exportInfo = exportInfo;
+        this.checked = checked;
+        this.hidden = hidden;
+    }
+}
+class ExportMode {
+    constructor(type) {
+        this.type = type;
+        // for "normal-reexport":
+        this.items = null;
+        // for "reexport-named-default" | "reexport-fake-namespace-object" | "reexport-namespace-object"
+        this.name = null;
+        this.partialNamespaceExportInfo = null;
+        // for "dynamic-reexport":
+        this.ignored = null;
+        // for "dynamic-reexport" | "empty-star":
+        this.hidden = null;
+        // for "missing":
+        this.userRequest = null;
+        // for "reexport-fake-namespace-object":
+        this.fakeType = 0;
+    }
+}
+const determineExportAssignments = (moduleGraph, dependencies, additionalDependency) => {
+    const names = new Set();
+    const dependencyIndices = [];
+    if (additionalDependency) {
+        dependencies = dependencies.concat(additionalDependency);
+    }
+    for (const dep of dependencies) {
+        const i = dependencyIndices.length;
+        dependencyIndices[i] = names.size;
+        const otherImportedModule = moduleGraph.getModule(dep);
+        if (otherImportedModule) {
+            const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
+            for (const exportInfo of exportsInfo.exports) {
+                if (exportInfo.provided === true &&
+                    exportInfo.name !== 'default' &&
+                    !names.has(exportInfo.name)) {
+                    names.add(exportInfo.name);
+                    dependencyIndices[i] = names.size;
+                }
+            }
+        }
+    }
+    dependencyIndices.push(names.size);
+    return { names: Array.from(names), dependencyIndices };
+};
+const findDependencyForName = ({ names, dependencyIndices }, name, dependencies) => {
+    const dependenciesIt = dependencies[Symbol.iterator]();
+    const dependencyIndicesIt = dependencyIndices[Symbol.iterator]();
+    let dependenciesItResult = dependenciesIt.next();
+    let dependencyIndicesItResult = dependencyIndicesIt.next();
+    if (dependencyIndicesItResult.done)
+        return;
+    for (let i = 0; i < names.length; i++) {
+        while (i >= dependencyIndicesItResult.value) {
+            dependenciesItResult = dependenciesIt.next();
+            dependencyIndicesItResult = dependencyIndicesIt.next();
+            if (dependencyIndicesItResult.done)
+                return;
+        }
+        if (names[i] === name)
+            return dependenciesItResult.value;
+    }
+    return undefined;
+};
+const getMode = (moduleGraph, dep, runtimeKey) => {
+    const importedModule = moduleGraph.getModule(dep);
+    if (!importedModule) {
+        const mode = new ExportMode('missing');
+        mode.userRequest = dep.userRequest;
+        return mode;
+    }
+    const name = dep.name;
+    const runtime = (0, RuntimeHelpers_1.keyToRuntime)(runtimeKey);
+    const parentModule = moduleGraph.getParentModule(dep);
+    const exportsInfo = moduleGraph.getExportsInfo(parentModule);
+    if (name
+        ? exportsInfo.getUsed(name, runtime) === ExportsInfo_1.UsageState.Unused
+        : exportsInfo.isUsed(runtime) === false) {
+        const mode = new ExportMode('unused');
+        mode.name = name || '*';
+        return mode;
+    }
+    const importedExportsType = importedModule.getExportsType(moduleGraph, parentModule.buildMeta.strictHarmonyModule);
+    const ids = dep.getIds(moduleGraph);
+    // Special handling for reexporting the default export
+    // from non-namespace modules
+    if (name && ids.length > 0 && ids[0] === 'default') {
+        switch (importedExportsType) {
+            case 'dynamic': {
+                const mode = new ExportMode('reexport-dynamic-default');
+                mode.name = name;
+                return mode;
+            }
+            case 'default-only':
+            case 'default-with-named': {
+                const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+                const mode = new ExportMode('reexport-named-default');
+                mode.name = name;
+                mode.partialNamespaceExportInfo = exportInfo;
+                return mode;
+            }
+        }
+    }
+    // reexporting with a fixed name
+    if (name) {
+        let mode;
+        const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+        if (ids.length > 0) {
+            // export { name as name }
+            switch (importedExportsType) {
+                case 'default-only':
+                    mode = new ExportMode('reexport-undefined');
+                    mode.name = name;
+                    break;
+                default:
+                    mode = new ExportMode('normal-reexport');
+                    mode.items = [new NormalReexportItem(name, ids, exportInfo, false, false)];
+                    break;
+            }
+        }
+        else {
+            // export * as name
+            switch (importedExportsType) {
+                case 'default-only':
+                    mode = new ExportMode('reexport-fake-namespace-object');
+                    mode.name = name;
+                    mode.partialNamespaceExportInfo = exportInfo;
+                    mode.fakeType = 0;
+                    break;
+                case 'default-with-named':
+                    mode = new ExportMode('reexport-fake-namespace-object');
+                    mode.name = name;
+                    mode.partialNamespaceExportInfo = exportInfo;
+                    mode.fakeType = 2;
+                    break;
+                case 'dynamic':
+                default:
+                    mode = new ExportMode('reexport-namespace-object');
+                    mode.name = name;
+                    mode.partialNamespaceExportInfo = exportInfo;
+            }
+        }
+        return mode;
+    }
+    // Star reexporting
+    const { ignoredExports, exports, checked, hidden } = dep.getStarReexports(moduleGraph, runtime, exportsInfo, importedModule);
+    if (!exports) {
+        // We have too few info about the modules
+        // Delegate the logic to the runtime code
+        const mode = new ExportMode('dynamic-reexport');
+        mode.ignored = ignoredExports;
+        mode.hidden = hidden;
+        return mode;
+    }
+    if (exports.size === 0) {
+        const mode = new ExportMode('empty-star');
+        mode.hidden = hidden;
+        return mode;
+    }
+    const mode = new ExportMode('normal-reexport');
+    mode.items = Array.from(exports, (exportName) => new NormalReexportItem(exportName, [exportName], exportsInfo.getReadOnlyExportInfo(exportName), checked.has(exportName), false));
+    if (hidden !== undefined) {
+        for (const exportName of hidden) {
+            mode.items.push(new NormalReexportItem(exportName, [exportName], exportsInfo.getReadOnlyExportInfo(exportName), false, true));
+        }
+    }
+    return mode;
+};
+class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency_1.HarmonyImportDependency {
+    constructor(request, sourceOrder, ids, name, activeExports, otherStarExports, exportPresenceMode, allStarExports, assertions) {
+        super(request, sourceOrder, assertions);
+        this.ids = ids;
+        this.name = name;
+        this.activeExports = activeExports;
+        this.otherStarExports = otherStarExports;
+        this.exportPresenceMode = exportPresenceMode;
+        this.allStarExports = allStarExports;
+    }
+    couldAffectReferencingModule() {
+        return Dependency_1.default.TRANSITIVE;
+    }
+    // TODO webpack 6 remove
+    get id() {
+        throw new Error('id was renamed to ids and type changed to string[]');
+    }
+    // TODO webpack 6 remove
+    getId() {
+        throw new Error('id was renamed to ids and type changed to string[]');
+    }
+    // TODO webpack 6 remove
+    setId() {
+        throw new Error('id was renamed to ids and type changed to string[]');
+    }
+    get type() {
+        return 'harmony export imported specifier';
+    }
+    getIds(moduleGraph) {
+        return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+    }
+    setIds(moduleGraph, ids) {
+        moduleGraph.getMeta(this)[idsSymbol] = ids;
+    }
+    getMode(moduleGraph, runtime) {
+        return moduleGraph.dependencyCacheProvide(this, (0, RuntimeHelpers_1.getRuntimeKey)(runtime), getMode);
+    }
+    getStarReexports(moduleGraph, runtime, exportsInfo = moduleGraph.getExportsInfo(moduleGraph.getParentModule(this)), importedModule = moduleGraph.getModule(this)) {
+        const importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
+        const noExtraExports = importedExportsInfo.otherExportsInfo.provided === false;
+        const noExtraImports = exportsInfo.otherExportsInfo.getUsed(runtime) === ExportsInfo_1.UsageState.Unused;
+        const ignoredExports = new Set(['default', ...this.activeExports]);
+        let hiddenExports;
+        const otherStarExports = this._discoverActiveExportsFromOtherStarExports(moduleGraph);
+        if (otherStarExports !== undefined) {
+            hiddenExports = new Set();
+            for (let i = 0; i < otherStarExports.namesSlice; i++) {
+                hiddenExports.add(otherStarExports.names[i]);
+            }
+            for (const e of ignoredExports)
+                hiddenExports.delete(e);
+        }
+        if (!noExtraExports && !noExtraImports) {
+            return {
+                ignoredExports,
+                hidden: hiddenExports,
+            };
+        }
+        const exports = new Set();
+        const checked = new Set();
+        const hidden = hiddenExports !== undefined ? new Set() : undefined;
+        if (noExtraImports) {
+            for (const exportInfo of exportsInfo.orderedExports) {
+                const name = exportInfo.name;
+                if (ignoredExports.has(name))
+                    continue;
+                if (exportInfo.getUsed(runtime) === ExportsInfo_1.UsageState.Unused)
+                    continue;
+                const importedExportInfo = importedExportsInfo.getReadOnlyExportInfo(name);
+                if (importedExportInfo.provided === false)
+                    continue;
+                if (hiddenExports === null || hiddenExports === void 0 ? void 0 : hiddenExports.has(name)) {
+                    hidden.add(name);
+                    continue;
+                }
+                exports.add(name);
+                if (importedExportInfo.provided === true)
+                    continue;
+                checked.add(name);
+            }
+        }
+        else if (noExtraExports) {
+            for (const importedExportInfo of importedExportsInfo.orderedExports) {
+                const name = importedExportInfo.name;
+                if (ignoredExports.has(name))
+                    continue;
+                if (importedExportInfo.provided === false)
+                    continue;
+                const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+                if (exportInfo.getUsed(runtime) === ExportsInfo_1.UsageState.Unused)
+                    continue;
+                if (hiddenExports === null || hiddenExports === void 0 ? void 0 : hiddenExports.has(name)) {
+                    hidden.add(name);
+                    continue;
+                }
+                exports.add(name);
+                if (importedExportInfo.provided === true)
+                    continue;
+                checked.add(name);
+            }
+        }
+        return { ignoredExports, exports, checked, hidden };
+    }
+    getCondition(moduleGraph) {
+        return (connection, runtime) => {
+            const mode = this.getMode(moduleGraph, runtime);
+            return mode.type !== 'unused' && mode.type !== 'empty-star';
+        };
+    }
+    getModuleEvaluationSideEffectsState(moduleGraph) {
+        return false;
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        const mode = this.getMode(moduleGraph, runtime);
+        switch (mode.type) {
+            case 'missing':
+            case 'unused':
+            case 'empty-star':
+            case 'reexport-undefined':
+                return Dependency_1.default.NO_EXPORTS_REFERENCED;
+            case 'reexport-dynamic-default':
+                return Dependency_1.default.EXPORTS_OBJECT_REFERENCED;
+            case 'reexport-named-default': {
+                if (!mode.partialNamespaceExportInfo)
+                    return Dependency_1.default.EXPORTS_OBJECT_REFERENCED;
+                const referencedExports = [];
+                (0, processExportInfo_1.default)(runtime, referencedExports, [], mode.partialNamespaceExportInfo);
+                return referencedExports;
+            }
+            case 'reexport-namespace-object':
+            case 'reexport-fake-namespace-object': {
+                if (!mode.partialNamespaceExportInfo)
+                    return Dependency_1.default.EXPORTS_OBJECT_REFERENCED;
+                const referencedExports = [];
+                (0, processExportInfo_1.default)(runtime, referencedExports, [], mode.partialNamespaceExportInfo, mode.type === 'reexport-fake-namespace-object');
+                return referencedExports;
+            }
+            case 'dynamic-reexport':
+                return Dependency_1.default.EXPORTS_OBJECT_REFERENCED;
+            case 'normal-reexport': {
+                const referencedExports = [];
+                for (const { ids, exportInfo, hidden } of mode.items) {
+                    if (hidden)
+                        continue;
+                    (0, processExportInfo_1.default)(runtime, referencedExports, ids, exportInfo, false);
+                }
+                return referencedExports;
+            }
+            default:
+                throw new Error(`Unknown mode ${mode.type}`);
+        }
+    }
+    _discoverActiveExportsFromOtherStarExports(moduleGraph) {
+        if (!this.otherStarExports)
+            return undefined;
+        const i = 'length' in this.otherStarExports
+            ? this.otherStarExports.length
+            : (0, IterableHelpers_1.countIterable)(this.otherStarExports);
+        if (i === 0)
+            return undefined;
+        if (this.allStarExports) {
+            const { names, dependencyIndices } = moduleGraph.cached(determineExportAssignments, this.allStarExports.dependencies);
+            return {
+                names,
+                namesSlice: dependencyIndices[i - 1],
+                dependencyIndices,
+                dependencyIndex: i,
+            };
+        }
+        const { names, dependencyIndices } = moduleGraph.cached(determineExportAssignments, this.otherStarExports, this);
+        return {
+            names,
+            namesSlice: dependencyIndices[i - 1],
+            dependencyIndices,
+            dependencyIndex: i,
+        };
+    }
+    getExports(moduleGraph) {
+        const mode = this.getMode(moduleGraph, undefined);
+        switch (mode.type) {
+            case 'missing':
+                return undefined;
+            case 'dynamic-reexport': {
+                const from = moduleGraph.getConnection(this);
+                return {
+                    exports: true,
+                    from,
+                    canMangle: false,
+                    excludeExports: mode.hidden ? (0, SetHelpers_1.combine)(mode.ignored, mode.hidden) : mode.ignored,
+                    hideExports: mode.hidden,
+                    dependencies: [from.module],
+                };
+            }
+            case 'empty-star':
+                return {
+                    exports: [],
+                    hideExports: mode.hidden,
+                    dependencies: [moduleGraph.getModule(this)],
+                };
+            // falls through
+            case 'normal-reexport': {
+                const from = moduleGraph.getConnection(this);
+                return {
+                    exports: Array.from(mode.items, (item) => ({
+                        name: item.name,
+                        from,
+                        export: item.ids,
+                        hidden: item.hidden,
+                    })),
+                    priority: 1,
+                    dependencies: [from.module],
+                };
+            }
+            case 'reexport-dynamic-default': {
+                const from = moduleGraph.getConnection(this);
+                return {
+                    exports: [
+                        {
+                            name: mode.name,
+                            from,
+                            export: ['default'],
+                        },
+                    ],
+                    priority: 1,
+                    dependencies: [from.module],
+                };
+            }
+            case 'reexport-undefined':
+                return {
+                    exports: [mode.name],
+                    dependencies: [moduleGraph.getModule(this)],
+                };
+            case 'reexport-fake-namespace-object': {
+                const from = moduleGraph.getConnection(this);
+                return {
+                    exports: [
+                        {
+                            name: mode.name,
+                            from,
+                            export: null,
+                            exports: [
+                                {
+                                    name: 'default',
+                                    canMangle: false,
+                                    from,
+                                    export: null,
+                                },
+                            ],
+                        },
+                    ],
+                    priority: 1,
+                    dependencies: [from.module],
+                };
+            }
+            case 'reexport-namespace-object': {
+                const from = moduleGraph.getConnection(this);
+                return {
+                    exports: [
+                        {
+                            name: mode.name,
+                            from,
+                            export: null,
+                        },
+                    ],
+                    priority: 1,
+                    dependencies: [from.module],
+                };
+            }
+            case 'reexport-named-default': {
+                const from = moduleGraph.getConnection(this);
+                return {
+                    exports: [
+                        {
+                            name: mode.name,
+                            from,
+                            export: ['default'],
+                        },
+                    ],
+                    priority: 1,
+                    dependencies: [from.module],
+                };
+            }
+            default:
+                throw new Error(`Unknown mode ${mode.type}`);
+        }
+    }
+    _getEffectiveExportPresenceLevel(moduleGraph) {
+        if (this.exportPresenceMode !== HarmonyImportDependency_1.ExportPresenceModes.AUTO)
+            return this.exportPresenceMode;
+        return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
+            ? HarmonyImportDependency_1.ExportPresenceModes.ERROR
+            : HarmonyImportDependency_1.ExportPresenceModes.WARN;
+    }
+    getWarnings(moduleGraph) {
+        const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+        if (exportsPresence === HarmonyImportDependency_1.ExportPresenceModes.WARN) {
+            return this._getErrors(moduleGraph);
+        }
+        return null;
+    }
+    getErrors(moduleGraph) {
+        const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+        if (exportsPresence === HarmonyImportDependency_1.ExportPresenceModes.ERROR) {
+            return this._getErrors(moduleGraph);
+        }
+        return null;
+    }
+    _getErrors(moduleGraph) {
+        const ids = this.getIds(moduleGraph);
+        let errors = this.getLinkingErrors(moduleGraph, ids, `(reexported as '${this.name}')`);
+        if (ids.length === 0 && this.name === null) {
+            const potentialConflicts = this._discoverActiveExportsFromOtherStarExports(moduleGraph);
+            if (potentialConflicts && potentialConflicts.namesSlice > 0) {
+                const ownNames = new Set(potentialConflicts.names.slice(potentialConflicts.namesSlice, potentialConflicts.dependencyIndices[potentialConflicts.dependencyIndex]));
+                const importedModule = moduleGraph.getModule(this);
+                if (importedModule) {
+                    const exportsInfo = moduleGraph.getExportsInfo(importedModule);
+                    const conflicts = new Map();
+                    for (const exportInfo of exportsInfo.orderedExports) {
+                        if (exportInfo.provided !== true)
+                            continue;
+                        if (exportInfo.name === 'default')
+                            continue;
+                        if (this.activeExports.has(exportInfo.name))
+                            continue;
+                        if (ownNames.has(exportInfo.name))
+                            continue;
+                        const conflictingDependency = findDependencyForName(potentialConflicts, exportInfo.name, this.allStarExports
+                            ? this.allStarExports.dependencies
+                            : [...this.otherStarExports, this]);
+                        if (!conflictingDependency)
+                            continue;
+                        const target = exportInfo.getTerminalBinding(moduleGraph);
+                        if (!target)
+                            continue;
+                        const conflictingModule = moduleGraph.getModule(conflictingDependency);
+                        if (conflictingModule === importedModule)
+                            continue;
+                        const conflictingExportInfo = moduleGraph.getExportInfo(conflictingModule, exportInfo.name);
+                        const conflictingTarget = conflictingExportInfo.getTerminalBinding(moduleGraph);
+                        if (!conflictingTarget)
+                            continue;
+                        if (target === conflictingTarget)
+                            continue;
+                        const list = conflicts.get(conflictingDependency.request);
+                        if (list === undefined) {
+                            conflicts.set(conflictingDependency.request, [exportInfo.name]);
+                        }
+                        else {
+                            list.push(exportInfo.name);
+                        }
+                    }
+                    for (const [request, exports] of conflicts) {
+                        if (!errors)
+                            errors = [];
+                        errors.push(new HarmonyLinkingError_1.default(`The requested module '${this.request}' contains conflicting star exports for the ${exports.length > 1 ? 'names' : 'name'} ${exports
+                            .map(e => `'${e}'`)
+                            .join(', ')} with the previous requested module '${request}'`));
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    serialize(context) {
+        const { write, setCircularReference } = context;
+        setCircularReference(this);
+        write(this.ids);
+        write(this.name);
+        write(this.activeExports);
+        write(this.otherStarExports);
+        write(this.exportPresenceMode);
+        write(this.allStarExports);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read, setCircularReference } = context;
+        setCircularReference(this);
+        this.ids = read();
+        this.name = read();
+        this.activeExports = read();
+        this.otherStarExports = read();
+        this.exportPresenceMode = read();
+        this.allStarExports = read();
+        super.deserialize(context);
+    }
+}
+exports.HarmonyExportImportedSpecifierDependency = HarmonyExportImportedSpecifierDependency;
+(0, makeSerializable_1.default)(HarmonyExportImportedSpecifierDependency, 'mp-compiler/core/dependencies/HarmonyExportImportedSpecifierDependency');
+HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedSpecifierDependencyTemplate extends (HarmonyImportDependency_1.HarmonyImportDependency.Template) {
+    apply(dependency, source, templateContext) {
+        const { moduleGraph, runtime, concatenationScope } = templateContext;
+        const dep = dependency;
+        const mode = dep.getMode(moduleGraph, runtime);
+        if (concatenationScope) {
+            switch (mode.type) {
+                case 'reexport-undefined':
+                    concatenationScope.registerRawExport(mode.name, '/* reexport non-default export from non-harmony */ undefined');
+            }
+            return;
+        }
+        if (mode.type !== 'unused' && mode.type !== 'empty-star') {
+            super.apply(dependency, source, templateContext);
+            this._addExportFragments(templateContext.initFragments, dep, mode, templateContext.module, moduleGraph, runtime, templateContext.runtimeTemplate, templateContext.runtimeRequirements);
+        }
+    }
+    _addExportFragments(initFragments, dep, mode, module, moduleGraph, runtime, runtimeTemplate, runtimeRequirements) {
+        const importedModule = moduleGraph.getModule(dep);
+        const importVar = dep.getImportVar(moduleGraph);
+        switch (mode.type) {
+            case 'missing':
+            case 'empty-star':
+                initFragments.push(new InitFragment_1.default('/* empty/unused harmony star reexport */\n', InitFragment_1.default.STAGE_HARMONY_EXPORTS, 1));
+                break;
+            case 'unused':
+                initFragments.push(new InitFragment_1.default(`${Template_1.Template.toNormalComment(`unused harmony reexport ${mode.name}`)}\n`, InitFragment_1.default.STAGE_HARMONY_EXPORTS, 1));
+                break;
+            case 'reexport-dynamic-default':
+                initFragments.push(this.getReexportFragment(module, 'reexport default  from dynamic', moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime), importVar, null, runtimeRequirements));
+                break;
+            case 'reexport-fake-namespace-object':
+                initFragments.push(...this.getReexportFakeNamespaceObjectFragments(module, moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime), importVar, mode.fakeType, runtimeRequirements));
+                break;
+            case 'reexport-undefined':
+                initFragments.push(this.getReexportFragment(module, 'reexport non-default export from non-harmony', moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime), 'undefined', '', runtimeRequirements));
+                break;
+            case 'reexport-named-default':
+                initFragments.push(this.getReexportFragment(module, 'reExport = export from named module', moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime), importVar, '', runtimeRequirements));
+                break;
+            case 'reexport-namespace-object':
+                initFragments.push(this.getReexportFragment(module, 'reexport module object', moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime), importVar, '', runtimeRequirements));
+                break;
+            case 'normal-reexport':
+                for (const { name, ids, checked, hidden } of mode.items) {
+                    if (hidden)
+                        continue;
+                    if (checked) {
+                        initFragments.push(new InitFragment_1.default(`/* harmony reexport (checked) */ ${this.getConditionalReexportStatement(module, name, importVar, ids, runtimeRequirements)}`, moduleGraph.isAsync(importedModule)
+                            ? InitFragment_1.default.STAGE_ASYNC_HARMONY_IMPORTS
+                            : InitFragment_1.default.STAGE_HARMONY_IMPORTS, dep.sourceOrder));
+                    }
+                    else {
+                        initFragments.push(this.getReexportFragment(module, 'reexport safe', moduleGraph.getExportsInfo(module).getUsedName(name, runtime), importVar, moduleGraph.getExportsInfo(importedModule).getUsedName(ids, runtime), runtimeRequirements));
+                    }
+                }
+                break;
+            case 'dynamic-reexport': {
+                const ignored = mode.hidden ? (0, SetHelpers_1.combine)(mode.ignored, mode.hidden) : mode.ignored;
+                const modern = runtimeTemplate.supportsConst() && runtimeTemplate.supportsArrowFunction();
+                let content = '/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};\n' +
+                    `/* harmony reexport (unknown) */ for(${modern ? 'const' : 'var'} __WEBPACK_IMPORT_KEY__ in ${importVar}) `;
+                // Filter out exports which are defined by other exports
+                // and filter out default export because it cannot be reexported with *
+                if (ignored.size > 1) {
+                    content +=
+                        `if(${JSON.stringify(Array.from(ignored))}.indexOf(__WEBPACK_IMPORT_KEY__) < 0) `;
+                }
+                else if (ignored.size === 1) {
+                    content += `if(__WEBPACK_IMPORT_KEY__ !== ${JSON.stringify((0, SetHelpers_1.first)(ignored))}) `;
+                }
+                content += `__WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = `;
+                if (modern) {
+                    content += `() => ${importVar}[__WEBPACK_IMPORT_KEY__]`;
+                }
+                else {
+                    content += `function(key) { return ${importVar}[key]; }.bind(0, __WEBPACK_IMPORT_KEY__)`;
+                }
+                runtimeRequirements.add(RuntimeGlobals.exports);
+                runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+                const exportsName = module.exportsArgument;
+                initFragments.push(new InitFragment_1.default(`${content}\n/* harmony reexport (unknown) */ ${RuntimeGlobals.definePropertyGetters}(${exportsName}, __WEBPACK_REEXPORT_OBJECT__);\n`, moduleGraph.isAsync(importedModule)
+                    ? InitFragment_1.default.STAGE_ASYNC_HARMONY_IMPORTS
+                    : InitFragment_1.default.STAGE_HARMONY_IMPORTS, dep.sourceOrder));
+                break;
+            }
+            default:
+                throw new Error(`Unknown mode ${mode.type}`);
+        }
+    }
+    getReexportFragment(module, comment, key, name, valueKey, runtimeRequirements) {
+        const returnValue = this.getReturnValue(name, valueKey);
+        runtimeRequirements.add(RuntimeGlobals.exports);
+        runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+        const map = new Map();
+        map.set(key, `/* ${comment} */ ${returnValue}`);
+        return new HarmonyExportInitFragment_1.default(module.exportsArgument, map);
+    }
+    getReexportFakeNamespaceObjectFragments(module, key, name, fakeType, runtimeRequirements) {
+        runtimeRequirements.add(RuntimeGlobals.exports);
+        runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+        runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+        const map = new Map();
+        map.set(key, `/* reexport fake namespace object from non-harmony */ ${name}_namespace_cache || (${name}_namespace_cache = ${RuntimeGlobals.createFakeNamespaceObject}(${name}${fakeType ? `, ${fakeType}` : ''}))`);
+        return [
+            new InitFragment_1.default(`var ${name}_namespace_cache;\n`, InitFragment_1.default.STAGE_CONSTANTS, -1, `${name}_namespace_cache`),
+            new HarmonyExportInitFragment_1.default(module.exportsArgument, map),
+        ];
+    }
+    getConditionalReexportStatement(module, key, name, valueKey, runtimeRequirements) {
+        if (valueKey === false) {
+            return '/* unused export */\n';
+        }
+        const exportsName = module.exportsArgument;
+        const returnValue = this.getReturnValue(name, valueKey);
+        runtimeRequirements.add(RuntimeGlobals.exports);
+        runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+        runtimeRequirements.add(RuntimeGlobals.hasOwnProperty);
+        return `if(${RuntimeGlobals.hasOwnProperty}(${name}, ${JSON.stringify(valueKey[0])})) ${RuntimeGlobals.definePropertyGetters}(${exportsName}, { ${(0, propertyName_1.propertyName)(key)}: function() { return ${returnValue}; } });\n`;
+    }
+    getReturnValue(name, valueKey) {
+        if (valueKey === null) {
+            return `${name}_default.a`;
+        }
+        if (valueKey === '') {
+            return name;
+        }
+        if (valueKey === false) {
+            return '/* unused export */ undefined';
+        }
+        return `${name}${(0, propertyAccess_1.default)(valueKey)}`;
+    }
+};
+class HarmonyStarExportsList {
+    constructor() {
+        this.dependencies = [];
+    }
+    push(dep) {
+        this.dependencies.push(dep);
+    }
+    slice() {
+        return this.dependencies.slice();
+    }
+    serialize({ write, setCircularReference }) {
+        setCircularReference(this);
+        write(this.dependencies);
+    }
+    deserialize({ read, setCircularReference }) {
+        setCircularReference(this);
+        this.dependencies = read();
+    }
+}
+exports.HarmonyStarExportsList = HarmonyStarExportsList;
+(0, makeSerializable_1.default)(HarmonyStarExportsList, 'mp-compiler/core/dependencies/HarmonyExportImportedSpecifierDependency', 'HarmonyStarExportsList');