/*

MIT License http://www.opensource.org/licenses/mit-license.php

Author Tobias Koppers @sokra

*/

"use strict";

const { ImportPhaseUtils } = require("./dependencies/ImportPhase");

const { equals } = require("./util/ArrayHelpers");

const SortableSet = require("./util/SortableSet");

const makeSerializable = require("./util/makeSerializable");

const { forEachRuntime } = require("./util/runtime");

/** @typedef {import("./Dependency")} Dependency */

/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */

/** @typedef {import("./Dependency").ExportInfoName} ExportInfoName */

/** @typedef {import("./Dependency").ExportsSpecExcludeExports} ExportsSpecExcludeExports */

/** @typedef {import("./dependencies/HarmonyImportDependency")} HarmonyImportDependency */

/** @typedef {import("./Module")} Module */

/** @typedef {import("./ModuleGraph")} ModuleGraph */

/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */

/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */

/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */

/** @typedef {import("./util/Hash")} Hash */

/** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */

/** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */

/** @typedef {Map<string, RuntimeUsageStateType>} UsedInRuntime */

/** @typedef {{ module: Module, export: ExportInfoName[], deferred: boolean }} TargetItemWithoutConnection */

/** @typedef {{ module: Module, connection: ModuleGraphConnection, export: ExportInfoName[] | undefined }} TargetItemWithConnection */

/** @typedef {(target: TargetItemWithConnection) => boolean} ResolveTargetFilter */

/** @typedef {(module: Module) => boolean} ValidTargetModuleFilter */

/** @typedef {{ connection: ModuleGraphConnection, export: ExportInfoName[], priority: number }} TargetItem */

/** @typedef {Map<Dependency | undefined, TargetItem>} Target */

/** @typedef {string | null} ExportInfoUsedName */

/** @typedef {boolean | null} ExportInfoProvided */

/** @typedef {Map<ExportInfoName, ExportInfo>} Exports */

/** @typedef {string | string[] | false} UsedName */

/** @typedef {Set<ExportInfo>} AlreadyVisitedExportInfo */

/**

* Defines the restore provided data exports type used by this module.

* @typedef {object} RestoreProvidedDataExports

* @property {ExportInfoName} name

* @property {ExportInfo["provided"]} provided

* @property {ExportInfo["canMangleProvide"]} canMangleProvide

* @property {ExportInfo["terminalBinding"]} terminalBinding

* @property {RestoreProvidedData | undefined} exportsInfo

*/

const UsageState = Object.freeze({

Unused: /** @type {0} */ (0),

OnlyPropertiesUsed: /** @type {1} */ (1),

NoInfo: /** @type {2} */ (2),

Unknown: /** @type {3} */ (3),

Used: /** @type {4} */ (4)

});

const RETURNS_TRUE = () => true;

const CIRCULAR = Symbol("circular target");

class RestoreProvidedData {

/**

* Creates an instance of RestoreProvidedData.

* @param {RestoreProvidedDataExports[]} exports exports

* @param {ExportInfo["provided"]} otherProvided other provided

* @param {ExportInfo["canMangleProvide"]} otherCanMangleProvide other can mangle provide

* @param {ExportInfo["terminalBinding"]} otherTerminalBinding other terminal binding

*/

constructor(

exports,

otherProvided,

otherCanMangleProvide,

otherTerminalBinding

) {

this.exports = exports;

this.otherProvided = otherProvided;

this.otherCanMangleProvide = otherCanMangleProvide;

this.otherTerminalBinding = otherTerminalBinding;

}

/**

* Serializes this instance into the provided serializer context.

* @param {ObjectSerializerContext} context context

*/

serialize({ write }) {

write(this.exports);

write(this.otherProvided);

write(this.otherCanMangleProvide);

write(this.otherTerminalBinding);

}

/**

* Restores this instance from the provided deserializer context.

* @param {ObjectDeserializerContext} context context

* @returns {RestoreProvidedData} RestoreProvidedData

*/

static deserialize({ read }) {

return new RestoreProvidedData(read(), read(), read(), read());

}

}

makeSerializable(

RestoreProvidedData,

"webpack/lib/ModuleGraph",

"RestoreProvidedData"

);

class ExportsInfo {

constructor() {

/** @type {Exports} */

this._exports = new Map();

/** @type {ExportInfo} */

this._otherExportsInfo = new ExportInfo(null);

/** @type {ExportInfo} */

this._sideEffectsOnlyInfo = new ExportInfo("*side effects only*");

/** @type {boolean} */

this._exportsAreOrdered = false;

/** @type {ExportsInfo=} */

this._redirectTo = undefined;

}

/**

* Gets owned exports.

* @returns {Iterable<ExportInfo>} all owned exports in any order

*/

get ownedExports() {

return this._exports.values();

}

/**

* Gets ordered owned exports.

* @returns {Iterable<ExportInfo>} all owned exports in order

*/

get orderedOwnedExports() {

if (!this._exportsAreOrdered) {

this._sortExports();

}

return this._exports.values();

}

/**

* Returns all exports in any order.

* @returns {Iterable<ExportInfo>} all exports in any order

*/

get exports() {

if (this._redirectTo !== undefined) {

const map = new Map(this._redirectTo._exports);

for (const [key, value] of this._exports) {

map.set(key, value);

}

return map.values();

}

return this._exports.values();

}

/**

* Gets ordered exports.

* @returns {Iterable<ExportInfo>} all exports in order

*/

get orderedExports() {

if (!this._exportsAreOrdered) {

this._sortExports();

}

if (this._redirectTo !== undefined) {

/** @type {Exports} */

const map = new Map(

Array.from(this._redirectTo.orderedExports, (item) => [item.name, item])

);

for (const [key, value] of this._exports) {

map.set(key, value);

}

// sorting should be pretty fast as map contains

// a lot of presorted items

this._sortExportsMap(map);

return map.values();

}

return this._exports.values();

}

/**

* Gets other exports info.

* @returns {ExportInfo} the export info of unlisted exports

*/

get otherExportsInfo() {

if (this._redirectTo !== undefined) {

return this._redirectTo.otherExportsInfo;

}

return this._otherExportsInfo;

}

/**

* Processes the provided export.

* @param {Exports} exports exports

* @private

*/

_sortExportsMap(exports) {

if (exports.size > 1) {

/** @type {ExportInfoName[]} */

const namesInOrder = [];

for (const entry of exports.values()) {

namesInOrder.push(entry.name);

}

namesInOrder.sort();

let i = 0;

for (const entry of exports.values()) {

const name = namesInOrder[i];

if (entry.name !== name) break;

i++;

}

for (; i < namesInOrder.length; i++) {

const name = namesInOrder[i];

const correctEntry = /** @type {ExportInfo} */ (exports.get(name));

exports.delete(name);

exports.set(name, correctEntry);

}

}

}

_sortExports() {

this._sortExportsMap(this._exports);

this._exportsAreOrdered = true;

}

/**

* Sets redirect named to.

* @param {ExportsInfo | undefined} exportsInfo exports info

* @returns {boolean} result

*/

setRedirectNamedTo(exportsInfo) {

if (this._redirectTo === exportsInfo) return false;

this._redirectTo = exportsInfo;

return true;

}

setHasProvideInfo() {

for (const exportInfo of this._exports.values()) {

if (exportInfo.provided === undefined) {

exportInfo.provided = false;

}

if (exportInfo.canMangleProvide === undefined) {

exportInfo.canMangleProvide = true;

}

}

if (this._redirectTo !== undefined) {

this._redirectTo.setHasProvideInfo();

} else {

if (this._otherExportsInfo.provided === undefined) {

this._otherExportsInfo.provided = false;

}

if (this._otherExportsInfo.canMangleProvide === undefined) {

this._otherExportsInfo.canMangleProvide = true;

}

}

}

setHasUseInfo() {

for (const exportInfo of this._exports.values()) {

exportInfo.setHasUseInfo();

}

this._sideEffectsOnlyInfo.setHasUseInfo();

if (this._redirectTo !== undefined) {

this._redirectTo.setHasUseInfo();

} else {

this._otherExportsInfo.setHasUseInfo();

}

}

/**

* Gets own export info.

* @param {ExportInfoName} name export name

* @returns {ExportInfo} export info for this name

*/

getOwnExportInfo(name) {

const info = this._exports.get(name);

if (info !== undefined) return info;

const newInfo = new ExportInfo(name, this._otherExportsInfo);

this._exports.set(name, newInfo);

this._exportsAreOrdered = false;

return newInfo;

}

/**

* Returns export info for this name.

* @param {ExportInfoName} name export name

* @returns {ExportInfo} export info for this name

*/

getExportInfo(name) {

const info = this._exports.get(name);

if (info !== undefined) return info;

if (this._redirectTo !== undefined) {

return this._redirectTo.getExportInfo(name);

}

const newInfo = new ExportInfo(name, this._otherExportsInfo);

this._exports.set(name, newInfo);

this._exportsAreOrdered = false;

return newInfo;

}

/**

* Gets read only export info.

* @param {ExportInfoName} name export name

* @returns {ExportInfo} export info for this name

*/

getReadOnlyExportInfo(name) {

const info = this._exports.get(name);

if (info !== undefined) return info;

if (this._redirectTo !== undefined) {

return this._redirectTo.getReadOnlyExportInfo(name);

}

return this._otherExportsInfo;

}

/**

* Gets read only export info recursive.

* @param {ExportInfoName[]} name export name

* @returns {ExportInfo | undefined} export info for this name

*/

getReadOnlyExportInfoRecursive(name) {

const exportInfo = this.getReadOnlyExportInfo(name[0]);

if (name.length === 1) return exportInfo;

if (!exportInfo.exportsInfo) return;

return exportInfo.exportsInfo.getReadOnlyExportInfoRecursive(name.slice(1));

}

/**

* Gets nested exports info.

* @param {ExportInfoName[]=} name the export name

* @returns {ExportsInfo | undefined} the nested exports info

*/

getNestedExportsInfo(name) {

if (Array.isArray(name) && name.length > 0) {

const info = this.getReadOnlyExportInfo(name[0]);

if (!info.exportsInfo) return;

return info.exportsInfo.getNestedExportsInfo(name.slice(1));

}

return this;

}

/**

* Sets unknown exports provided.

* @param {boolean=} canMangle true, if exports can still be mangled (defaults to false)

* @param {ExportsSpecExcludeExports=} excludeExports list of unaffected exports

* @param {Dependency=} targetKey use this as key for the target

* @param {ModuleGraphConnection=} targetModule set this module as target

* @param {number=} priority priority

* @returns {boolean} true, if this call changed something

*/

setUnknownExportsProvided(

canMangle,

excludeExports,

targetKey,

targetModule,

priority

) {

let changed = false;

if (excludeExports) {

for (const name of excludeExports) {

// Make sure these entries exist, so they can get different info

this.getExportInfo(name);

}

}

for (const exportInfo of this._exports.values()) {

if (!canMangle && exportInfo.canMangleProvide !== false) {

exportInfo.canMangleProvide = false;

changed = true;

}

if (excludeExports && excludeExports.has(exportInfo.name)) continue;

if (exportInfo.provided !== true && exportInfo.provided !== null) {

exportInfo.provided = null;

changed = true;

}

if (targetKey) {

exportInfo.setTarget(

targetKey,

/** @type {ModuleGraphConnection} */

(targetModule),

[exportInfo.name],

-1

);

}

}

if (this._redirectTo !== undefined) {

if (

this._redirectTo.setUnknownExportsProvided(

canMangle,

excludeExports,

targetKey,

targetModule,

priority

)

) {

changed = true;

}

} else {

if (

this._otherExportsInfo.provided !== true &&

this._otherExportsInfo.provided !== null

) {

this._otherExportsInfo.provided = null;

changed = true;

}

if (!canMangle && this._otherExportsInfo.canMangleProvide !== false) {

this._otherExportsInfo.canMangleProvide = false;

changed = true;

}

if (targetKey) {

this._otherExportsInfo.setTarget(

targetKey,

/** @type {ModuleGraphConnection} */ (targetModule),

undefined,

priority

);

}

}

return changed;

}

/**

* Sets used in unknown way.

* @param {RuntimeSpec} runtime the runtime

* @returns {boolean} true, when something changed

*/

setUsedInUnknownWay(runtime) {

let changed = false;

for (const exportInfo of this._exports.values()) {

if (exportInfo.setUsedInUnknownWay(runtime)) {

changed = true;

}

}

if (this._redirectTo !== undefined) {

if (this._redirectTo.setUsedInUnknownWay(runtime)) {

changed = true;

}

} else {

if (

this._otherExportsInfo.setUsedConditionally(

(used) => used < UsageState.Unknown,

UsageState.Unknown,

runtime

)

) {

changed = true;

}

if (this._otherExportsInfo.canMangleUse !== false) {

this._otherExportsInfo.canMangleUse = false;

changed = true;

}

}

return changed;

}

/**

* Sets used without info.

* @param {RuntimeSpec} runtime the runtime

* @returns {boolean} true, when something changed

*/

setUsedWithoutInfo(runtime) {

let changed = false;

for (const exportInfo of this._exports.values()) {

if (exportInfo.setUsedWithoutInfo(runtime)) {

changed = true;

}

}

if (this._redirectTo !== undefined) {

if (this._redirectTo.setUsedWithoutInfo(runtime)) {

changed = true;

}

} else {

if (this._otherExportsInfo.setUsed(UsageState.NoInfo, runtime)) {

changed = true;

}

if (this._otherExportsInfo.canMangleUse !== false) {

this._otherExportsInfo.canMangleUse = false;

changed = true;

}

}

return changed;

}

/**

* Sets all known exports used.

* @param {RuntimeSpec} runtime the runtime

* @returns {boolean} true, when something changed

*/

setAllKnownExportsUsed(runtime) {

let changed = false;

for (const exportInfo of this._exports.values()) {

if (!exportInfo.provided) continue;

if (exportInfo.setUsed(UsageState.Used, runtime)) {

changed = true;

}

}

return changed;

}

/**

* Sets used for side effects only.

* @param {RuntimeSpec} runtime the runtime

* @returns {boolean} true, when something changed

*/

setUsedForSideEffectsOnly(runtime) {

return this._sideEffectsOnlyInfo.setUsedConditionally(

(used) => used === UsageState.Unused,

UsageState.Used,

runtime

);

}

/**

* Checks whether this exports info is used.

* @param {RuntimeSpec} runtime the runtime

* @returns {boolean} true, when the module exports are used in any way

*/

isUsed(runtime) {

if (this._redirectTo !== undefined) {

if (this._redirectTo.isUsed(runtime)) {

return true;

}

} else if (this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {

return true;

}

for (const exportInfo of this._exports.values()) {

if (exportInfo.getUsed(runtime) !== UsageState.Unused) {

return true;

}

}

return false;

}

/**

* Checks whether this exports info is module used.

* @param {RuntimeSpec} runtime the runtime

* @returns {boolean} true, when the module is used in any way

*/

isModuleUsed(runtime) {

if (this.isUsed(runtime)) return true;

if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused) {

return true;

}

return false;

}

/**

* Returns set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown).

* @param {RuntimeSpec} runtime the runtime

* @returns {SortableSet<ExportInfoName> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)

*/

getUsedExports(runtime) {

switch (this._otherExportsInfo.getUsed(runtime)) {

case UsageState.NoInfo:

return null;

case UsageState.Unknown:

case UsageState.OnlyPropertiesUsed:

case UsageState.Used:

return true;

}

/** @type {ExportInfoName[]} */

const array = [];

if (!this._exportsAreOrdered) this._sortExports();

for (const exportInfo of this._exports.values()) {

switch (exportInfo.getUsed(runtime)) {

case UsageState.NoInfo:

return null;

case UsageState.Unknown:

return true;

case UsageState.OnlyPropertiesUsed:

case UsageState.Used:

array.push(exportInfo.name);

}

}

if (this._redirectTo !== undefined) {

const inner = this._redirectTo.getUsedExports(runtime);

if (inner === null) return null;

if (inner === true) return true;

if (inner !== false) {

for (const item of inner) {

array.push(item);

}

}

}

if (array.length === 0) {

switch (this._sideEffectsOnlyInfo.getUsed(runtime)) {

case UsageState.NoInfo:

return null;

case UsageState.Unused:

return false;

}

}

return /** @type {SortableSet<ExportInfoName>} */ (new SortableSet(array));

}

/**

* Gets provided exports.

* @returns {null | true | ExportInfoName[]} list of exports when known

*/

getProvidedExports() {

switch (this._otherExportsInfo.provided) {

case undefined:

return null;

case null:

return true;

case true:

return true;

}

/** @type {ExportInfoName[]} */

const array = [];

if (!this._exportsAreOrdered) this._sortExports();

for (const exportInfo of this._exports.values()) {

switch (exportInfo.provided) {

case undefined:

return null;

case null:

return true;

case true:

array.push(exportInfo.name);

}

}

if (this._redirectTo !== undefined) {

const inner = this._redirectTo.getProvidedExports();

if (inner === null) return null;

if (inner === true) return true;

for (const item of inner) {

if (!array.includes(item)) {

array.push(item);

}

}

}

return array;

}

/**

* Gets relevant exports.

* @param {RuntimeSpec} runtime the runtime

* @returns {ExportInfo[]} exports that are relevant (not unused and potential provided)

*/

getRelevantExports(runtime) {

/** @type {ExportInfo[]} */

const list = [];

for (const exportInfo of this._exports.values()) {

const used = exportInfo.getUsed(runtime);

if (used === UsageState.Unused) continue;

if (exportInfo.provided === false) continue;

list.push(exportInfo);

}

if (this._redirectTo !== undefined) {

for (const exportInfo of this._redirectTo.getRelevantExports(runtime)) {

if (!this._exports.has(exportInfo.name)) list.push(exportInfo);

}

}

if (

this._otherExportsInfo.provided !== false &&

this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused

) {

list.push(this._otherExportsInfo);

}

return list;

}

/**

* Checks whether this exports info is export provided.

* @param {ExportInfoName | ExportInfoName[]} name the name of the export

* @returns {boolean | undefined | null} if the export is provided

*/

isExportProvided(name) {

if (Array.isArray(name)) {

const info = this.getReadOnlyExportInfo(name[0]);

if (info.exportsInfo && name.length > 1) {

return info.exportsInfo.isExportProvided(name.slice(1));

}

return info.provided ? name.length === 1 || undefined : info.provided;

}

const info = this.getReadOnlyExportInfo(name);

return info.provided;

}

/**

* Returns key representing the usage.

* @param {RuntimeSpec} runtime runtime

* @returns {string} key representing the usage

*/

getUsageKey(runtime) {

/** @type {(string | number)[]} */

const key = [];

if (this._redirectTo !== undefined) {

key.push(this._redirectTo.getUsageKey(runtime));

} else {

key.push(this._otherExportsInfo.getUsed(runtime));

}

key.push(this._sideEffectsOnlyInfo.getUsed(runtime));

for (const exportInfo of this.orderedOwnedExports) {

key.push(exportInfo.getUsed(runtime));

}

return key.join("|");

}

/**

* Checks whether this exports info is equally used.

* @param {RuntimeSpec} runtimeA first runtime

* @param {RuntimeSpec} runtimeB second runtime

* @returns {boolean} true, when equally used

*/

isEquallyUsed(runtimeA, runtimeB) {

if (this._redirectTo !== undefined) {

if (!this._redirectTo.isEquallyUsed(runtimeA, runtimeB)) return false;

} else if (

this._otherExportsInfo.getUsed(runtimeA) !==

this._otherExportsInfo.getUsed(runtimeB)

) {

return false;

}

if (

this._sideEffectsOnlyInfo.getUsed(runtimeA) !==

this._sideEffectsOnlyInfo.getUsed(runtimeB)

) {

return false;

}

for (const exportInfo of this.ownedExports) {

if (exportInfo.getUsed(runtimeA) !== exportInfo.getUsed(runtimeB)) {

return false;

}

}

return true;

}

/**

* Returns usage status.

* @param {ExportInfoName | ExportInfoName[]} name export name

* @param {RuntimeSpec} runtime check usage for this runtime only

* @returns {UsageStateType} usage status

*/

getUsed(name, runtime) {

if (Array.isArray(name)) {

if (name.length === 0) return this.otherExportsInfo.getUsed(runtime);

const info = this.getReadOnlyExportInfo(name[0]);

if (info.exportsInfo && name.length > 1) {

return info.exportsInfo.getUsed(name.slice(1), runtime);

}

return info.getUsed(runtime);

}

const info = this.getReadOnlyExportInfo(name);

return info.getUsed(runtime);

}

/**

* Returns the used name.

* @param {ExportInfoName | ExportInfoName[]} name the export name

* @param {RuntimeSpec} runtime check usage for this runtime only

* @returns {UsedName} the used name

*/

getUsedName(name, runtime) {

if (Array.isArray(name)) {

// TODO improve this

if (name.length === 0) {

if (!this.isUsed(runtime)) return false;

return name;

}

const info = this.getReadOnlyExportInfo(name[0]);

const x = info.getUsedName(name[0], runtime);

if (x === false) return false;

const arr =

/** @type {ExportInfoName[]} */

(x === name[0] && name.length === 1 ? name : [x]);

if (name.length === 1) {

return arr;

}

if (

info.exportsInfo &&

info.getUsed(runtime) === UsageState.OnlyPropertiesUsed

) {

const nested = info.exportsInfo.getUsedName(name.slice(1), runtime);

if (!nested) return false;

return [...arr, ...(Array.isArray(nested) ? nested : [nested])];

}

return [...arr, ...name.slice(1)];

}

const info = this.getReadOnlyExportInfo(name);

const usedName = info.getUsedName(name, runtime);

return usedName;

}

/**

* Updates the hash with the data contributed by this instance.

* @param {Hash} hash the hash

* @param {RuntimeSpec} runtime the runtime

* @returns {void}

*/

updateHash(hash, runtime) {

this._updateHash(hash, runtime, new Set());

}

/**

* Updates hash using the provided hash.

* @param {Hash} hash the hash

* @param {RuntimeSpec} runtime the runtime

* @param {Set<ExportsInfo>} alreadyVisitedExportsInfo for circular references

* @returns {void}

*/

_updateHash(hash, runtime, alreadyVisitedExportsInfo) {

const set = new Set(alreadyVisitedExportsInfo);

set.add(this);

for (const exportInfo of this.orderedExports) {

if (exportInfo.hasInfo(this._otherExportsInfo, runtime)) {

exportInfo._updateHash(hash, runtime, set);

}

}

this._sideEffectsOnlyInfo._updateHash(hash, runtime, set);

this._otherExportsInfo._updateHash(hash, runtime, set);

if (this._redirectTo !== undefined) {

this._redirectTo._updateHash(hash, runtime, set);

}

}

/**

* Gets restore provided data.

* @returns {RestoreProvidedData} restore provided data

*/

getRestoreProvidedData() {

const otherProvided = this._otherExportsInfo.provided;

const otherCanMangleProvide = this._otherExportsInfo.canMangleProvide;

const otherTerminalBinding = this._otherExportsInfo.terminalBinding;

/** @type {RestoreProvidedDataExports[]} */

const exports = [];

for (const exportInfo of this.orderedExports) {

if (

exportInfo.provided !== otherProvided ||

exportInfo.canMangleProvide !== otherCanMangleProvide ||

exportInfo.terminalBinding !== otherTerminalBinding ||

exportInfo.exportsInfoOwned

) {

exports.push({

name: exportInfo.name,

provided: exportInfo.provided,

canMangleProvide: exportInfo.canMangleProvide,

terminalBinding: exportInfo.terminalBinding,

exportsInfo: exportInfo.exportsInfoOwned

? /** @type {NonNullable<ExportInfo["exportsInfo"]>} */

(exportInfo.exportsInfo).getRestoreProvidedData()

: undefined

});

}

}

return new RestoreProvidedData(

exports,

otherProvided,

otherCanMangleProvide,

otherTerminalBinding

);

}

/**

* Processes the provided data.

* @param {RestoreProvidedData} data data

*/

restoreProvided({

otherProvided,

otherCanMangleProvide,

otherTerminalBinding,

exports

}) {

let wasEmpty = true;

for (const exportInfo of this._exports.values()) {

wasEmpty = false;

exportInfo.provided = otherProvided;

exportInfo.canMangleProvide = otherCanMangleProvide;

exportInfo.terminalBinding = otherTerminalBinding;

}

this._otherExportsInfo.provided = otherProvided;

this._otherExportsInfo.canMangleProvide = otherCanMangleProvide;

this._otherExportsInfo.terminalBinding = otherTerminalBinding;

for (const exp of exports) {

const exportInfo = this.getExportInfo(exp.name);

exportInfo.provided = exp.provided;

exportInfo.canMangleProvide = exp.canMangleProvide;

exportInfo.terminalBinding = exp.terminalBinding;

if (exp.exportsInfo) {

const exportsInfo = exportInfo.createNestedExportsInfo();

exportsInfo.restoreProvided(exp.exportsInfo);

}

}

if (wasEmpty) this._exportsAreOrdered = true;

}

}

class ExportInfo {

/**

* Creates an instance of ExportInfo.

* @param {ExportInfoName | null} name the original name of the export

* @param {ExportInfo=} initFrom init values from this ExportInfo

*/

constructor(name, initFrom) {

/** @type {ExportInfoName} */

this.name = /** @type {ExportInfoName} */ (name);

/**

* @private

* @type {ExportInfoUsedName}

*/

this._usedName = initFrom ? initFrom._usedName : null;

/**

* @private

* @type {UsageStateType | undefined}

*/

this._globalUsed = initFrom ? initFrom._globalUsed : undefined;

/**

* @private

* @type {UsedInRuntime | undefined}

*/

this._usedInRuntime =

initFrom && initFrom._usedInRuntime

? new Map(initFrom._usedInRuntime)

: undefined;

/**

* @private

* @type {boolean}

*/

this._hasUseInRuntimeInfo = initFrom

? initFrom._hasUseInRuntimeInfo

: false;

/**

* true: it is provided

* false: it is not provided

* null: only the runtime knows if it is provided

* undefined: it was not determined if it is provided

* @type {ExportInfoProvided | undefined}

*/

this.provided = initFrom ? initFrom.provided : undefined;

/**

* is the export a terminal binding that should be checked for export star conflicts

* @type {boolean}

*/

this.terminalBinding = initFrom ? initFrom.terminalBinding : false;

/**

* true: it can be mangled

* false: is can not be mangled

* undefined: it was not determined if it can be mangled

* @type {boolean | undefined}

*/

this.canMangleProvide = initFrom ? initFrom.canMangleProvide : undefined;

/**

* true: it can be mangled

* false: is can not be mangled

* undefined: it was not determined if it can be mangled

* @type {boolean | undefined}

*/

this.canMangleUse = initFrom ? initFrom.canMangleUse : undefined;

/** @type {boolean} */

this.exportsInfoOwned = false;

/** @type {ExportsInfo | undefined} */

this.exportsInfo = undefined;

/** @type {Target | undefined} */

this._target = undefined;

if (initFrom && initFrom._target) {

this._target = /** @type {Target} */ (new Map());

for (const [key, value] of initFrom._target) {

this._target.set(key, {

connection: value.connection,

export: value.export || [name],

priority: value.priority

});

}

}

/** @type {Target | undefined} */

this._maxTarget = undefined;

}

get canMangle() {

switch (this.canMangleProvide) {

case undefined:

return this.canMangleUse === false ? false : undefined;

case false:

return false;

case true:

switch (this.canMangleUse) {

case undefined:

return undefined;

case false:

return false;

case true:

return true;

}

}

throw new Error(

`Unexpected flags for canMangle ${this.canMangleProvide} ${this.canMangleUse}`

);

}

/**

* Sets used in unknown way.

* @param {RuntimeSpec} runtime only apply to this runtime

* @returns {boolean} true, when something changed

*/

setUsedInUnknownWay(runtime) {

let changed = false;

if (