xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/harmony/HarmonyImportDependencyParserPlugin.js

@@ -0,0 +1,202 @@
+"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.harmonySpecifierTag = exports.HarmonyImportDependencyParserPlugin = exports.getAssertions = void 0;
+const InnerGraph = __importStar(require("@/plugins/optimize/InnerGraph"));
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const HarmonyEvaluatedImportSpecifierDependency_1 = __importDefault(require("./HarmonyEvaluatedImportSpecifierDependency"));
+const HarmonyImportDependency_1 = require("./HarmonyImportDependency");
+const HarmonyImportSideEffectDependency_1 = __importDefault(require("./HarmonyImportSideEffectDependency"));
+const HarmonyImportSpecifierDependency_1 = __importDefault(require("./HarmonyImportSpecifierDependency"));
+const harmonySpecifierTag = Symbol('harmony import');
+exports.harmonySpecifierTag = harmonySpecifierTag;
+function getAssertions(node) {
+    // TODO remove cast when @types/estree has been updated to import assertions
+    const assertions = node.assertions;
+    if (assertions === undefined) {
+        return undefined;
+    }
+    const result = {};
+    for (const assertion of assertions) {
+        const key = assertion.key.type === 'Identifier' ? assertion.key.name : assertion.key.value;
+        result[key] = assertion.value.value;
+    }
+    return result;
+}
+exports.getAssertions = getAssertions;
+class HarmonyImportDependencyParserPlugin {
+    constructor(options) {
+        this.exportPresenceMode =
+            options.importExportsPresence !== undefined
+                ? HarmonyImportDependency_1.ExportPresenceModes.fromUserOption(options.importExportsPresence)
+                : options.exportsPresence !== undefined
+                    ? HarmonyImportDependency_1.ExportPresenceModes.fromUserOption(options.exportsPresence)
+                    : options.strictExportPresence
+                        ? HarmonyImportDependency_1.ExportPresenceModes.ERROR
+                        : HarmonyImportDependency_1.ExportPresenceModes.AUTO;
+        this.strictThisContextOnImports = options.strictThisContextOnImports;
+    }
+    apply(parser) {
+        const { exportPresenceMode } = this;
+        function getNonOptionalPart(members, membersOptionals) {
+            let i = 0;
+            while (i < members.length && membersOptionals[i] === false)
+                i++;
+            return i !== members.length ? members.slice(0, i) : members;
+        }
+        function getNonOptionalMemberChain(node, count) {
+            while (count--)
+                node = node.object;
+            return node;
+        }
+        parser.hooks.isPure.for('Identifier').tap('HarmonyImportDependencyParserPlugin', expression => {
+            const expr = expression;
+            if (parser.isVariableDefined(expr.name) ||
+                parser.getTagData(expr.name, harmonySpecifierTag)) {
+                return true;
+            }
+        });
+        parser.hooks.import.tap('HarmonyImportDependencyParserPlugin', (statement, source) => {
+            parser.state.lastHarmonyImportOrder = (parser.state.lastHarmonyImportOrder || 0) + 1;
+            const clearDep = new ConstDependency_1.default(parser.isAsiPosition(statement.range[0]) ? ';' : '', statement.range);
+            clearDep.loc = statement.loc;
+            parser.state.module.addPresentationalDependency(clearDep);
+            parser.unsetAsiPosition(statement.range[1]);
+            const assertions = getAssertions(statement);
+            const sideEffectDep = new HarmonyImportSideEffectDependency_1.default(source, parser.state.lastHarmonyImportOrder, assertions);
+            sideEffectDep.loc = statement.loc;
+            parser.state.module.addDependency(sideEffectDep);
+            return true;
+        });
+        parser.hooks.importSpecifier.tap('HarmonyImportDependencyParserPlugin', (statement, source, id, name) => {
+            const ids = id === null ? [] : [id];
+            parser.tagVariable(name, harmonySpecifierTag, {
+                name,
+                source,
+                ids,
+                sourceOrder: parser.state.lastHarmonyImportOrder,
+                assertions: getAssertions(statement),
+            });
+            return true;
+        });
+        parser.hooks.binaryExpression.tap('HarmonyImportDependencyParserPlugin', expression => {
+            if (expression.operator !== 'in')
+                return;
+            const leftPartEvaluated = parser.evaluateExpression(expression.left);
+            if (leftPartEvaluated.couldHaveSideEffects())
+                return;
+            const leftPart = leftPartEvaluated.asString();
+            if (!leftPart)
+                return;
+            const rightPart = parser.evaluateExpression(expression.right);
+            if (!rightPart.isIdentifier())
+                return;
+            const rootInfo = rightPart.rootInfo;
+            if (typeof rootInfo === 'string' ||
+                !rootInfo ||
+                !rootInfo.tagInfo ||
+                rootInfo.tagInfo.tag !== harmonySpecifierTag)
+                return;
+            const settings = rootInfo.tagInfo.data;
+            const members = rightPart.getMembers();
+            const dep = new HarmonyEvaluatedImportSpecifierDependency_1.default(settings.source, settings.sourceOrder, settings.ids.concat(members).concat([leftPart]), settings.name, expression.range, settings.assertions, 'in');
+            dep.directImport = members.length === 0;
+            dep.asiSafe = !parser.isAsiPosition(expression.range[0]);
+            dep.loc = expression.loc;
+            parser.state.module.addDependency(dep);
+            // eslint-disable-next-line no-return-assign
+            InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+            return true;
+        });
+        parser.hooks.expression
+            .for(harmonySpecifierTag)
+            .tap('HarmonyImportDependencyParserPlugin', expr => {
+            const settings = parser.currentTagData;
+            const dep = new HarmonyImportSpecifierDependency_1.default(settings.source, settings.sourceOrder, settings.ids, settings.name, expr.range, exportPresenceMode, settings.assertions, []);
+            dep.referencedPropertiesInDestructuring = parser.destructuringAssignmentPropertiesFor(expr);
+            dep.shorthand = parser.scope.inShorthand;
+            dep.directImport = true;
+            dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+            dep.loc = expr.loc;
+            dep.call = parser.scope.inTaggedTemplateTag;
+            parser.state.module.addDependency(dep);
+            InnerGraph.onUsage(parser.state, e => {
+                dep.usedByExports = e;
+            });
+            return true;
+        });
+        parser.hooks.expressionMemberChain
+            .for(harmonySpecifierTag)
+            .tap('HarmonyImportDependencyParserPlugin', (expression, members, membersOptionals, memberRanges) => {
+            const settings = parser.currentTagData;
+            const nonOptionalMembers = getNonOptionalPart(members, membersOptionals);
+            const ranges = memberRanges.slice(0, memberRanges.length - (members.length - nonOptionalMembers.length));
+            const expr = nonOptionalMembers !== members
+                ? getNonOptionalMemberChain(expression, members.length - nonOptionalMembers.length)
+                : expression;
+            const ids = settings.ids.concat(nonOptionalMembers);
+            const dep = new HarmonyImportSpecifierDependency_1.default(settings.source, settings.sourceOrder, ids, settings.name, expr.range, exportPresenceMode, settings.assertions, ranges);
+            dep.referencedPropertiesInDestructuring =
+                parser.destructuringAssignmentPropertiesFor(expr);
+            dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+            dep.loc = expr.loc;
+            parser.state.module.addDependency(dep);
+            InnerGraph.onUsage(parser.state, e => {
+                dep.usedByExports = e;
+            });
+            return true;
+        });
+        parser.hooks.callMemberChain
+            .for(harmonySpecifierTag)
+            .tap('HarmonyImportDependencyParserPlugin', (expression, members, membersOptionals, memberRanges) => {
+            const { arguments: args, callee } = expression;
+            const settings = parser.currentTagData;
+            const nonOptionalMembers = getNonOptionalPart(members, membersOptionals);
+            const ranges = memberRanges.slice(0, memberRanges.length - (members.length - nonOptionalMembers.length));
+            const expr = nonOptionalMembers !== members
+                ? getNonOptionalMemberChain(callee, members.length - nonOptionalMembers.length)
+                : callee;
+            const ids = settings.ids.concat(nonOptionalMembers);
+            const dep = new HarmonyImportSpecifierDependency_1.default(settings.source, settings.sourceOrder, ids, settings.name, expr.range, exportPresenceMode, settings.assertions, ranges);
+            dep.directImport = members.length === 0;
+            dep.call = true;
+            dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+            // only in case when we strictly follow the spec we need a special case here
+            dep.namespaceObjectAsContext = members.length > 0 && this.strictThisContextOnImports;
+            dep.loc = expr.loc;
+            parser.state.module.addDependency(dep);
+            if (args)
+                parser.walkExpressions(args);
+            InnerGraph.onUsage(parser.state, e => {
+                dep.usedByExports = e;
+            });
+            return true;
+        });
+    }
+}
+exports.HarmonyImportDependencyParserPlugin = HarmonyImportDependencyParserPlugin;

package/dist/dependencies/harmony/HarmonyImportSideEffectDependency.d.ts

@@ -0,0 +1,8 @@
+import { HarmonyImportDependency } from './HarmonyImportDependency';
+declare class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
+    constructor(request: any, sourceOrder: number, assertions?: any);
+    get type(): string;
+    getCondition(moduleGraph: any): (connection: any) => any;
+    getModuleEvaluationSideEffectsState(moduleGraph: any): any;
+}
+export default HarmonyImportSideEffectDependency;

package/dist/dependencies/harmony/HarmonyImportSideEffectDependency.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const HarmonyImportDependency_1 = require("./HarmonyImportDependency");
+class HarmonyImportSideEffectDependency extends HarmonyImportDependency_1.HarmonyImportDependency {
+    constructor(request, sourceOrder, assertions) {
+        super(request, sourceOrder, assertions);
+    }
+    get type() {
+        return 'harmony side effect evaluation';
+    }
+    getCondition(moduleGraph) {
+        return connection => {
+            const refModule = connection.resolvedModule;
+            if (!refModule)
+                return true;
+            return refModule.getSideEffectsConnectionState(moduleGraph);
+        };
+    }
+    getModuleEvaluationSideEffectsState(moduleGraph) {
+        const refModule = moduleGraph.getModule(this);
+        if (!refModule)
+            return true;
+        return refModule.getSideEffectsConnectionState(moduleGraph);
+    }
+}
+(0, makeSerializable_1.default)(HarmonyImportSideEffectDependency, 'mp-compiler/core/dependencies/HarmonyImportSideEffectDependency');
+HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDependencyTemplate extends (HarmonyImportDependency_1.HarmonyImportDependency.Template) {
+    apply(dependency, source, templateContext) {
+        const { moduleGraph, concatenationScope } = templateContext;
+        if (concatenationScope) {
+            const module = moduleGraph.getModule(dependency);
+            if (concatenationScope.isModuleInScope(module)) {
+                return;
+            }
+        }
+        super.apply(dependency, source, templateContext);
+    }
+};
+exports.default = HarmonyImportSideEffectDependency;

package/dist/dependencies/harmony/HarmonyImportSpecifierDependency.d.ts

@@ -0,0 +1,33 @@
+import { HarmonyImportDependency } from './HarmonyImportDependency';
+declare class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
+    referencedPropertiesInDestructuring: any;
+    shorthand: any;
+    directImport: boolean | undefined;
+    asiSafe: boolean | undefined;
+    call: any;
+    usedByExports: any;
+    namespaceObjectAsContext: any;
+    ids: any;
+    name: any;
+    idRanges: any;
+    exportPresenceMode: any;
+    constructor(request: any, sourceOrder: any, ids: any, name: any, range: any, exportPresenceMode: any, assertions?: any, idRanges?: any);
+    get id(): void;
+    getId(): void;
+    setId(): void;
+    get type(): string;
+    getIds(moduleGraph: any): any;
+    setIds(moduleGraph: any, ids: any): void;
+    getCondition(moduleGraph: any): false | ((connections: any, runtime: any) => boolean) | null;
+    getModuleEvaluationSideEffectsState(moduleGraph: any): boolean;
+    getReferencedExports(moduleGraph: any, runtime: any): any;
+    _getReferencedExportsInDestructuring(ids?: string[]): any;
+    _getEffectiveExportPresenceLevel(moduleGraph: any): any;
+    getWarnings(moduleGraph: any): import("../../base/errors/HarmonyLinkingError").default[] | null | undefined;
+    getErrors(moduleGraph: any): import("../../base/errors/HarmonyLinkingError").default[] | null | undefined;
+    _getErrors(moduleGraph: any): import("../../base/errors/HarmonyLinkingError").default[] | undefined;
+    getNumberOfIdOccurrences(): number;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default HarmonyImportSpecifierDependency;

package/dist/dependencies/harmony/HarmonyImportSpecifierDependency.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Dependency_1 = __importDefault(require("@/dependencies/Dependency"));
+const InnerGraph_1 = require("@/plugins/optimize/InnerGraph");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const HarmonyImportDependency_1 = require("./HarmonyImportDependency");
+const idsSymbol = Symbol('HarmonyImportSpecifierDependency.ids');
+class HarmonyImportSpecifierDependency extends HarmonyImportDependency_1.HarmonyImportDependency {
+    constructor(request, sourceOrder, ids, name, range, exportPresenceMode, assertions, idRanges) {
+        super(request, sourceOrder, assertions);
+        this.ids = ids;
+        this.name = name;
+        this.range = range;
+        this.idRanges = idRanges;
+        this.exportPresenceMode = exportPresenceMode;
+        this.namespaceObjectAsContext = false;
+        this.call = undefined;
+        this.directImport = undefined;
+        this.shorthand = undefined;
+        this.asiSafe = undefined;
+        this.usedByExports = undefined;
+        this.referencedPropertiesInDestructuring = undefined;
+    }
+    // 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 import specifier';
+    }
+    getIds(moduleGraph) {
+        const meta = moduleGraph.getMetaIfExisting(this);
+        if (meta === undefined)
+            return this.ids;
+        const ids = meta[idsSymbol];
+        return ids !== undefined ? ids : this.ids;
+    }
+    setIds(moduleGraph, ids) {
+        moduleGraph.getMeta(this)[idsSymbol] = ids;
+    }
+    getCondition(moduleGraph) {
+        return (0, InnerGraph_1.getDependencyUsedByExportsCondition)(this, this.usedByExports, moduleGraph);
+    }
+    getModuleEvaluationSideEffectsState(moduleGraph) {
+        return false;
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        let ids = this.getIds(moduleGraph);
+        if (ids.length === 0)
+            return this._getReferencedExportsInDestructuring();
+        let namespaceObjectAsContext = this.namespaceObjectAsContext;
+        if (ids[0] === 'default') {
+            const selfModule = moduleGraph.getParentModule(this);
+            const importedModule = moduleGraph.getModule(this);
+            switch (importedModule.getExportsType(moduleGraph, selfModule.buildMeta.strictHarmonyModule)) {
+                case 'default-only':
+                case 'default-with-named':
+                    if (ids.length === 1)
+                        return this._getReferencedExportsInDestructuring();
+                    ids = ids.slice(1);
+                    namespaceObjectAsContext = true;
+                    break;
+                case 'dynamic':
+                    return Dependency_1.default.EXPORTS_OBJECT_REFERENCED;
+            }
+        }
+        if (this.call && !this.directImport && (namespaceObjectAsContext || ids.length > 1)) {
+            if (ids.length === 1)
+                return Dependency_1.default.EXPORTS_OBJECT_REFERENCED;
+            ids = ids.slice(0, -1);
+        }
+        return this._getReferencedExportsInDestructuring(ids);
+    }
+    _getReferencedExportsInDestructuring(ids) {
+        if (this.referencedPropertiesInDestructuring) {
+            const refs = [];
+            for (const key of this.referencedPropertiesInDestructuring) {
+                refs.push({
+                    name: ids ? ids.concat([key]) : [key],
+                    canMangle: false,
+                });
+            }
+            return refs;
+        }
+        return ids ? [ids] : Dependency_1.default.EXPORTS_OBJECT_REFERENCED;
+    }
+    _getEffectiveExportPresenceLevel(moduleGraph) {
+        if (this.exportPresenceMode !== HarmonyImportDependency_1.ExportPresenceModes.AUTO)
+            return this.exportPresenceMode;
+        const buildMeta = moduleGraph.getParentModule(this).buildMeta;
+        return 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);
+        return this.getLinkingErrors(moduleGraph, ids, `(imported as '${this.name}')`);
+    }
+    getNumberOfIdOccurrences() {
+        return 0;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.ids);
+        write(this.name);
+        write(this.range);
+        write(this.idRanges);
+        write(this.exportPresenceMode);
+        write(this.namespaceObjectAsContext);
+        write(this.call);
+        write(this.directImport);
+        write(this.shorthand);
+        write(this.asiSafe);
+        write(this.usedByExports);
+        write(this.referencedPropertiesInDestructuring);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.ids = read();
+        this.name = read();
+        this.range = read();
+        this.idRanges = read();
+        this.exportPresenceMode = read();
+        this.namespaceObjectAsContext = read();
+        this.call = read();
+        this.directImport = read();
+        this.shorthand = read();
+        this.asiSafe = read();
+        this.usedByExports = read();
+        this.referencedPropertiesInDestructuring = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(HarmonyImportSpecifierDependency, 'mp-compiler/core/dependencies/HarmonyImportSpecifierDependency');
+HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate extends (HarmonyImportDependency_1.HarmonyImportDependency.Template) {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        const { moduleGraph, runtime } = templateContext;
+        const connection = moduleGraph.getConnection(dep);
+        // Skip rendering depending when dependency is conditional
+        if (connection && !connection.isTargetActive(runtime))
+            return;
+        const ids = dep.getIds(moduleGraph); // determine minimal set of IDs.
+        let trimmedIds = this._trimIdsToThoseImported(ids, moduleGraph, dep);
+        let [rangeStart, rangeEnd] = dep.range;
+        if (trimmedIds.length !== ids.length) {
+            // The array returned from dep.idRanges is right-aligned with the array returned from dep.getIds.
+            // Meaning, the two arrays may not always have the same number of elements, but the last element of
+            // dep.idRanges corresponds to [the expression fragment to the left of] the last element of dep.getIds.
+            // Use this to find the correct replacement range based on the number of ids that were trimmed.
+            const idx = dep.idRanges === undefined
+                ? -1 /* trigger failure case below */
+                : dep.idRanges.length + (trimmedIds.length - ids.length);
+            if (idx < 0 || idx >= dep.idRanges.length) {
+                // cspell:ignore minifiers
+                // Should not happen but we can't throw an error here because of backward compatibility with
+                // external plugins in wp5.  Instead, we just disable trimming for now.  This may break some minifiers.
+                trimmedIds = ids;
+                // TODO webpack 6 remove the "trimmedIds = ids" above and uncomment the following line instead.
+                // throw new Error("Missing range starts data for id replacement trimming.");
+            }
+            else {
+                ;
+                [rangeStart, rangeEnd] = dep.idRanges[idx];
+            }
+        }
+        const exportExpr = this._getCodeForIds(dep, source, templateContext, trimmedIds);
+        if (dep.shorthand) {
+            source.insert(rangeEnd, `: ${exportExpr}`);
+        }
+        else {
+            source.replace(rangeStart, rangeEnd - 1, exportExpr);
+        }
+    }
+    _trimIdsToThoseImported(ids, moduleGraph, dependency) {
+        let trimmedIds = [];
+        const exportsInfo = moduleGraph.getExportsInfo(moduleGraph.getModule(dependency));
+        let currentExportsInfo = exportsInfo;
+        for (let i = 0; i < ids.length; i++) {
+            if (i === 0 && ids[i] === 'default') {
+                continue; // ExportInfo for the next level under default is still at the root ExportsInfo, so don't advance currentExportsInfo
+            }
+            const exportInfo = currentExportsInfo.getExportInfo(ids[i]);
+            if (exportInfo.provided === false) {
+                // json imports have nested ExportInfo for elements that things that are not actually exported, so check .provided
+                trimmedIds = ids.slice(0, i);
+                break;
+            }
+            const nestedInfo = exportInfo.getNestedExportsInfo();
+            if (!nestedInfo) {
+                // once all nested exports are traversed, the next item is the actual import so stop there
+                trimmedIds = ids.slice(0, i + 1);
+                break;
+            }
+            currentExportsInfo = nestedInfo;
+        }
+        // Never trim to nothing.  This can happen for invalid imports (e.g. import { notThere } from "./module", or import { anything } from "./missingModule")
+        return trimmedIds.length ? trimmedIds : ids;
+    }
+    _getCodeForIds(dep, source, templateContext, ids) {
+        const { moduleGraph, module, runtime, concatenationScope } = templateContext;
+        const connection = moduleGraph.getConnection(dep);
+        let exportExpr;
+        if (connection && concatenationScope && concatenationScope.isModuleInScope(connection.module)) {
+            if (ids.length === 0) {
+                exportExpr = concatenationScope.createModuleReference(connection.module, {
+                    asiSafe: dep.asiSafe,
+                });
+            }
+            else if (dep.namespaceObjectAsContext && ids.length === 1) {
+                exportExpr =
+                    concatenationScope.createModuleReference(connection.module, {
+                        asiSafe: dep.asiSafe,
+                    }) + (0, propertyAccess_1.default)(ids);
+            }
+            else {
+                exportExpr = concatenationScope.createModuleReference(connection.module, {
+                    ids,
+                    call: dep.call,
+                    directImport: dep.directImport,
+                    asiSafe: dep.asiSafe,
+                });
+            }
+        }
+        else {
+            super.apply(dep, source, templateContext);
+            const { runtimeTemplate, initFragments, runtimeRequirements } = templateContext;
+            exportExpr = runtimeTemplate.exportFromImport({
+                moduleGraph,
+                module: moduleGraph.getModule(dep),
+                request: dep.request,
+                exportName: ids,
+                originModule: module,
+                asiSafe: dep.shorthand ? true : dep.asiSafe,
+                isCall: dep.call,
+                callContext: !dep.directImport,
+                defaultInterop: true,
+                importVar: dep.getImportVar(moduleGraph),
+                initFragments,
+                runtime,
+                runtimeRequirements,
+            });
+        }
+        return exportExpr;
+    }
+};
+exports.default = HarmonyImportSpecifierDependency;

package/dist/dependencies/harmony/HarmonyModulesPlugin.d.ts

@@ -0,0 +1,6 @@
+declare class HarmonyModulesPlugin {
+    options: any;
+    constructor(options: any);
+    apply(compiler: any): void;
+}
+export default HarmonyModulesPlugin;

package/dist/dependencies/harmony/HarmonyModulesPlugin.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const HarmonyAcceptDependency_1 = __importDefault(require("./HarmonyAcceptDependency"));
+const HarmonyAcceptImportDependency_1 = __importDefault(require("./HarmonyAcceptImportDependency"));
+const HarmonyCompatibilityDependency_1 = __importDefault(require("./HarmonyCompatibilityDependency"));
+const HarmonyEvaluatedImportSpecifierDependency_1 = __importDefault(require("./HarmonyEvaluatedImportSpecifierDependency"));
+const HarmonyExportExpressionDependency_1 = __importDefault(require("./HarmonyExportExpressionDependency"));
+const HarmonyExportHeaderDependency_1 = __importDefault(require("./HarmonyExportHeaderDependency"));
+const HarmonyExportImportedSpecifierDependency_1 = require("./HarmonyExportImportedSpecifierDependency");
+const HarmonyExportSpecifierDependency_1 = __importDefault(require("./HarmonyExportSpecifierDependency"));
+const HarmonyImportSideEffectDependency_1 = __importDefault(require("./HarmonyImportSideEffectDependency"));
+const HarmonyImportSpecifierDependency_1 = __importDefault(require("./HarmonyImportSpecifierDependency"));
+const HarmonyDetectionParserPlugin_1 = __importDefault(require("./HarmonyDetectionParserPlugin"));
+const HarmonyExportDependencyParserPlugin_1 = __importDefault(require("./HarmonyExportDependencyParserPlugin"));
+const HarmonyImportDependencyParserPlugin_1 = require("./HarmonyImportDependencyParserPlugin");
+const HarmonyTopLevelThisParserPlugin_1 = __importDefault(require("./HarmonyTopLevelThisParserPlugin"));
+const PLUGIN_NAME = 'HarmonyModulesPlugin';
+class HarmonyModulesPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            compilation.dependencyTemplates.set(HarmonyCompatibilityDependency_1.default, new HarmonyCompatibilityDependency_1.default.Template());
+            compilation.dependencyFactories.set(HarmonyImportSideEffectDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(HarmonyImportSideEffectDependency_1.default, new HarmonyImportSideEffectDependency_1.default.Template());
+            compilation.dependencyFactories.set(HarmonyImportSpecifierDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(HarmonyImportSpecifierDependency_1.default, new HarmonyImportSpecifierDependency_1.default.Template());
+            compilation.dependencyFactories.set(HarmonyEvaluatedImportSpecifierDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(HarmonyEvaluatedImportSpecifierDependency_1.default, new HarmonyEvaluatedImportSpecifierDependency_1.default.Template());
+            compilation.dependencyTemplates.set(HarmonyExportHeaderDependency_1.default, new HarmonyExportHeaderDependency_1.default.Template());
+            compilation.dependencyTemplates.set(HarmonyExportExpressionDependency_1.default, new HarmonyExportExpressionDependency_1.default.Template());
+            compilation.dependencyTemplates.set(HarmonyExportSpecifierDependency_1.default, new HarmonyExportSpecifierDependency_1.default.Template());
+            compilation.dependencyFactories.set(HarmonyExportImportedSpecifierDependency_1.HarmonyExportImportedSpecifierDependency, normalModuleFactory);
+            compilation.dependencyTemplates.set(HarmonyExportImportedSpecifierDependency_1.HarmonyExportImportedSpecifierDependency, new HarmonyExportImportedSpecifierDependency_1.HarmonyExportImportedSpecifierDependency.Template());
+            compilation.dependencyTemplates.set(HarmonyAcceptDependency_1.default, new HarmonyAcceptDependency_1.default.Template());
+            compilation.dependencyFactories.set(HarmonyAcceptImportDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(HarmonyAcceptImportDependency_1.default, new HarmonyAcceptImportDependency_1.default.Template());
+            const handler = (parser, parserOptions) => {
+                // TODO webpack 6: rename harmony to esm or module
+                if (parserOptions.harmony !== undefined && !parserOptions.harmony)
+                    return;
+                new HarmonyDetectionParserPlugin_1.default(this.options).apply(parser);
+                new HarmonyImportDependencyParserPlugin_1.HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
+                new HarmonyExportDependencyParserPlugin_1.default(parserOptions).apply(parser);
+                new HarmonyTopLevelThisParserPlugin_1.default().apply(parser);
+            };
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM).tap(PLUGIN_NAME, handler);
+        });
+    }
+}
+exports.default = HarmonyModulesPlugin;

package/dist/dependencies/harmony/HarmonyTopLevelThisParserPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class HarmonyTopLevelThisParserPlugin {
+    apply(parser: any): void;
+}
+export default HarmonyTopLevelThisParserPlugin;