xhs-mp-pack 1.1.0-beta.0

package/dist/module/Module.js

@@ -0,0 +1,550 @@
+"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 util_1 = __importDefault(require("util"));
+const ChunkGraph_1 = __importDefault(require("@/chunk/ChunkGraph"));
+const DependenciesBlock_1 = __importDefault(require("@/dependencies/DependenciesBlock"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const SetHelpers_1 = require("@/base/SetHelpers");
+const comparators_1 = require("@/base/comparators");
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+const ModuleGraph_1 = __importDefault(require("./ModuleGraph"));
+const EMPTY_RESOLVE_OPTIONS = {};
+let debugId = 1000;
+const DEFAULT_TYPES_UNKNOWN = new Set(['unknown']);
+const DEFAULT_TYPES_JS = new Set(['javascript']);
+const deprecatedNeedRebuild = util_1.default.deprecate((module, context) => module.needRebuild(context.fileSystemInfo.getDeprecatedFileTimestamps(), context.fileSystemInfo.getDeprecatedContextTimestamps()), 'Module.needRebuild is deprecated in favor of Module.needBuild', 'DEP_WEBPACK_MODULE_NEED_REBUILD');
+class Module extends DependenciesBlock_1.default {
+    constructor(type, context = null, layer = null) {
+        super();
+        this.type = type;
+        this.context = context;
+        this.layer = layer;
+        this.needId = true;
+        // Unique Id
+        this.debugId = debugId++;
+        // Info from Factory
+        // @ts-ignore
+        this.resolveOptions = EMPTY_RESOLVE_OPTIONS;
+        this.factoryMeta = undefined;
+        // TODO refactor this -> options object filled from Factory
+        // TODO webpack 6: use an enum
+        this.useSourceMap = false;
+        this.useSimpleSourceMap = false;
+        // Info from Build
+    }
+    // TODO remove in webpack 6
+    // BACKWARD-COMPAT START
+    get id() {
+        return ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.id', 'DEP_WEBPACK_MODULE_ID').getModuleId(this);
+    }
+    set id(value) {
+        if (value === '') {
+            this.needId = false;
+            return;
+        }
+        ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.id', 'DEP_WEBPACK_MODULE_ID').setModuleId(this, value);
+    }
+    get hash() {
+        return ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.hash', 'DEP_WEBPACK_MODULE_HASH').getModuleHash(this, undefined);
+    }
+    get renderedHash() {
+        return ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.renderedHash', 'DEP_WEBPACK_MODULE_RENDERED_HASH').getRenderedModuleHash(this, undefined);
+    }
+    get profile() {
+        return ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.profile', 'DEP_WEBPACK_MODULE_PROFILE').getProfile(this);
+    }
+    set profile(value) {
+        ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.profile', 'DEP_WEBPACK_MODULE_PROFILE').setProfile(this, value);
+    }
+    get index() {
+        return ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.index', 'DEP_WEBPACK_MODULE_INDEX').getPreOrderIndex(this);
+    }
+    set index(value) {
+        ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.index', 'DEP_WEBPACK_MODULE_INDEX').setPreOrderIndex(this, value);
+    }
+    get index2() {
+        return ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.index2', 'DEP_WEBPACK_MODULE_INDEX2').getPostOrderIndex(this);
+    }
+    set index2(value) {
+        ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.index2', 'DEP_WEBPACK_MODULE_INDEX2').setPostOrderIndex(this, value);
+    }
+    get depth() {
+        return ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.depth', 'DEP_WEBPACK_MODULE_DEPTH').getDepth(this);
+    }
+    set depth(value) {
+        ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.depth', 'DEP_WEBPACK_MODULE_DEPTH').setDepth(this, value);
+    }
+    get issuer() {
+        return ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.issuer', 'DEP_WEBPACK_MODULE_ISSUER').getIssuer(this);
+    }
+    set issuer(value) {
+        ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.issuer', 'DEP_WEBPACK_MODULE_ISSUER').setIssuer(this, value);
+    }
+    get usedExports() {
+        return ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.usedExports', 'DEP_WEBPACK_MODULE_USED_EXPORTS').getUsedExports(this, undefined);
+    }
+    get optimizationBailout() {
+        return ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.optimizationBailout', 'DEP_WEBPACK_MODULE_OPTIMIZATION_BAILOUT').getOptimizationBailout(this);
+    }
+    get optional() {
+        return this.isOptional(ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.optional', 'DEP_WEBPACK_MODULE_OPTIONAL'));
+    }
+    addChunk(chunk) {
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.addChunk', 'DEP_WEBPACK_MODULE_ADD_CHUNK');
+        if (chunkGraph.isModuleInChunk(this, chunk))
+            return false;
+        chunkGraph.connectChunkAndModule(chunk, this);
+        return true;
+    }
+    removeChunk(chunk) {
+        return ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.removeChunk', 'DEP_WEBPACK_MODULE_REMOVE_CHUNK').disconnectChunkAndModule(chunk, this);
+    }
+    isInChunk(chunk) {
+        return ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.isInChunk', 'DEP_WEBPACK_MODULE_IS_IN_CHUNK').isModuleInChunk(this, chunk);
+    }
+    isEntryModule() {
+        return ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.isEntryModule', 'DEP_WEBPACK_MODULE_IS_ENTRY_MODULE').isEntryModule(this);
+    }
+    getChunks() {
+        return ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.getChunks', 'DEP_WEBPACK_MODULE_GET_CHUNKS').getModuleChunks(this);
+    }
+    getNumberOfChunks() {
+        return ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.getNumberOfChunks', 'DEP_WEBPACK_MODULE_GET_NUMBER_OF_CHUNKS').getNumberOfModuleChunks(this);
+    }
+    get chunksIterable() {
+        return ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.chunksIterable', 'DEP_WEBPACK_MODULE_CHUNKS_ITERABLE').getOrderedModuleChunksIterable(this, comparators_1.compareChunksById);
+    }
+    isProvided(exportName) {
+        return ModuleGraph_1.default.getModuleGraphForModule(this, 'Module.usedExports', 'DEP_WEBPACK_MODULE_USED_EXPORTS').isExportProvided(this, exportName);
+    }
+    // BACKWARD-COMPAT END
+    get exportsArgument() {
+        var _a;
+        return ((_a = this.buildInfo) === null || _a === void 0 ? void 0 : _a.exportsArgument) || 'exports';
+    }
+    get moduleArgument() {
+        var _a;
+        return ((_a = this.buildInfo) === null || _a === void 0 ? void 0 : _a.moduleArgument) || 'module';
+    }
+    /**
+     * "namespace": Exports is already a namespace object. namespace = exports.
+     * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
+     * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
+     * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+     */
+    getExportsType(moduleGraph, strict) {
+        var _a, _b;
+        switch ((_a = this.buildMeta) === null || _a === void 0 ? void 0 : _a.exportsType) {
+            case 'flagged':
+                return strict ? 'default-with-named' : 'namespace';
+            case 'namespace':
+                return 'namespace';
+            case 'default':
+                switch (this.buildMeta.defaultObject) {
+                    case 'redirect':
+                        return 'default-with-named';
+                    case 'redirect-warn':
+                        return strict ? 'default-only' : 'default-with-named';
+                    default:
+                        return 'default-only';
+                }
+            case 'dynamic': {
+                if (strict)
+                    return 'default-with-named';
+                // Try to figure out value of __esModule by following reexports
+                const handleDefault = () => {
+                    switch (this.buildMeta.defaultObject) {
+                        case 'redirect':
+                        case 'redirect-warn':
+                            return 'default-with-named';
+                        default:
+                            return 'default-only';
+                    }
+                };
+                const exportInfo = moduleGraph.getReadOnlyExportInfo(this, '__esModule');
+                if (exportInfo.provided === false) {
+                    return handleDefault();
+                }
+                const target = exportInfo.getTarget(moduleGraph);
+                if (!target ||
+                    !target.export ||
+                    target.export.length !== 1 ||
+                    target.export[0] !== '__esModule') {
+                    return 'dynamic';
+                }
+                switch ((_b = target.module.buildMeta) === null || _b === void 0 ? void 0 : _b.exportsType) {
+                    case 'flagged':
+                    case 'namespace':
+                        return 'namespace';
+                    case 'default':
+                        return handleDefault();
+                    default:
+                        return 'dynamic';
+                }
+            }
+            default:
+                return strict ? 'default-with-named' : 'dynamic';
+        }
+    }
+    addPresentationalDependency(presentationalDependency) {
+        if (this.presentationalDependencies === undefined) {
+            this.presentationalDependencies = [];
+        }
+        this.presentationalDependencies.push(presentationalDependency);
+    }
+    addCodeGenerationDependency(codeGenerationDependency) {
+        if (this.codeGenerationDependencies === undefined) {
+            this.codeGenerationDependencies = [];
+        }
+        this.codeGenerationDependencies.push(codeGenerationDependency);
+    }
+    clearDependenciesAndBlocks() {
+        if (this.presentationalDependencies !== undefined) {
+            this.presentationalDependencies.length = 0;
+        }
+        if (this.codeGenerationDependencies !== undefined) {
+            this.codeGenerationDependencies.length = 0;
+        }
+        super.clearDependenciesAndBlocks();
+    }
+    addWarning(warning) {
+        if (this._warnings === undefined) {
+            this._warnings = [];
+        }
+        this._warnings.push(warning);
+    }
+    getWarnings() {
+        return this._warnings;
+    }
+    getNumberOfWarnings() {
+        return this._warnings !== undefined ? this._warnings.length : 0;
+    }
+    addError(error) {
+        if (this._errors === undefined) {
+            this._errors = [];
+        }
+        this._errors.push(error);
+    }
+    getErrors() {
+        return this._errors;
+    }
+    /**
+     * @returns {number} number of errors
+     */
+    getNumberOfErrors() {
+        return this._errors !== undefined ? this._errors.length : 0;
+    }
+    clearWarningsAndErrors() {
+        if (this._warnings !== undefined) {
+            this._warnings.length = 0;
+        }
+        if (this._errors !== undefined) {
+            this._errors.length = 0;
+        }
+    }
+    isOptional(moduleGraph) {
+        let hasConnections = false;
+        for (const r of moduleGraph.getIncomingConnections(this)) {
+            if (!r.dependency || !r.dependency.optional || !r.isTargetActive(undefined)) {
+                return false;
+            }
+            hasConnections = true;
+        }
+        return hasConnections;
+    }
+    isAccessibleInChunk(chunkGraph, chunk, ignoreChunk) {
+        // Check if module is accessible in ALL chunk groups
+        for (const chunkGroup of chunk.groupsIterable) {
+            if (!this.isAccessibleInChunkGroup(chunkGraph, chunkGroup))
+                return false;
+        }
+        return true;
+    }
+    isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk) {
+        const queue = new Set([chunkGroup]);
+        // Check if module is accessible from all items of the queue
+        queueFor: for (const cg of queue) {
+            // 1. If module is in one of the chunks of the group we can continue checking the next items
+            //    because it's accessible.
+            for (const chunk of cg.chunks) {
+                if (chunk !== ignoreChunk && chunkGraph.isModuleInChunk(this, chunk))
+                    continue queueFor;
+            }
+            // 2. If the chunk group is initial, we can break here because it's not accessible.
+            if (chunkGroup.isInitial())
+                return false;
+            // 3. Enqueue all parents because it must be accessible from ALL parents
+            for (const parent of chunkGroup.parentsIterable)
+                queue.add(parent);
+        }
+        // When we processed through the whole list and we didn't bailout, the module is accessible
+        return true;
+    }
+    hasReasonForChunk(chunk, moduleGraph, chunkGraph) {
+        // check for each reason if we need the chunk
+        for (const [fromModule, connections] of moduleGraph.getIncomingConnectionsByOriginModule(this)) {
+            if (!connections.some(c => c.isTargetActive(chunk.runtime)))
+                continue;
+            for (const originChunk of chunkGraph.getModuleChunksIterable(fromModule)) {
+                // return true if module this is not reachable from originChunk when ignoring chunk
+                if (!this.isAccessibleInChunk(chunkGraph, originChunk, chunk))
+                    return true;
+            }
+        }
+        return false;
+    }
+    hasReasons(moduleGraph, runtime) {
+        for (const c of moduleGraph.getIncomingConnections(this)) {
+            if (c.isTargetActive(runtime))
+                return true;
+        }
+        return false;
+    }
+    toString() {
+        return `Module[${this.debugId}: ${this.identifier()}]`;
+    }
+    needBuild(context, callback) {
+        callback(null, !this.buildMeta ||
+            this.needRebuild === Module.prototype.needRebuild ||
+            deprecatedNeedRebuild(this, context));
+    }
+    needRebuild(fileTimestamps, contextTimestamps) {
+        return true;
+    }
+    updateHash(hash, context = {
+        chunkGraph: ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.updateHash', 'DEP_WEBPACK_MODULE_UPDATE_HASH'),
+        runtime: undefined,
+    }) {
+        const { chunkGraph, runtime } = context;
+        hash.update(chunkGraph.getModuleGraphHash(this, runtime));
+        if (this.presentationalDependencies !== undefined) {
+            for (const dep of this.presentationalDependencies) {
+                dep.updateHash(hash, context);
+            }
+        }
+        super.updateHash(hash, context);
+    }
+    invalidateBuild() {
+        // should be overridden to support this feature
+    }
+    /* istanbul ignore next */
+    identifier() {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    /* istanbul ignore next */
+    readableIdentifier(requestShortener) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    /* istanbul ignore next */
+    build(options, compilation, resolver, fs, callback) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    getSourceTypes() {
+        // Better override this method to return the correct types
+        if (this.source === Module.prototype.source) {
+            return DEFAULT_TYPES_UNKNOWN;
+        }
+        return DEFAULT_TYPES_JS;
+    }
+    source(dependencyTemplates, runtimeTemplate, type = 'javascript') {
+        if (this.codeGeneration === Module.prototype.codeGeneration) {
+            const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+            throw new AbstractMethodError();
+        }
+        const chunkGraph = ChunkGraph_1.default.getChunkGraphForModule(this, 'Module.source() is deprecated. Use Compilation.codeGenerationResults.getSource(module, runtime, type) instead', 'DEP_WEBPACK_MODULE_SOURCE');
+        const codeGenContext = {
+            dependencyTemplates,
+            runtimeTemplate,
+            moduleGraph: chunkGraph.moduleGraph,
+            chunkGraph,
+            runtime: undefined,
+            // @ts-ignore
+            codeGenerationResults: undefined,
+        };
+        const sources = this.codeGeneration(codeGenContext).sources;
+        return type ? sources.get(type) : sources.get((0, SetHelpers_1.first)(this.getSourceTypes()));
+    }
+    size(type) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    libIdent(options) {
+        return null;
+    }
+    nameForCondition() {
+        return null;
+    }
+    getConcatenationBailoutReason(context) {
+        return `Module Concatenation is not implemented for ${this.constructor.name}`;
+    }
+    getSideEffectsConnectionState(moduleGraph) {
+        return true;
+    }
+    codeGeneration(context) {
+        // Best override this method
+        const sources = new Map();
+        for (const type of this.getSourceTypes()) {
+            if (type !== 'unknown') {
+                sources.set(type, this.source(context.dependencyTemplates, context.runtimeTemplate, type));
+            }
+        }
+        return {
+            sources,
+            runtimeRequirements: new Set([
+                RuntimeGlobals.module,
+                RuntimeGlobals.exports,
+                RuntimeGlobals.require,
+            ]),
+        };
+    }
+    chunkCondition(chunk, compilation) {
+        return true;
+    }
+    hasChunkCondition() {
+        return this.chunkCondition !== Module.prototype.chunkCondition;
+    }
+    /**
+     * Assuming this module is in the cache. Update the (cached) module with
+     * the fresh module from the factory. Usually updates internal references
+     * and properties.
+     */
+    updateCacheModule(module) {
+        this.type = module.type;
+        this.layer = module.layer;
+        this.context = module.context;
+        this.factoryMeta = module.factoryMeta;
+        this.resolveOptions = module.resolveOptions;
+    }
+    /**
+     * Module should be unsafe cached. Get data that's needed for that.
+     * This data will be passed to restoreFromUnsafeCache later.
+     */
+    getUnsafeCacheData() {
+        return {
+            factoryMeta: this.factoryMeta,
+            resolveOptions: this.resolveOptions,
+        };
+    }
+    /**
+     * restore unsafe cache data
+     */
+    _restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+        this.factoryMeta = unsafeCacheData.factoryMeta;
+        this.resolveOptions = unsafeCacheData.resolveOptions;
+    }
+    /**
+     * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+     */
+    cleanupForCache() {
+        this.factoryMeta = undefined;
+        this.resolveOptions = undefined;
+    }
+    originalSource() {
+        return null;
+    }
+    addCacheDependencies(fileDependencies, contextDependencies, missingDependencies, buildDependencies) { }
+    serialize(context) {
+        const { write } = context;
+        write(this.type);
+        write(this.layer);
+        write(this.context);
+        write(this.resolveOptions);
+        write(this.factoryMeta);
+        write(this.useSourceMap);
+        write(this.useSimpleSourceMap);
+        write(this._warnings !== undefined && this._warnings.length === 0 ? undefined : this._warnings);
+        write(this._errors !== undefined && this._errors.length === 0 ? undefined : this._errors);
+        write(this.buildMeta);
+        write(this.buildInfo);
+        write(this.presentationalDependencies);
+        write(this.codeGenerationDependencies);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.type = read();
+        this.layer = read();
+        this.context = read();
+        this.resolveOptions = read();
+        this.factoryMeta = read();
+        this.useSourceMap = read();
+        this.useSimpleSourceMap = read();
+        this._warnings = read();
+        this._errors = read();
+        this.buildMeta = read();
+        this.buildInfo = read();
+        this.presentationalDependencies = read();
+        this.codeGenerationDependencies = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(Module, 'mp-compiler/core/module/Module');
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, 'hasEqualsChunks', {
+    get() {
+        throw new Error('Module.hasEqualsChunks was renamed (use hasEqualChunks instead)');
+    },
+});
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, 'isUsed', {
+    get() {
+        throw new Error('Module.isUsed was renamed (use getUsedName, isExportUsed or isModuleUsed instead)');
+    },
+});
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, 'errors', {
+    get: util_1.default.deprecate(function () {
+        if (this._errors === undefined) {
+            this._errors = [];
+        }
+        return this._errors;
+    }, 'Module.errors was removed (use getErrors instead)', 'DEP_WEBPACK_MODULE_ERRORS'),
+});
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, 'warnings', {
+    get: util_1.default.deprecate(function () {
+        if (this._warnings === undefined) {
+            this._warnings = [];
+        }
+        return this._warnings;
+    }, 'Module.warnings was removed (use getWarnings instead)', 'DEP_WEBPACK_MODULE_WARNINGS'),
+});
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, 'used', {
+    get() {
+        throw new Error('Module.used was refactored (use ModuleGraph.getUsedExports instead)');
+    },
+    set(value) {
+        throw new Error('Module.used was refactored (use ModuleGraph.setUsedExports instead)');
+    },
+});
+exports.default = Module;

package/dist/module/ModuleFactory.d.ts

@@ -0,0 +1,25 @@
+import { ResolveOptions } from 'enhanced-resolve';
+import Module from './Module';
+import Dependency from '../dependencies/Dependency';
+export interface ModuleFactoryResult {
+    module?: Module;
+    fileDependencies?: Set<string>;
+    contextDependencies?: Set<string>;
+    missingDependencies?: Set<string>;
+    cacheable?: boolean;
+}
+interface ModuleFactoryCreateDataContextInfo {
+    issuer: string;
+    issuerLayer?: string;
+    compiler?: string;
+}
+interface ModuleFactoryCreateData {
+    contextInfo: ModuleFactoryCreateDataContextInfo;
+    resolveOptions?: ResolveOptions;
+    context: string;
+    dependencies: Dependency[];
+}
+declare class ModuleFactory {
+    create(data: ModuleFactoryCreateData, callback: any): void;
+}
+export default ModuleFactory;

package/dist/module/ModuleFactory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ModuleFactory {
+    /* istanbul ignore next */
+    create(data, callback) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+}
+exports.default = ModuleFactory;

package/dist/module/ModuleGraph.d.ts

@@ -0,0 +1,74 @@
+declare class ModuleGraph {
+    _dependencyMap: WeakMap<any, any>;
+    _moduleMap: Map<any, any>;
+    _metaMap: WeakMap<any, any>;
+    _cache: any;
+    _moduleMemCaches: any;
+    _cacheStage: any;
+    constructor();
+    _getModuleGraphModule(module: any): any;
+    setParents(dependency: any, block: any, module: any, indexInBlock?: number): void;
+    getParentModule(dependency: any): any;
+    getParentBlock(dependency: any): any;
+    getParentBlockIndex(dependency: any): any;
+    setResolvedModule(originModule: any, dependency: any, module: any): void;
+    updateModule(dependency: any, module: any): void;
+    removeConnection(dependency: any): void;
+    addExplanation(dependency: any, explanation: string): void;
+    cloneModuleAttributes(sourceModule: any, targetModule: any): void;
+    removeModuleAttributes(module: any): void;
+    removeAllModuleAttributes(): void;
+    moveModuleConnections(oldModule: any, newModule: any, filterConnection: any): void;
+    copyOutgoingModuleConnections(oldModule: any, newModule: any, filterConnection: any): void;
+    addExtraReason(module: any, explanation: string): void;
+    getResolvedModule(dependency: any): any;
+    getConnection(dependency: any): any;
+    getModule(dependency: any): any;
+    getOrigin(dependency: any): any;
+    getResolvedOrigin(dependency: any): any;
+    getIncomingConnections(module: any): any;
+    getOutgoingConnections(module: any): any;
+    getIncomingConnectionsByOriginModule(module: any): any;
+    getOutgoingConnectionsByModule(module: any): any;
+    getProfile(module: any): any;
+    setProfile(module: any, profile: any): void;
+    getIssuer(module: any): any;
+    setIssuer(module: any, issuer: any): void;
+    setIssuerIfUnset(module: any, issuer: any): void;
+    getOptimizationBailout(module: any): any;
+    getProvidedExports(module: any): any;
+    isExportProvided(module: any, exportName: string | string[]): any;
+    getExportsInfo(module: any): any;
+    getExportInfo(module: any, exportName: any): any;
+    getReadOnlyExportInfo(module: any, exportName: any): any;
+    /**
+     * false: module is not used at all.
+     * true: the module namespace/object export is used.
+     * SortableSet<string>: these export names are used.
+     * empty SortableSet<string>: module is used but no export.
+     * null: unknown, worst case should be assumed.
+     */
+    getUsedExports(module: any, runtime: any): any;
+    getPreOrderIndex(module: any): any;
+    getPostOrderIndex(module: any): any;
+    setPreOrderIndex(module: any, index: any): void;
+    setPreOrderIndexIfUnset(module: any, index: any): boolean;
+    setPostOrderIndex(module: any, index: any): void;
+    setPostOrderIndexIfUnset(module: any, index: any): boolean;
+    getDepth(module: any): any;
+    setDepth(module: any, depth: any): void;
+    setDepthIfLower(module: any, depth: number): boolean;
+    isAsync(module: any): any;
+    setAsync(module: any): void;
+    getMeta(thing: any): any;
+    getMetaIfExisting(thing: any): any;
+    freeze(cacheStage?: string): void;
+    unfreeze(): void;
+    cached(fn: any, ...args: any[]): any;
+    setModuleMemCaches(moduleMemCaches: any): void;
+    dependencyCacheProvide(dependency: any, ...args: any[]): any;
+    static getModuleGraphForModule(module: any, deprecateMessage: string, deprecationCode: string): any;
+    static setModuleGraphForModule(module: any, moduleGraph: any): void;
+    static clearModuleGraphForModule(module: any): void;
+}
+export default ModuleGraph;