xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/LocalModulesHelpers.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalModule = exports.addLocalModule = void 0;
+const LocalModule_1 = __importDefault(require("./LocalModule"));
+const lookup = (parent, mod) => {
+    if (mod.charAt(0) !== '.')
+        return mod;
+    const path = parent.split('/');
+    const segments = mod.split('/');
+    path.pop();
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if (seg === '..') {
+            path.pop();
+        }
+        else if (seg !== '.') {
+            path.push(seg);
+        }
+    }
+    return path.join('/');
+};
+const addLocalModule = (state, name) => {
+    if (!state.localModules) {
+        state.localModules = [];
+    }
+    const m = new LocalModule_1.default(name, state.localModules.length);
+    state.localModules.push(m);
+    return m;
+};
+exports.addLocalModule = addLocalModule;
+const getLocalModule = (state, name, namedModule) => {
+    if (!state.localModules)
+        return null;
+    if (namedModule) {
+        // resolve dependency name relative to the defining named module
+        name = lookup(namedModule, name);
+    }
+    for (let i = 0; i < state.localModules.length; i++) {
+        if (state.localModules[i].name === name) {
+            return state.localModules[i];
+        }
+    }
+    return null;
+};
+exports.getLocalModule = getLocalModule;

package/dist/dependencies/ModuleDecoratorDependency.d.ts

@@ -0,0 +1,15 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class ModuleDecoratorDependency extends NullDependency {
+    decorator: string;
+    allowExportsAccess: boolean;
+    _hashUpdate: string | undefined;
+    constructor(decorator: string, allowExportsAccess: boolean);
+    get type(): string;
+    get category(): string;
+    getResourceIdentifier(): string;
+    getReferencedExports(moduleGraph: any, runtime: any): any;
+    updateHash(hash: any, context: any): void;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ModuleDecoratorDependency;

package/dist/dependencies/ModuleDecoratorDependency.js

@@ -0,0 +1,85 @@
+"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 });
+const Dependency_1 = __importDefault(require("@/dependencies/Dependency"));
+const InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+class ModuleDecoratorDependency extends NullDependency_1.default {
+    constructor(decorator, allowExportsAccess) {
+        super();
+        this.decorator = decorator;
+        this.allowExportsAccess = allowExportsAccess;
+        this._hashUpdate = undefined;
+    }
+    get type() {
+        return 'module decorator';
+    }
+    get category() {
+        return 'self';
+    }
+    getResourceIdentifier() {
+        return `self`;
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        return this.allowExportsAccess
+            ? Dependency_1.default.EXPORTS_OBJECT_REFERENCED
+            : Dependency_1.default.NO_EXPORTS_REFERENCED;
+    }
+    updateHash(hash, context) {
+        if (this._hashUpdate === undefined) {
+            this._hashUpdate = `${this.decorator}${this.allowExportsAccess}`;
+        }
+        hash.update(this._hashUpdate);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.decorator);
+        write(this.allowExportsAccess);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.decorator = read();
+        this.allowExportsAccess = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ModuleDecoratorDependency, 'mp-compiler/core/dependencies/ModuleDecoratorDependency');
+ModuleDecoratorDependency.Template = class ModuleDecoratorDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { module, chunkGraph, initFragments, runtimeRequirements }) {
+        const dep = dependency;
+        runtimeRequirements.add(RuntimeGlobals.moduleLoaded);
+        runtimeRequirements.add(RuntimeGlobals.moduleId);
+        runtimeRequirements.add(RuntimeGlobals.module);
+        runtimeRequirements.add(dep.decorator);
+        initFragments.push(new InitFragment_1.default(`/* module decorator */ ${module.moduleArgument} = ${dep.decorator}(${module.moduleArgument});\n`, InitFragment_1.default.STAGE_PROVIDES, 0, `module decorator ${chunkGraph.getModuleId(module)}`));
+    }
+};
+exports.default = ModuleDecoratorDependency;

package/dist/dependencies/ModuleDependency.d.ts

@@ -0,0 +1,16 @@
+import Dependency from '@/dependencies/Dependency';
+declare class ModuleDependency extends Dependency {
+    static Template: any;
+    request: any;
+    range: any;
+    assertions: any;
+    _context: any;
+    constructor(request: any);
+    getContext(): any;
+    getResourceIdentifier(): string;
+    couldAffectReferencingModule(): boolean;
+    createIgnoredModule(context: any): any;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ModuleDependency;

package/dist/dependencies/ModuleDependency.js

@@ -0,0 +1,53 @@
+"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 DependencyTemplate_1 = __importDefault(require("@/dependencies/DependencyTemplate"));
+const RawModule_1 = __importDefault(require("@/module/RawModule"));
+class ModuleDependency extends Dependency_1.default {
+    constructor(request) {
+        super();
+        this.request = request;
+        this.userRequest = request;
+        this.range = undefined;
+        // assertions must be serialized by subclasses that use it
+        this.assertions = undefined;
+        this._context = undefined;
+    }
+    getContext() {
+        return this._context;
+    }
+    getResourceIdentifier() {
+        let str = `context${this._context || ''}|module${this.request}`;
+        if (this.assertions !== undefined) {
+            str += JSON.stringify(this.assertions);
+        }
+        return str;
+    }
+    couldAffectReferencingModule() {
+        return true;
+    }
+    createIgnoredModule(context) {
+        return new RawModule_1.default('/* (ignored) */', `ignored|${context}|${this.request}`, `${this.request} (ignored)`);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.request);
+        write(this.userRequest);
+        write(this._context);
+        write(this.range);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.request = read();
+        this.userRequest = read();
+        this._context = read();
+        this.range = read();
+        super.deserialize(context);
+    }
+}
+ModuleDependency.Template = DependencyTemplate_1.default;
+exports.default = ModuleDependency;

package/dist/dependencies/ModuleDependencyTemplateAsId.d.ts

@@ -0,0 +1,9 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare class ModuleDependencyTemplateAsId extends ModuleDependency.Template {
+    apply(dependency: any, source: any, { runtimeTemplate, moduleGraph, chunkGraph }: {
+        runtimeTemplate: any;
+        moduleGraph: any;
+        chunkGraph: any;
+    }): void;
+}
+export default ModuleDependencyTemplateAsId;

package/dist/dependencies/ModuleDependencyTemplateAsId.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+class ModuleDependencyTemplateAsId extends ModuleDependency_1.default.Template {
+    apply(dependency, source, { runtimeTemplate, moduleGraph, chunkGraph }) {
+        const dep = dependency;
+        if (!dep.range)
+            return;
+        const content = runtimeTemplate.moduleId({
+            module: moduleGraph.getModule(dep),
+            chunkGraph,
+            request: dep.request,
+            weak: dep.weak,
+        });
+        source.replace(dep.range[0], dep.range[1] - 1, content);
+    }
+}
+exports.default = ModuleDependencyTemplateAsId;

package/dist/dependencies/ModuleDependencyTemplateAsRequireId.d.ts

@@ -0,0 +1,10 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare class ModuleDependencyTemplateAsRequireId extends ModuleDependency.Template {
+    apply(dependency: any, source: any, { runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }: {
+        runtimeTemplate: any;
+        moduleGraph: any;
+        chunkGraph: any;
+        runtimeRequirements: any;
+    }): void;
+}
+export default ModuleDependencyTemplateAsRequireId;

package/dist/dependencies/ModuleDependencyTemplateAsRequireId.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+class ModuleDependencyTemplateAsRequireId extends ModuleDependency_1.default.Template {
+    apply(dependency, source, { runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }) {
+        const dep = dependency;
+        if (!dep.range)
+            return;
+        const content = runtimeTemplate.moduleExports({
+            module: moduleGraph.getModule(dep),
+            chunkGraph,
+            request: dep.request,
+            weak: dep.weak,
+            runtimeRequirements,
+        });
+        source.replace(dep.range[0], dep.range[1] - 1, content);
+    }
+}
+exports.default = ModuleDependencyTemplateAsRequireId;

package/dist/dependencies/NullDependency.d.ts

@@ -0,0 +1,7 @@
+import Dependency from './Dependency';
+declare class NullDependency extends Dependency {
+    static Template: any;
+    get type(): string;
+    couldAffectReferencingModule(): boolean;
+}
+export default NullDependency;

package/dist/dependencies/NullDependency.js

@@ -0,0 +1,19 @@
+"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("./Dependency"));
+const DependencyTemplate_1 = __importDefault(require("./DependencyTemplate"));
+class NullDependency extends Dependency_1.default {
+    get type() {
+        return 'null';
+    }
+    couldAffectReferencingModule() {
+        return false;
+    }
+}
+NullDependency.Template = class NullDependencyTemplate extends DependencyTemplate_1.default {
+    apply(dependency, source, templateContext) { }
+};
+exports.default = NullDependency;

package/dist/dependencies/PureExpressionDependency.d.ts

@@ -0,0 +1,12 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class PureExpressionDependency extends NullDependency {
+    range: any;
+    usedByExports: boolean;
+    _hashUpdate: string | undefined;
+    constructor(range: any);
+    updateHash(hash: any, context: any): void;
+    getModuleEvaluationSideEffectsState(moduleGraph: any): boolean;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default PureExpressionDependency;

package/dist/dependencies/PureExpressionDependency.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+class PureExpressionDependency extends NullDependency_1.default {
+    constructor(range) {
+        super();
+        this.range = range;
+        this.usedByExports = false;
+        this._hashUpdate = undefined;
+    }
+    updateHash(hash, context) {
+        if (this._hashUpdate === undefined) {
+            this._hashUpdate = `${this.range}`;
+        }
+        hash.update(this._hashUpdate);
+    }
+    getModuleEvaluationSideEffectsState(moduleGraph) {
+        return false;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        write(this.usedByExports);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.range = read();
+        this.usedByExports = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(PureExpressionDependency, 'mp-compiler/core/dependencies/PureExpressionDependency');
+PureExpressionDependency.Template = class PureExpressionDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { chunkGraph, moduleGraph, runtime, runtimeTemplate, runtimeRequirements }) {
+        const dep = dependency;
+        const usedByExports = dep.usedByExports;
+        if (usedByExports !== false) {
+            const selfModule = moduleGraph.getParentModule(dep);
+            const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+            const runtimeCondition = (0, RuntimeHelpers_1.filterRuntime)(runtime, runtime => {
+                for (const exportName of usedByExports) {
+                    if (exportsInfo.getUsed(exportName, runtime) !== ExportsInfo_1.UsageState.Unused) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+            if (runtimeCondition === true)
+                return;
+            if (runtimeCondition !== false) {
+                const condition = runtimeTemplate.runtimeConditionExpression({
+                    chunkGraph,
+                    runtime,
+                    runtimeCondition,
+                    runtimeRequirements,
+                });
+                source.insert(dep.range[0], `(/* runtime-dependent pure expression or super */ ${condition} ? (`);
+                source.insert(dep.range[1], ') : null)');
+                return;
+            }
+        }
+        source.insert(dep.range[0], `(/* unused pure expression or super */ null && (`);
+        source.insert(dep.range[1], '))');
+    }
+};
+exports.default = PureExpressionDependency;

package/dist/dependencies/RequireHeaderDependency.d.ts

@@ -0,0 +1,8 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class RequireHeaderDependency extends NullDependency {
+    range: any;
+    constructor(range: any);
+    serialize(context: any): void;
+    static deserialize(context: any): RequireHeaderDependency;
+}
+export default RequireHeaderDependency;

package/dist/dependencies/RequireHeaderDependency.js

@@ -0,0 +1,58 @@
+"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 });
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+class RequireHeaderDependency extends NullDependency_1.default {
+    constructor(range) {
+        super();
+        if (!Array.isArray(range))
+            throw new Error('range must be valid');
+        this.range = range;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        super.serialize(context);
+    }
+    static deserialize(context) {
+        const obj = new RequireHeaderDependency(context.read());
+        obj.deserialize(context);
+        return obj;
+    }
+}
+(0, makeSerializable_1.default)(RequireHeaderDependency, 'mp-compiler/core/dependencies/RequireHeaderDependency');
+RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { runtimeRequirements }) {
+        const dep = dependency;
+        runtimeRequirements.add(RuntimeGlobals.require);
+        source.replace(dep.range[0], dep.range[1] - 1, RuntimeGlobals.require);
+    }
+};
+exports.default = RequireHeaderDependency;

package/dist/dependencies/RequireResolveContextDependency.d.ts

@@ -0,0 +1,8 @@
+import ContextDependency from '@/dependencies/context/ContextDependency';
+declare class RequireResolveContextDependency extends ContextDependency {
+    constructor(options: any, range: any, valueRange: any, context: any);
+    get type(): string;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default RequireResolveContextDependency;

package/dist/dependencies/RequireResolveContextDependency.js

@@ -0,0 +1,33 @@
+"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 ContextDependency_1 = __importDefault(require("@/dependencies/context/ContextDependency"));
+const ContextDependencyTemplateAsId_1 = __importDefault(require("@/dependencies/context/ContextDependencyTemplateAsId"));
+class RequireResolveContextDependency extends ContextDependency_1.default {
+    constructor(options, range, valueRange, context) {
+        super(options, context);
+        this.range = range;
+        this.valueRange = valueRange;
+    }
+    get type() {
+        return 'amd require context';
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        write(this.valueRange);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.range = read();
+        this.valueRange = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(RequireResolveContextDependency, 'mp-compiler/core/dependencies/RequireResolveContextDependency');
+RequireResolveContextDependency.Template = ContextDependencyTemplateAsId_1.default;
+exports.default = RequireResolveContextDependency;

package/dist/dependencies/RequireResolveDependency.d.ts

@@ -0,0 +1,10 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare class RequireResolveDependency extends ModuleDependency {
+    range: any;
+    _context: string;
+    constructor(request: string, range: any, context: string);
+    get type(): string;
+    get category(): string;
+    getReferencedExports(moduleGraph: any, runtime: any): any;
+}
+export default RequireResolveDependency;

package/dist/dependencies/RequireResolveDependency.js

@@ -0,0 +1,29 @@
+"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 makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+const ModuleDependencyTemplateAsId_1 = __importDefault(require("./ModuleDependencyTemplateAsId"));
+class RequireResolveDependency extends ModuleDependency_1.default {
+    constructor(request, range, context) {
+        super(request);
+        this.range = range;
+        this._context = context;
+    }
+    get type() {
+        return 'require.resolve';
+    }
+    get category() {
+        return 'commonjs';
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        // This doesn't use any export
+        return Dependency_1.default.NO_EXPORTS_REFERENCED;
+    }
+}
+(0, makeSerializable_1.default)(RequireResolveDependency, 'mp-compiler/core/dependencies/RequireResolveDependency');
+RequireResolveDependency.Template = ModuleDependencyTemplateAsId_1.default;
+exports.default = RequireResolveDependency;

package/dist/dependencies/RequireResolveHeaderDependency.d.ts

@@ -0,0 +1,8 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class RequireResolveHeaderDependency extends NullDependency {
+    range: any[];
+    constructor(range: any);
+    serialize(context: any): void;
+    static deserialize(context: any): RequireResolveHeaderDependency;
+}
+export default RequireResolveHeaderDependency;

package/dist/dependencies/RequireResolveHeaderDependency.js

@@ -0,0 +1,36 @@
+"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 NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+class RequireResolveHeaderDependency extends NullDependency_1.default {
+    constructor(range) {
+        super();
+        if (!Array.isArray(range))
+            throw new Error('range must be valid');
+        this.range = range;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        super.serialize(context);
+    }
+    static deserialize(context) {
+        const obj = new RequireResolveHeaderDependency(context.read());
+        obj.deserialize(context);
+        return obj;
+    }
+}
+(0, makeSerializable_1.default)(RequireResolveHeaderDependency, 'mp-compiler/core/dependencies/RequireResolveHeaderDependency');
+RequireResolveHeaderDependency.Template = class RequireResolveHeaderDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        source.replace(dep.range[0], dep.range[1] - 1, '/*require.resolve*/');
+    }
+    applyAsTemplateArgument(name, dep, source) {
+        source.replace(dep.range[0], dep.range[1] - 1, '/*require.resolve*/');
+    }
+};
+exports.default = RequireResolveHeaderDependency;

package/dist/dependencies/RuntimeRequirementsDependency.d.ts

@@ -0,0 +1,10 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class RuntimeRequirementsDependency extends NullDependency {
+    runtimeRequirements: Set<string>;
+    _hashUpdate: any;
+    constructor(runtimeRequirements: string[]);
+    updateHash(hash: any, context: any): void;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default RuntimeRequirementsDependency;

package/dist/dependencies/RuntimeRequirementsDependency.js

@@ -0,0 +1,40 @@
+"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 NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+class RuntimeRequirementsDependency extends NullDependency_1.default {
+    constructor(runtimeRequirements) {
+        super();
+        this.runtimeRequirements = new Set(runtimeRequirements);
+        this._hashUpdate = undefined;
+    }
+    updateHash(hash, context) {
+        if (this._hashUpdate === undefined) {
+            this._hashUpdate = `${Array.from(this.runtimeRequirements).join()}`;
+        }
+        hash.update(this._hashUpdate);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.runtimeRequirements);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.runtimeRequirements = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(RuntimeRequirementsDependency, 'mp-compiler/core/dependencies/RuntimeRequirementsDependency');
+RuntimeRequirementsDependency.Template = class RuntimeRequirementsDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { runtimeRequirements }) {
+        const dep = dependency;
+        for (const req of dep.runtimeRequirements) {
+            runtimeRequirements.add(req);
+        }
+    }
+};
+exports.default = RuntimeRequirementsDependency;