xhs-mp-pack 1.1.0-beta.0

package/dist/dependencies/commonjs/CommonJsPlugin.js

@@ -0,0 +1,170 @@
+"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 RuntimeModule_1 = __importDefault(require("@/module/RuntimeModule"));
+const SelfModuleFactory_1 = __importDefault(require("@/module/SelfModuleFactory"));
+const Template_1 = require("@/template/Template");
+const ModuleDecoratorDependency_1 = __importDefault(require("@/dependencies/ModuleDecoratorDependency"));
+const RequireHeaderDependency_1 = __importDefault(require("@/dependencies/RequireHeaderDependency"));
+const RequireResolveContextDependency_1 = __importDefault(require("@/dependencies/RequireResolveContextDependency"));
+const RequireResolveDependency_1 = __importDefault(require("@/dependencies/RequireResolveDependency"));
+const RequireResolveHeaderDependency_1 = __importDefault(require("@/dependencies/RequireResolveHeaderDependency"));
+const RuntimeRequirementsDependency_1 = __importDefault(require("@/dependencies/RuntimeRequirementsDependency"));
+const ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const JavascriptParserHelpers_1 = require("@/module/javascript/JavascriptParserHelpers");
+const CommonJsExportsParserPlugin_1 = __importDefault(require("./CommonJsExportsParserPlugin"));
+const CommonJsImportsParserPlugin_1 = __importDefault(require("./CommonJsImportsParserPlugin"));
+const CommonJsSelfReferenceDependency_1 = __importDefault(require("./CommonJsSelfReferenceDependency"));
+const CommonJsRequireDependency_1 = __importDefault(require("./CommonJsRequireDependency"));
+const CommonJsRequireContextDependency_1 = __importDefault(require("./CommonJsRequireContextDependency"));
+const CommonJsFullRequireDependency_1 = __importDefault(require("./CommonJsFullRequireDependency"));
+const CommonJsExportsDependency_1 = __importDefault(require("./CommonJsExportsDependency"));
+const CommonJsExportRequireDependency_1 = __importDefault(require("./CommonJsExportRequireDependency"));
+const PLUGIN_NAME = 'CommonJsPlugin';
+class CommonJsPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { contextModuleFactory, normalModuleFactory }) => {
+            compilation.dependencyFactories.set(CommonJsRequireDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(CommonJsRequireDependency_1.default, new CommonJsRequireDependency_1.default.Template());
+            compilation.dependencyFactories.set(CommonJsFullRequireDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(CommonJsFullRequireDependency_1.default, new CommonJsFullRequireDependency_1.default.Template());
+            compilation.dependencyFactories.set(CommonJsRequireContextDependency_1.default, contextModuleFactory);
+            compilation.dependencyTemplates.set(CommonJsRequireContextDependency_1.default, new CommonJsRequireContextDependency_1.default.Template());
+            compilation.dependencyFactories.set(RequireResolveDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(RequireResolveDependency_1.default, new RequireResolveDependency_1.default.Template());
+            compilation.dependencyFactories.set(RequireResolveContextDependency_1.default, contextModuleFactory);
+            compilation.dependencyTemplates.set(RequireResolveContextDependency_1.default, new RequireResolveContextDependency_1.default.Template());
+            compilation.dependencyTemplates.set(RequireResolveHeaderDependency_1.default, new RequireResolveHeaderDependency_1.default.Template());
+            compilation.dependencyTemplates.set(RequireHeaderDependency_1.default, new RequireHeaderDependency_1.default.Template());
+            compilation.dependencyTemplates.set(CommonJsExportsDependency_1.default, new CommonJsExportsDependency_1.default.Template());
+            compilation.dependencyFactories.set(CommonJsExportRequireDependency_1.default, normalModuleFactory);
+            compilation.dependencyTemplates.set(CommonJsExportRequireDependency_1.default, new CommonJsExportRequireDependency_1.default.Template());
+            const selfFactory = new SelfModuleFactory_1.default(compilation.moduleGraph);
+            compilation.dependencyFactories.set(CommonJsSelfReferenceDependency_1.default, selfFactory);
+            compilation.dependencyTemplates.set(CommonJsSelfReferenceDependency_1.default, new CommonJsSelfReferenceDependency_1.default.Template());
+            compilation.dependencyFactories.set(ModuleDecoratorDependency_1.default, selfFactory);
+            compilation.dependencyTemplates.set(ModuleDecoratorDependency_1.default, new ModuleDecoratorDependency_1.default.Template());
+            compilation.hooks.runtimeRequirementInModule
+                .for(RuntimeGlobals.harmonyModuleDecorator)
+                .tap(PLUGIN_NAME, (module, set) => {
+                set.add(RuntimeGlobals.module);
+                set.add(RuntimeGlobals.requireScope);
+            });
+            compilation.hooks.runtimeRequirementInModule
+                .for(RuntimeGlobals.nodeModuleDecorator)
+                .tap(PLUGIN_NAME, (module, set) => {
+                set.add(RuntimeGlobals.module);
+                set.add(RuntimeGlobals.requireScope);
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.harmonyModuleDecorator)
+                .tap(PLUGIN_NAME, (chunk, set) => {
+                compilation.addRuntimeModule(chunk, new HarmonyModuleDecoratorRuntimeModule());
+            });
+            compilation.hooks.runtimeRequirementInTree
+                .for(RuntimeGlobals.nodeModuleDecorator)
+                .tap(PLUGIN_NAME, (chunk, set) => {
+                compilation.addRuntimeModule(chunk, new NodeModuleDecoratorRuntimeModule());
+            });
+            const handler = (parser, parserOptions) => {
+                if (parserOptions.commonjs !== undefined && !parserOptions.commonjs)
+                    return;
+                parser.hooks.typeof
+                    .for('module')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.toConstantDependency)(parser, JSON.stringify('object')));
+                parser.hooks.expression
+                    .for('require.main')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.toConstantDependency)(parser, `${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}]`, [RuntimeGlobals.moduleCache, RuntimeGlobals.entryModuleId]));
+                parser.hooks.expression.for(RuntimeGlobals.moduleLoaded).tap(PLUGIN_NAME, expr => {
+                    parser.state.module.buildInfo.moduleConcatenationBailout = RuntimeGlobals.moduleLoaded;
+                    const dep = new RuntimeRequirementsDependency_1.default([RuntimeGlobals.moduleLoaded]);
+                    dep.loc = expr.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+                parser.hooks.expression.for(RuntimeGlobals.moduleId).tap(PLUGIN_NAME, expr => {
+                    parser.state.module.buildInfo.moduleConcatenationBailout = RuntimeGlobals.moduleId;
+                    const dep = new RuntimeRequirementsDependency_1.default([RuntimeGlobals.moduleId]);
+                    dep.loc = expr.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+                parser.hooks.evaluateIdentifier.for('module.hot').tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.evaluateToIdentifier)('module.hot', 'module', () => ['hot'], null));
+                new CommonJsImportsParserPlugin_1.default(parserOptions).apply(parser);
+                new CommonJsExportsParserPlugin_1.default(compilation.moduleGraph).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_DYNAMIC)
+                .tap(PLUGIN_NAME, handler);
+        });
+    }
+}
+class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('harmony module decorator');
+    }
+    generate() {
+        const { runtimeTemplate } = this.compilation;
+        return Template_1.Template.asString([
+            `${RuntimeGlobals.harmonyModuleDecorator} = ${runtimeTemplate.basicFunction('module', [
+                'module = Object.create(module);',
+                'if (!module.children) module.children = [];',
+                "Object.defineProperty(module, 'exports', {",
+                Template_1.Template.indent([
+                    'enumerable: true,',
+                    `set: ${runtimeTemplate.basicFunction('', [
+                        "throw new Error('ES Modules may not assign module.exports or exports. *, Use ESM export syntax, instead: ' + module.id);",
+                    ])}`,
+                ]),
+                '});',
+                'return module;',
+            ])};`,
+        ]);
+    }
+}
+class NodeModuleDecoratorRuntimeModule extends RuntimeModule_1.default {
+    constructor() {
+        super('node module decorator');
+    }
+    /**
+     * @returns {string | null} runtime code
+     */
+    generate() {
+        const { runtimeTemplate } = this.compilation;
+        return Template_1.Template.asString([
+            `${RuntimeGlobals.nodeModuleDecorator} = ${runtimeTemplate.basicFunction('module', [
+                'module.paths = [];',
+                'if (!module.children) module.children = [];',
+                'return module;',
+            ])};`,
+        ]);
+    }
+}
+exports.default = CommonJsPlugin;

package/dist/dependencies/commonjs/CommonJsRequireContextDependency.d.ts

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

package/dist/dependencies/commonjs/CommonJsRequireContextDependency.js

@@ -0,0 +1,37 @@
+"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 ContextDependencyTemplateAsRequireCall_1 = __importDefault(require("@/dependencies/context/ContextDependencyTemplateAsRequireCall"));
+class CommonJsRequireContextDependency extends ContextDependency_1.default {
+    constructor(options, range, valueRange, inShorthand, context) {
+        super(options, context);
+        this.range = range;
+        this.valueRange = valueRange;
+        // inShorthand must be serialized by subclasses that use it
+        this.inShorthand = inShorthand;
+    }
+    get type() {
+        return 'cjs require context';
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        write(this.valueRange);
+        write(this.inShorthand);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.range = read();
+        this.valueRange = read();
+        this.inShorthand = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(CommonJsRequireContextDependency, 'mp-compiler/core/dependencies/CommonJsRequireContextDependency');
+CommonJsRequireContextDependency.Template = ContextDependencyTemplateAsRequireCall_1.default;
+exports.default = CommonJsRequireContextDependency;

package/dist/dependencies/commonjs/CommonJsRequireDependency.d.ts

@@ -0,0 +1,7 @@
+import ModuleDependency from '@/dependencies/ModuleDependency';
+declare class CommonJsRequireDependency extends ModuleDependency {
+    constructor(request: any, range?: any, context?: string);
+    get type(): string;
+    get category(): string;
+}
+export default CommonJsRequireDependency;

package/dist/dependencies/commonjs/CommonJsRequireDependency.js

@@ -0,0 +1,24 @@
+"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 ModuleDependency_1 = __importDefault(require("@/dependencies/ModuleDependency"));
+const ModuleDependencyTemplateAsId_1 = __importDefault(require("@/dependencies/ModuleDependencyTemplateAsId"));
+class CommonJsRequireDependency extends ModuleDependency_1.default {
+    constructor(request, range, context) {
+        super(request);
+        this.range = range;
+        this._context = context;
+    }
+    get type() {
+        return 'cjs require';
+    }
+    get category() {
+        return 'commonjs';
+    }
+}
+CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId_1.default;
+(0, makeSerializable_1.default)(CommonJsRequireDependency, 'mp-compiler/core/dependencies/CommonJsRequireDependency');
+exports.default = CommonJsRequireDependency;

package/dist/dependencies/commonjs/CommonJsSelfReferenceDependency.d.ts

@@ -0,0 +1,15 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class CommonJsSelfReferenceDependency extends NullDependency {
+    range: any;
+    base: any;
+    names: string[];
+    call: boolean;
+    constructor(range: any, base: any, names: any, call: any);
+    get type(): string;
+    get category(): string;
+    getResourceIdentifier(): string;
+    getReferencedExports(moduleGraph: any, runtime: any): string[][];
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default CommonJsSelfReferenceDependency;

package/dist/dependencies/commonjs/CommonJsSelfReferenceDependency.js

@@ -0,0 +1,112 @@
+"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 ArrayHelpers_1 = require("@/base/ArrayHelpers");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+class CommonJsSelfReferenceDependency extends NullDependency_1.default {
+    constructor(range, base, names, call) {
+        super();
+        this.range = range;
+        this.base = base;
+        this.names = names;
+        this.call = call;
+    }
+    get type() {
+        return 'cjs self exports reference';
+    }
+    get category() {
+        return 'self';
+    }
+    getResourceIdentifier() {
+        return `self`;
+    }
+    getReferencedExports(moduleGraph, runtime) {
+        return [this.call ? this.names.slice(0, -1) : this.names];
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.range);
+        write(this.base);
+        write(this.names);
+        write(this.call);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.range = read();
+        this.base = read();
+        this.names = read();
+        this.call = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(CommonJsSelfReferenceDependency, 'mp-compiler/core/dependencies/CommonJsSelfReferenceDependency');
+CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependencyTemplate extends (NullDependency_1.default.Template) {
+    apply(dependency, source, { module, moduleGraph, runtime, runtimeRequirements }) {
+        const dep = dependency;
+        let used;
+        if (dep.names.length === 0) {
+            used = dep.names;
+        }
+        else {
+            used = moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime);
+        }
+        if (!used) {
+            throw new Error('Self-reference dependency has unused export name: This should not happen');
+        }
+        let base;
+        switch (dep.base) {
+            case 'exports':
+                runtimeRequirements.add(RuntimeGlobals.exports);
+                base = module.exportsArgument;
+                break;
+            case 'module.exports':
+                runtimeRequirements.add(RuntimeGlobals.module);
+                base = `${module.moduleArgument}.exports`;
+                break;
+            case 'this':
+                runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+                base = 'this';
+                break;
+            default:
+                throw new Error(`Unsupported base ${dep.base}`);
+        }
+        if (base === dep.base && (0, ArrayHelpers_1.equals)(used, dep.names)) {
+            // Nothing has to be changed
+            // We don't use a replacement for compat reasons
+            // for plugins that update `module._source` which they
+            // shouldn't do!
+            return;
+        }
+        source.replace(dep.range[0], dep.range[1] - 1, `${base}${(0, propertyAccess_1.default)(used)}`);
+    }
+};
+exports.default = CommonJsSelfReferenceDependency;

package/dist/dependencies/const/CachedConstDependency.d.ts

@@ -0,0 +1,12 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class CachedConstDependency extends NullDependency {
+    expression: any;
+    range: any;
+    identifier: string;
+    _hashUpdate: any;
+    constructor(expression: any, range: any, identifier: string);
+    updateHash(hash: any, context: any): void;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default CachedConstDependency;

package/dist/dependencies/const/CachedConstDependency.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const InitFragment_1 = __importDefault(require("@/base/InitFragment"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const NullDependency_1 = __importDefault(require("@/dependencies/NullDependency"));
+const DependencyTemplate_1 = __importDefault(require("../DependencyTemplate"));
+class CachedConstDependency extends NullDependency_1.default {
+    constructor(expression, range, identifier) {
+        super();
+        this.expression = expression;
+        this.range = range;
+        this.identifier = identifier;
+        this._hashUpdate = undefined;
+    }
+    updateHash(hash, context) {
+        if (this._hashUpdate === undefined)
+            this._hashUpdate = `${this.identifier}${this.range}${this.expression}`;
+        hash.update(this._hashUpdate);
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.expression);
+        write(this.range);
+        write(this.identifier);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.expression = read();
+        this.range = read();
+        this.identifier = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(CachedConstDependency, 'mp-compiler/core/dependencies/CachedConstDependency');
+CachedConstDependency.Template = class CachedConstDependencyTemplate extends DependencyTemplate_1.default {
+    apply(dependency, source, { runtimeTemplate, dependencyTemplates, initFragments }) {
+        const dep = dependency;
+        initFragments.push(new InitFragment_1.default(`var ${dep.identifier} = ${dep.expression};\n`, InitFragment_1.default.STAGE_CONSTANTS, 0, `const ${dep.identifier}`));
+        if (typeof dep.range === 'number') {
+            source.insert(dep.range, dep.identifier);
+            return;
+        }
+        source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
+    }
+};
+exports.default = CachedConstDependency;

package/dist/dependencies/const/ConstDependency.d.ts

@@ -0,0 +1,13 @@
+import NullDependency from '@/dependencies/NullDependency';
+declare class ConstDependency extends NullDependency {
+    expression: any;
+    range: any;
+    runtimeRequirements: Set<unknown> | null;
+    _hashUpdate: string | undefined;
+    constructor(expression: any, range: any, runtimeRequirements?: string[] | null);
+    updateHash(hash: any, context: any): void;
+    getModuleEvaluationSideEffectsState(moduleGraph: any): boolean;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ConstDependency;

package/dist/dependencies/const/ConstDependency.js

@@ -0,0 +1,63 @@
+"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 ConstDependency extends NullDependency_1.default {
+    constructor(expression, range, runtimeRequirements) {
+        super();
+        this.expression = expression;
+        this.range = range;
+        this.runtimeRequirements = runtimeRequirements ? new Set(runtimeRequirements) : null;
+        this._hashUpdate = undefined;
+    }
+    updateHash(hash, context) {
+        if (this._hashUpdate === undefined) {
+            let hashUpdate = `${this.range}|${this.expression}`;
+            if (this.runtimeRequirements) {
+                for (const item of this.runtimeRequirements) {
+                    hashUpdate += '|';
+                    hashUpdate += item;
+                }
+            }
+            this._hashUpdate = hashUpdate;
+        }
+        hash.update(this._hashUpdate);
+    }
+    getModuleEvaluationSideEffectsState(moduleGraph) {
+        return false;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.expression);
+        write(this.range);
+        write(this.runtimeRequirements);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.expression = read();
+        this.range = read();
+        this.runtimeRequirements = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ConstDependency, 'mp-compiler/core/dependencies/ConstDependency');
+ConstDependency.Template = class ConstDependencyTemplate extends NullDependency_1.default.Template {
+    apply(dependency, source, templateContext) {
+        const dep = dependency;
+        if (dep.runtimeRequirements) {
+            for (const req of dep.runtimeRequirements) {
+                templateContext.runtimeRequirements.add(req);
+            }
+        }
+        if (typeof dep.range === 'number') {
+            source.insert(dep.range, dep.expression);
+            return;
+        }
+        source.replace(dep.range[0], dep.range[1] - 1, dep.expression);
+    }
+};
+exports.default = ConstDependency;

package/dist/dependencies/context/ContextDependency.d.ts

@@ -0,0 +1,26 @@
+import Dependency from '@/dependencies/Dependency';
+import DependencyTemplate from '@/dependencies/DependencyTemplate';
+import BaseError from '@/base/errors/BaseError';
+declare class ContextDependency extends Dependency {
+    options: any;
+    userRequest: any;
+    critical: boolean;
+    hadGlobalOrStickyRegExp: boolean;
+    request: any;
+    range: any;
+    valueRange: any;
+    inShorthand: any;
+    replaces: any;
+    prepend: any;
+    _requestContext: string | undefined;
+    static Template: typeof DependencyTemplate;
+    constructor(options: any, context?: string);
+    getContext(): string | undefined;
+    get category(): string;
+    couldAffectReferencingModule(): boolean;
+    getResourceIdentifier(): string;
+    getWarnings(moduleGraph: any): BaseError[] | null;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ContextDependency;

package/dist/dependencies/context/ContextDependency.js

@@ -0,0 +1,91 @@
+"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 makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const CriticalDependencyWarning_1 = __importDefault(require("@/base/errors/CriticalDependencyWarning"));
+const regExpToString = r => (r ? `${r}` : '');
+class ContextDependency extends Dependency_1.default {
+    constructor(options, context) {
+        var _a;
+        super();
+        this.options = options;
+        this.userRequest = (_a = this.options) === null || _a === void 0 ? void 0 : _a.request;
+        this.critical = false;
+        this.hadGlobalOrStickyRegExp = false;
+        if (this.options && (this.options.regExp.global || this.options.regExp.sticky)) {
+            this.options = Object.assign(Object.assign({}, this.options), { regExp: null });
+            this.hadGlobalOrStickyRegExp = true;
+        }
+        this.request = undefined;
+        this.range = undefined;
+        this.valueRange = undefined;
+        this.inShorthand = undefined;
+        // TODO refactor this
+        this.replaces = undefined;
+        this._requestContext = context;
+    }
+    getContext() {
+        return this._requestContext;
+    }
+    get category() {
+        return 'commonjs';
+    }
+    couldAffectReferencingModule() {
+        return true;
+    }
+    getResourceIdentifier() {
+        return (`context${this._requestContext || ''}|ctx request${this.options.request} ${this.options.recursive} ` +
+            `${regExpToString(this.options.regExp)} ${regExpToString(this.options.include)} ${regExpToString(this.options.exclude)} ` +
+            `${this.options.mode} ${this.options.chunkName} ` +
+            `${JSON.stringify(this.options.groupOptions)}`);
+    }
+    getWarnings(moduleGraph) {
+        let warnings = super.getWarnings(moduleGraph);
+        if (this.critical) {
+            if (!warnings)
+                warnings = [];
+            warnings.push(new CriticalDependencyWarning_1.default(this.critical));
+        }
+        if (this.hadGlobalOrStickyRegExp) {
+            if (!warnings)
+                warnings = [];
+            warnings.push(new CriticalDependencyWarning_1.default("Contexts can't use RegExps with the 'g' or 'y' flags."));
+        }
+        return warnings;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.options);
+        write(this.userRequest);
+        write(this.critical);
+        write(this.hadGlobalOrStickyRegExp);
+        write(this.request);
+        write(this._requestContext);
+        write(this.range);
+        write(this.valueRange);
+        write(this.prepend);
+        write(this.replaces);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.options = read();
+        this.userRequest = read();
+        this.critical = read();
+        this.hadGlobalOrStickyRegExp = read();
+        this.request = read();
+        this._requestContext = read();
+        this.range = read();
+        this.valueRange = read();
+        this.prepend = read();
+        this.replaces = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ContextDependency, 'mp-compiler/core/dependencies/ContextDependency');
+ContextDependency.Template = DependencyTemplate_1.default;
+exports.default = ContextDependency;

package/dist/dependencies/context/ContextDependencyHelpers.d.ts

@@ -0,0 +1,2 @@
+declare const create: (Dep: any, range: any, param: any, expr: any, options: any, contextOptions: any, parser: any, ...depArgs: any[]) => any;
+export { create };