xhs-mp-pack 1.1.0-beta.0

package/dist/module/ExportsInfo.js

@@ -0,0 +1,1171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportInfo = exports.ExportsInfo = exports.UsageState = void 0;
+const ArrayHelpers_1 = require("@/base/ArrayHelpers");
+const SortableSet_1 = __importDefault(require("@/base/SortableSet"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const UsageState = Object.freeze({
+    Unused: 0,
+    OnlyPropertiesUsed: 1,
+    NoInfo: 2,
+    Unknown: 3,
+    Used: 4,
+});
+exports.UsageState = UsageState;
+const RETURNS_TRUE = () => true;
+const CIRCULAR = Symbol('circular target');
+class RestoreProvidedData {
+    constructor(exports, otherProvided, otherCanMangleProvide, otherTerminalBinding) {
+        this.exports = exports;
+        this.otherProvided = otherProvided;
+        this.otherCanMangleProvide = otherCanMangleProvide;
+        this.otherTerminalBinding = otherTerminalBinding;
+    }
+    serialize({ write }) {
+        write(this.exports);
+        write(this.otherProvided);
+        write(this.otherCanMangleProvide);
+        write(this.otherTerminalBinding);
+    }
+    static deserialize({ read }) {
+        return new RestoreProvidedData(read(), read(), read(), read());
+    }
+}
+(0, makeSerializable_1.default)(RestoreProvidedData, 'mp-compiler/core/module/ModuleGraph', 'RestoreProvidedData');
+class ExportsInfo {
+    constructor() {
+        this._exports = new Map();
+        this._otherExportsInfo = new ExportInfo(null);
+        this._sideEffectsOnlyInfo = new ExportInfo('*side effects only*');
+        this._exportsAreOrdered = false;
+        this._redirectTo = undefined;
+    }
+    get ownedExports() {
+        return this._exports.values();
+    }
+    get orderedOwnedExports() {
+        if (!this._exportsAreOrdered) {
+            this._sortExports();
+        }
+        return this._exports.values();
+    }
+    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();
+    }
+    get orderedExports() {
+        if (!this._exportsAreOrdered) {
+            this._sortExports();
+        }
+        if (this._redirectTo !== undefined) {
+            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();
+    }
+    get otherExportsInfo() {
+        if (this._redirectTo !== undefined) {
+            return this._redirectTo.otherExportsInfo;
+        }
+        return this._otherExportsInfo;
+    }
+    _sortExportsMap(exports) {
+        if (exports.size > 1) {
+            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 = exports.get(name);
+                exports.delete(name);
+                exports.set(name, correctEntry);
+            }
+        }
+    }
+    _sortExports() {
+        this._sortExportsMap(this._exports);
+        this._exportsAreOrdered = true;
+    }
+    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();
+            if (this._otherExportsInfo.canMangleUse === undefined) {
+                this._otherExportsInfo.canMangleUse = true;
+            }
+        }
+    }
+    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;
+    }
+    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;
+    }
+    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;
+    }
+    getReadOnlyExportInfoRecursive(name) {
+        const exportInfo = this.getReadOnlyExportInfo(name[0]);
+        if (name.length === 1)
+            return exportInfo;
+        if (!exportInfo.exportsInfo)
+            return undefined;
+        return exportInfo.exportsInfo.getReadOnlyExportInfoRecursive(name.slice(1));
+    }
+    getNestedExportsInfo(name) {
+        if (Array.isArray(name) && name.length > 0) {
+            const info = this.getReadOnlyExportInfo(name[0]);
+            if (!info.exportsInfo)
+                return undefined;
+            return info.exportsInfo.getNestedExportsInfo(name.slice(1));
+        }
+        return this;
+    }
+    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 === null || excludeExports === void 0 ? void 0 : excludeExports.has(exportInfo.name))
+                continue;
+            if (exportInfo.provided !== true && exportInfo.provided !== null) {
+                exportInfo.provided = null;
+                changed = true;
+            }
+            if (targetKey) {
+                exportInfo.setTarget(targetKey, 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, targetModule, undefined, priority);
+            }
+        }
+        return 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;
+    }
+    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;
+    }
+    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;
+    }
+    setUsedForSideEffectsOnly(runtime) {
+        return this._sideEffectsOnlyInfo.setUsedConditionally(used => used === UsageState.Unused, UsageState.Used, runtime);
+    }
+    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;
+    }
+    isModuleUsed(runtime) {
+        if (this.isUsed(runtime))
+            return true;
+        if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused)
+            return true;
+        return false;
+    }
+    getUsedExports(runtime) {
+        if (!this._redirectTo !== undefined) {
+            switch (this._otherExportsInfo.getUsed(runtime)) {
+                case UsageState.NoInfo:
+                    return null;
+                case UsageState.Unknown:
+                case UsageState.OnlyPropertiesUsed:
+                case UsageState.Used:
+                    return true;
+            }
+        }
+        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 new SortableSet_1.default(array);
+    }
+    getProvidedExports() {
+        if (!this._redirectTo !== undefined) {
+            switch (this._otherExportsInfo.provided) {
+                case undefined:
+                    return null;
+                case null:
+                    return true;
+                case true:
+                    return true;
+            }
+        }
+        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;
+    }
+    getRelevantExports(runtime) {
+        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;
+    }
+    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;
+    }
+    getUsageKey(runtime) {
+        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('|');
+    }
+    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;
+    }
+    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);
+    }
+    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 = 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.concat(nested);
+            }
+            return arr.concat(name.slice(1));
+        }
+        const info = this.getReadOnlyExportInfo(name);
+        const usedName = info.getUsedName(name, runtime);
+        return usedName;
+    }
+    updateHash(hash, runtime) {
+        this._updateHash(hash, runtime, new Set());
+    }
+    _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);
+        }
+    }
+    getRestoreProvidedData() {
+        const otherProvided = this._otherExportsInfo.provided;
+        const otherCanMangleProvide = this._otherExportsInfo.canMangleProvide;
+        const otherTerminalBinding = this._otherExportsInfo.terminalBinding;
+        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
+                        ? exportInfo.exportsInfo.getRestoreProvidedData()
+                        : undefined,
+                });
+            }
+        }
+        return new RestoreProvidedData(exports, otherProvided, otherCanMangleProvide, otherTerminalBinding);
+    }
+    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;
+    }
+}
+exports.ExportsInfo = ExportsInfo;
+class ExportInfo {
+    constructor(name, initFrom) {
+        this.name = name;
+        this._usedName = initFrom ? initFrom._usedName : null;
+        this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
+        // @ts-ignore
+        this._usedInRuntime =
+            (initFrom === null || initFrom === void 0 ? void 0 : initFrom._usedInRuntime) ? new Map(initFrom._usedInRuntime) : undefined;
+        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
+         */
+        this.provided = initFrom ? initFrom.provided : undefined;
+        this.terminalBinding = initFrom ? initFrom.terminalBinding : false;
+        this.canMangleProvide = initFrom ? initFrom.canMangleProvide : undefined;
+        this.canMangleUse = initFrom ? initFrom.canMangleUse : undefined;
+        this.exportsInfoOwned = false;
+        this.exportsInfo = undefined;
+        this._target = undefined;
+        if (initFrom === null || initFrom === void 0 ? void 0 : initFrom._target) {
+            this._target = new Map();
+            for (const [key, value] of initFrom._target) {
+                this._target.set(key, {
+                    connection: value.connection,
+                    export: value.export || [name],
+                    priority: value.priority,
+                });
+            }
+        }
+        this._maxTarget = undefined;
+    }
+    get used() {
+        throw new Error('REMOVED');
+    }
+    get usedName() {
+        throw new Error('REMOVED');
+    }
+    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}`);
+    }
+    setUsedInUnknownWay(runtime) {
+        let changed = false;
+        if (this.setUsedConditionally(used => used < UsageState.Unknown, UsageState.Unknown, runtime)) {
+            changed = true;
+        }
+        if (this.canMangleUse !== false) {
+            this.canMangleUse = false;
+            changed = true;
+        }
+        return changed;
+    }
+    setUsedWithoutInfo(runtime) {
+        let changed = false;
+        if (this.setUsed(UsageState.NoInfo, runtime)) {
+            changed = true;
+        }
+        if (this.canMangleUse !== false) {
+            this.canMangleUse = false;
+            changed = true;
+        }
+        return changed;
+    }
+    setHasUseInfo() {
+        if (!this._hasUseInRuntimeInfo) {
+            this._hasUseInRuntimeInfo = true;
+        }
+        if (this.canMangleUse === undefined) {
+            this.canMangleUse = true;
+        }
+        if (this.exportsInfoOwned) {
+            this.exportsInfo.setHasUseInfo();
+        }
+    }
+    setUsedConditionally(condition, newValue, runtime) {
+        if (runtime === undefined) {
+            if (this._globalUsed === undefined) {
+                this._globalUsed = newValue;
+                return true;
+            }
+            if (this._globalUsed !== newValue && condition(this._globalUsed)) {
+                this._globalUsed = newValue;
+                return true;
+            }
+        }
+        else if (this._usedInRuntime === undefined) {
+            if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
+                this._usedInRuntime = new Map();
+                (0, RuntimeHelpers_1.forEachRuntime)(runtime, runtime => this._usedInRuntime.set(runtime, newValue));
+                return true;
+            }
+        }
+        else {
+            let changed = false;
+            (0, RuntimeHelpers_1.forEachRuntime)(runtime, runtime => {
+                let oldValue = this._usedInRuntime.get(runtime);
+                if (oldValue === undefined)
+                    oldValue = UsageState.Unused;
+                if (newValue !== oldValue && condition(oldValue)) {
+                    if (newValue === UsageState.Unused) {
+                        this._usedInRuntime.delete(runtime);
+                    }
+                    else {
+                        this._usedInRuntime.set(runtime, newValue);
+                    }
+                    changed = true;
+                }
+            });
+            if (changed) {
+                // @ts-ignore
+                if (this._usedInRuntime.size === 0)
+                    this._usedInRuntime = undefined;
+                return true;
+            }
+        }
+        return false;
+    }
+    setUsed(newValue, runtime) {
+        if (runtime === undefined) {
+            if (this._globalUsed !== newValue) {
+                this._globalUsed = newValue;
+                return true;
+            }
+        }
+        else if (this._usedInRuntime === undefined) {
+            if (newValue !== UsageState.Unused) {
+                this._usedInRuntime = new Map();
+                (0, RuntimeHelpers_1.forEachRuntime)(runtime, runtime => this._usedInRuntime.set(runtime, newValue));
+                return true;
+            }
+        }
+        else {
+            let changed = false;
+            (0, RuntimeHelpers_1.forEachRuntime)(runtime, runtime => {
+                let oldValue = this._usedInRuntime.get(runtime);
+                if (oldValue === undefined)
+                    oldValue = UsageState.Unused;
+                if (newValue !== oldValue) {
+                    if (newValue === UsageState.Unused) {
+                        this._usedInRuntime.delete(runtime);
+                    }
+                    else {
+                        this._usedInRuntime.set(runtime, newValue);
+                    }
+                    changed = true;
+                }
+            });
+            if (changed) {
+                // @ts-ignore
+                if (this._usedInRuntime.size === 0)
+                    this._usedInRuntime = undefined;
+                return true;
+            }
+        }
+        return false;
+    }
+    unsetTarget(key) {
+        if (!this._target)
+            return false;
+        if (this._target.delete(key)) {
+            this._maxTarget = undefined;
+            return true;
+        }
+        return false;
+    }
+    setTarget(key, connection, exportName, priority = 0) {
+        if (exportName)
+            exportName = [...exportName];
+        if (!this._target) {
+            this._target = new Map();
+            this._target.set(key, { connection, export: exportName, priority });
+            return true;
+        }
+        const oldTarget = this._target.get(key);
+        if (!oldTarget) {
+            if (oldTarget === null && !connection)
+                return false;
+            this._target.set(key, { connection, export: exportName, priority });
+            this._maxTarget = undefined;
+            return true;
+        }
+        if (oldTarget.connection !== connection ||
+            oldTarget.priority !== priority ||
+            (exportName ? !oldTarget.export || !(0, ArrayHelpers_1.equals)(oldTarget.export, exportName) : oldTarget.export)) {
+            oldTarget.connection = connection;
+            oldTarget.export = exportName;
+            oldTarget.priority = priority;
+            // this._maxTarget = undefined
+            return true;
+        }
+        return false;
+    }
+    getUsed(runtime) {
+        if (!this._hasUseInRuntimeInfo)
+            return UsageState.NoInfo;
+        if (this._globalUsed !== undefined)
+            return this._globalUsed;
+        if (this._usedInRuntime === undefined) {
+            return UsageState.Unused;
+        }
+        if (typeof runtime === 'string') {
+            const value = this._usedInRuntime.get(runtime);
+            return value === undefined ? UsageState.Unused : value;
+        }
+        if (runtime === undefined) {
+            let max = UsageState.Unused;
+            for (const value of this._usedInRuntime.values()) {
+                if (value === UsageState.Used) {
+                    return UsageState.Used;
+                }
+                if (max < value)
+                    max = value;
+            }
+            return max;
+        }
+        let max = UsageState.Unused;
+        for (const item of runtime) {
+            const value = this._usedInRuntime.get(item);
+            if (value !== undefined) {
+                if (value === UsageState.Used) {
+                    return UsageState.Used;
+                }
+                if (max < value)
+                    max = value;
+            }
+        }
+        return max;
+    }
+    getUsedName(fallbackName, runtime) {
+        if (this._hasUseInRuntimeInfo) {
+            if (this._globalUsed !== undefined) {
+                if (this._globalUsed === UsageState.Unused)
+                    return false;
+            }
+            else {
+                if (this._usedInRuntime === undefined)
+                    return false;
+                if (typeof runtime === 'string') {
+                    if (!this._usedInRuntime.has(runtime)) {
+                        return false;
+                    }
+                }
+                else if (runtime !== undefined) {
+                    if (Array.from(runtime).every(runtime => !this._usedInRuntime.has(runtime))) {
+                        return false;
+                    }
+                }
+            }
+        }
+        if (this._usedName !== null)
+            return this._usedName;
+        return this.name || fallbackName;
+    }
+    hasUsedName() {
+        return this._usedName !== null;
+    }
+    setUsedName(name) {
+        this._usedName = name;
+    }
+    getTerminalBinding(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
+        if (this.terminalBinding)
+            return this;
+        const target = this.getTarget(moduleGraph, resolveTargetFilter);
+        if (!target)
+            return undefined;
+        const exportsInfo = moduleGraph.getExportsInfo(target.module);
+        if (!target.export)
+            return exportsInfo;
+        return exportsInfo.getReadOnlyExportInfoRecursive(target.export);
+    }
+    isReexport() {
+        return !this.terminalBinding && this._target && this._target.size > 0;
+    }
+    _getMaxTarget() {
+        if (this._maxTarget !== undefined)
+            return this._maxTarget;
+        if (this._target.size <= 1) {
+            this._maxTarget = this._target;
+            return this._maxTarget;
+        }
+        let maxPriority = -Infinity;
+        let minPriority = Infinity;
+        for (const { priority } of this._target.values()) {
+            if (maxPriority < priority)
+                maxPriority = priority;
+            if (minPriority > priority)
+                minPriority = priority;
+        }
+        // This should be very common
+        if (maxPriority === minPriority) {
+            this._maxTarget = this._target;
+            return this._maxTarget;
+        }
+        // This is an edge case
+        const map = new Map();
+        for (const [key, value] of this._target) {
+            if (maxPriority === value.priority) {
+                map.set(key, value);
+            }
+        }
+        this._maxTarget = map;
+        return map;
+    }
+    findTarget(moduleGraph, validTargetModuleFilter) {
+        return this._findTarget(moduleGraph, validTargetModuleFilter, new Set());
+    }
+    _findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) {
+        if (!this._target || this._target.size === 0)
+            return undefined;
+        const rawTarget = this._getMaxTarget().values().next().value;
+        if (!rawTarget)
+            return undefined;
+        let target = {
+            module: rawTarget.connection.module,
+            export: rawTarget.export,
+        };
+        for (;;) {
+            if (validTargetModuleFilter(target.module))
+                return target;
+            const exportsInfo = moduleGraph.getExportsInfo(target.module);
+            const exportInfo = exportsInfo.getExportInfo(target.export[0]);
+            if (alreadyVisited.has(exportInfo))
+                return null;
+            const newTarget = exportInfo._findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited);
+            if (!newTarget)
+                return false;
+            if (target.export.length === 1) {
+                target = newTarget;
+            }
+            else {
+                target = {
+                    module: newTarget.module,
+                    export: newTarget.export
+                        ? newTarget.export.concat(target.export.slice(1))
+                        : target.export.slice(1),
+                };
+            }
+        }
+    }
+    getTarget(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
+        const result = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
+        if (result === CIRCULAR)
+            return undefined;
+        return result;
+    }
+    _getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) {
+        const resolveTarget = (inputTarget, alreadyVisited) => {
+            if (!inputTarget)
+                return null;
+            if (!inputTarget.export) {
+                return {
+                    module: inputTarget.connection.module,
+                    connection: inputTarget.connection,
+                    export: undefined,
+                };
+            }
+            let target = {
+                module: inputTarget.connection.module,
+                connection: inputTarget.connection,
+                export: inputTarget.export,
+            };
+            if (!resolveTargetFilter(target))
+                return target;
+            let alreadyVisitedOwned = false;
+            for (;;) {
+                const exportsInfo = moduleGraph.getExportsInfo(target.module);
+                const exportInfo = exportsInfo.getExportInfo(target.export[0]);
+                if (!exportInfo)
+                    return target;
+                if (alreadyVisited.has(exportInfo))
+                    return CIRCULAR;
+                const newTarget = exportInfo._getTarget(moduleGraph, resolveTargetFilter, alreadyVisited);
+                if (newTarget === CIRCULAR)
+                    return CIRCULAR;
+                if (!newTarget)
+                    return target;
+                if (target.export.length === 1) {
+                    target = newTarget;
+                    if (!target.export)
+                        return target;
+                }
+                else {
+                    target = {
+                        module: newTarget.module,
+                        connection: newTarget.connection,
+                        export: newTarget.export
+                            ? newTarget.export.concat(target.export.slice(1))
+                            : target.export.slice(1),
+                    };
+                }
+                if (!resolveTargetFilter(target))
+                    return target;
+                if (!alreadyVisitedOwned) {
+                    alreadyVisited = new Set(alreadyVisited);
+                    alreadyVisitedOwned = true;
+                }
+                alreadyVisited.add(exportInfo);
+            }
+        };
+        if (!this._target || this._target.size === 0)
+            return undefined;
+        if (alreadyVisited === null || alreadyVisited === void 0 ? void 0 : alreadyVisited.has(this))
+            return CIRCULAR;
+        const newAlreadyVisited = new Set(alreadyVisited);
+        newAlreadyVisited.add(this);
+        const values = this._getMaxTarget().values();
+        const target = resolveTarget(values.next().value, newAlreadyVisited);
+        if (target === CIRCULAR)
+            return CIRCULAR;
+        if (target === null)
+            return undefined;
+        let result = values.next();
+        while (!result.done) {
+            const t = resolveTarget(result.value, newAlreadyVisited);
+            if (t === CIRCULAR)
+                return CIRCULAR;
+            if (t === null)
+                return undefined;
+            if (t.module !== target.module)
+                return undefined;
+            if (!t.export !== !target.export)
+                return undefined;
+            if (target.export && !(0, ArrayHelpers_1.equals)(t.export, target.export))
+                return undefined;
+            result = values.next();
+        }
+        return target;
+    }
+    moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) {
+        const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
+        if (target === CIRCULAR)
+            return undefined;
+        if (!target)
+            return undefined;
+        const originalTarget = this._getMaxTarget().values().next().value;
+        if (originalTarget.connection === target.connection &&
+            originalTarget.export === target.export) {
+            return undefined;
+        }
+        this._target.clear();
+        this._target.set(undefined, {
+            connection: updateOriginalConnection ? updateOriginalConnection(target) : target.connection,
+            export: target.export,
+            priority: 0,
+        });
+        return target;
+    }
+    createNestedExportsInfo() {
+        if (this.exportsInfoOwned)
+            return this.exportsInfo;
+        this.exportsInfoOwned = true;
+        const oldExportsInfo = this.exportsInfo;
+        this.exportsInfo = new ExportsInfo();
+        this.exportsInfo.setHasProvideInfo();
+        if (oldExportsInfo) {
+            this.exportsInfo.setRedirectNamedTo(oldExportsInfo);
+        }
+        return this.exportsInfo;
+    }
+    getNestedExportsInfo() {
+        return this.exportsInfo;
+    }
+    hasInfo(baseInfo, runtime) {
+        return ((this._usedName && this._usedName !== this.name) ||
+            this.provided ||
+            this.terminalBinding ||
+            this.getUsed(runtime) !== baseInfo.getUsed(runtime));
+    }
+    updateHash(hash, runtime) {
+        this._updateHash(hash, runtime, new Set());
+    }
+    _updateHash(hash, runtime, alreadyVisitedExportsInfo) {
+        hash.update(`${this._usedName || this.name}${this.getUsed(runtime)}${this.provided}${this.terminalBinding}`);
+        if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) {
+            this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
+        }
+    }
+    getUsedInfo() {
+        if (this._globalUsed !== undefined) {
+            switch (this._globalUsed) {
+                case UsageState.Unused:
+                    return 'unused';
+                case UsageState.NoInfo:
+                    return 'no usage info';
+                case UsageState.Unknown:
+                    return 'maybe used (runtime-defined)';
+                case UsageState.Used:
+                    return 'used';
+                case UsageState.OnlyPropertiesUsed:
+                    return 'only properties used';
+            }
+        }
+        else if (this._usedInRuntime !== undefined) {
+            const map = new Map();
+            for (const [runtime, used] of this._usedInRuntime) {
+                const list = map.get(used);
+                if (list !== undefined)
+                    list.push(runtime);
+                else
+                    map.set(used, [runtime]);
+            }
+            // eslint-disable-next-line array-callback-return
+            const specificInfo = Array.from(map, ([used, runtimes]) => {
+                switch (used) {
+                    case UsageState.NoInfo:
+                        return `no usage info in ${runtimes.join(', ')}`;
+                    case UsageState.Unknown:
+                        return `maybe used in ${runtimes.join(', ')} (runtime-defined)`;
+                    case UsageState.Used:
+                        return `used in ${runtimes.join(', ')}`;
+                    case UsageState.OnlyPropertiesUsed:
+                        return `only properties used in ${runtimes.join(', ')}`;
+                }
+            });
+            if (specificInfo.length > 0) {
+                return specificInfo.join('; ');
+            }
+        }
+        return this._hasUseInRuntimeInfo ? 'unused' : 'no usage info';
+    }
+    getProvidedInfo() {
+        switch (this.provided) {
+            case undefined:
+                return 'no provided info';
+            case null:
+                return 'maybe provided (runtime-defined)';
+            case true:
+                return 'provided';
+            case false:
+                return 'not provided';
+        }
+    }
+    getRenameInfo() {
+        if (this._usedName !== null && this._usedName !== this.name) {
+            return `renamed to ${JSON.stringify(this._usedName).slice(1, -1)}`;
+        }
+        switch (this.canMangleProvide) {
+            case undefined:
+                switch (this.canMangleUse) {
+                    case undefined:
+                        return 'missing provision and use info prevents renaming';
+                    case false:
+                        return 'usage prevents renaming (no provision info)';
+                    case true:
+                        return 'missing provision info prevents renaming';
+                }
+                break;
+            case true:
+                switch (this.canMangleUse) {
+                    case undefined:
+                        return 'missing usage info prevents renaming';
+                    case false:
+                        return 'usage prevents renaming';
+                    case true:
+                        return 'could be renamed';
+                }
+                break;
+            case false:
+                switch (this.canMangleUse) {
+                    case undefined:
+                        return 'provision prevents renaming (no use info)';
+                    case false:
+                        return 'usage and provision prevents renaming';
+                    case true:
+                        return 'provision prevents renaming';
+                }
+                break;
+        }
+        throw new Error(`Unexpected flags for getRenameInfo ${this.canMangleProvide} ${this.canMangleUse}`);
+    }
+}
+exports.ExportInfo = ExportInfo;