xhs-mp-pack 1.1.0-beta.0

package/dist/base/errors/BuildCycleError.d.ts

@@ -0,0 +1,8 @@
+import BaseError from './BaseError';
+declare class BuildCycleError extends BaseError {
+    /**
+     * Creates an instance of ModuleDependencyError.
+     */
+    constructor(module: any);
+}
+export default BuildCycleError;

package/dist/base/errors/BuildCycleError.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+class BuildCycleError extends BaseError_1.default {
+    /**
+     * Creates an instance of ModuleDependencyError.
+     */
+    constructor(module) {
+        super('There is a circular build dependency, which makes it impossible to create this module');
+        this.name = 'BuildCycleError';
+        this.module = module;
+    }
+}
+exports.default = BuildCycleError;

package/dist/base/errors/CaseSensitiveModulesWarning.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class CaseSensitiveModulesWarning extends BaseError {
+    constructor(modules: any, moduleGraph: any);
+}
+export default CaseSensitiveModulesWarning;

package/dist/base/errors/CaseSensitiveModulesWarning.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const sortModules = modules => modules.sort((a, b) => {
+    const aIdent = a.identifier();
+    const bIdent = b.identifier();
+    /* istanbul ignore next */
+    if (aIdent < bIdent)
+        return -1;
+    /* istanbul ignore next */
+    if (aIdent > bIdent)
+        return 1;
+    /* istanbul ignore next */
+    return 0;
+});
+const createModulesListMessage = (modules, moduleGraph) => modules
+    .map(m => {
+    let message = `* ${m.identifier()}`;
+    const validReasons = Array.from(moduleGraph.getIncomingConnectionsByOriginModule(m).keys()).filter(x => x);
+    if (validReasons.length > 0) {
+        message += `\n    Used by ${validReasons.length} module(s), i. e.`;
+        message += `\n    ${validReasons[0].identifier()}`;
+    }
+    return message;
+})
+    .join('\n');
+class CaseSensitiveModulesWarning extends BaseError_1.default {
+    constructor(modules, moduleGraph) {
+        const sortedModules = sortModules(Array.from(modules));
+        const modulesList = createModulesListMessage(sortedModules, moduleGraph);
+        super(`There are multiple modules with names that only differ in casing.
+This can lead to unexpected behavior when compiling on a filesystem with other case-semantic.
+Use equal casing. Compare these module identifiers:
+${modulesList}`);
+        this.name = 'CaseSensitiveModulesWarning';
+        this.module = sortedModules[0];
+    }
+}
+exports.default = CaseSensitiveModulesWarning;

package/dist/base/errors/ChunkRenderError.d.ts

@@ -0,0 +1,6 @@
+import BaseError from './BaseError';
+declare class ChunkRenderError extends BaseError {
+    error: any;
+    constructor(chunk: any, file: any, error: any);
+}
+export default ChunkRenderError;

package/dist/base/errors/ChunkRenderError.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+class ChunkRenderError extends BaseError_1.default {
+    constructor(chunk, file, error) {
+        super();
+        this.name = 'ChunkRenderError';
+        this.error = error;
+        this.message = error.message;
+        this.details = error.stack;
+        this.file = file;
+        this.chunk = chunk;
+    }
+}
+exports.default = ChunkRenderError;

package/dist/base/errors/CodeGenerationError.d.ts

@@ -0,0 +1,8 @@
+import BaseError from './BaseError';
+declare class CodeGenerationError extends BaseError {
+    /**
+     * Create a new CodeGenerationError
+     */
+    constructor(module: any, error: any);
+}
+export default CodeGenerationError;

package/dist/base/errors/CodeGenerationError.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+class CodeGenerationError extends BaseError_1.default {
+    /**
+     * Create a new CodeGenerationError
+     */
+    constructor(module, error) {
+        super();
+        this.name = 'CodeGenerationError';
+        this.error = error;
+        this.message = error.message;
+        this.details = error.stack;
+        this.module = module;
+    }
+}
+exports.default = CodeGenerationError;

package/dist/base/errors/CommentCompilationWarning.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class CommentCompilationWarning extends BaseError {
+    constructor(message: any, loc: any);
+}
+export default CommentCompilationWarning;

package/dist/base/errors/CommentCompilationWarning.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class CommentCompilationWarning extends BaseError_1.default {
+    constructor(message, loc) {
+        super(message);
+        this.name = 'CommentCompilationWarning';
+        this.loc = loc;
+    }
+}
+(0, makeSerializable_1.default)(CommentCompilationWarning, 'mp-compiler/base/errors/CommentCompilationWarning');
+exports.default = CommentCompilationWarning;

package/dist/base/errors/ConcurrentCompilationError.d.ts

@@ -0,0 +1,4 @@
+import BaseError from './BaseError';
+export default class ConcurrentCompilationError extends BaseError {
+    constructor();
+}

package/dist/base/errors/ConcurrentCompilationError.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+class ConcurrentCompilationError extends BaseError_1.default {
+    constructor() {
+        super();
+        this.name = 'ConcurrentCompilationError';
+        this.message =
+            'You ran Webpack twice. Each instance only supports a single concurrent compilation at a time.';
+    }
+}
+exports.default = ConcurrentCompilationError;

package/dist/base/errors/CriticalDependencyWarning.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class CriticalDependencyWarning extends BaseError {
+    constructor(message: any);
+}
+export default CriticalDependencyWarning;

package/dist/base/errors/CriticalDependencyWarning.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class CriticalDependencyWarning extends BaseError_1.default {
+    constructor(message) {
+        super();
+        this.name = 'CriticalDependencyWarning';
+        this.message = `Critical dependency: ${message}`;
+    }
+}
+(0, makeSerializable_1.default)(CriticalDependencyWarning, 'mp-compiler/base/errors/CriticalDependencyWarning');
+exports.default = CriticalDependencyWarning;

package/dist/base/errors/ErrorHelpers.d.ts

@@ -0,0 +1,8 @@
+declare const cutOffByFlag: (stack: string, flag: string) => string;
+declare const cutOffLoaderExecution: (stack: string) => string;
+declare const cutOffWebpackOptions: (stack: string) => string;
+declare const cutOffMultilineMessage: (stack: string, message: string) => string;
+declare const cutOffMessage: (stack: string, message: string) => string;
+declare const cleanUp: (stack: string, message: string) => string;
+declare const cleanUpWebpackOptions: (stack: string, message: string) => string;
+export { cutOffByFlag, cutOffLoaderExecution, cutOffWebpackOptions, cutOffMultilineMessage, cutOffMessage, cleanUp, cleanUpWebpackOptions, };

package/dist/base/errors/ErrorHelpers.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanUpWebpackOptions = exports.cleanUp = exports.cutOffMessage = exports.cutOffMultilineMessage = exports.cutOffWebpackOptions = exports.cutOffLoaderExecution = exports.cutOffByFlag = void 0;
+const loaderFlag = 'LOADER_EXECUTION';
+const webpackOptionsFlag = 'WEBPACK_OPTIONS';
+const cutOffByFlag = (stack, flag) => {
+    const errorStack = stack.split('\n');
+    for (let i = 0; i < errorStack.length; i++) {
+        if (errorStack[i].includes(flag)) {
+            errorStack.length = i;
+        }
+    }
+    return errorStack.join('\n');
+};
+exports.cutOffByFlag = cutOffByFlag;
+const cutOffLoaderExecution = (stack) => cutOffByFlag(stack, loaderFlag);
+exports.cutOffLoaderExecution = cutOffLoaderExecution;
+const cutOffWebpackOptions = (stack) => cutOffByFlag(stack, webpackOptionsFlag);
+exports.cutOffWebpackOptions = cutOffWebpackOptions;
+const cutOffMultilineMessage = (stack, message) => {
+    const stackSplitByLines = stack.split('\n');
+    const messageSplitByLines = message.split('\n');
+    const result = [];
+    stackSplitByLines.forEach((line, idx) => {
+        if (!line.includes(messageSplitByLines[idx]))
+            result.push(line);
+    });
+    return result.join('\n');
+};
+exports.cutOffMultilineMessage = cutOffMultilineMessage;
+const cutOffMessage = (stack, message) => {
+    const nextLine = stack.indexOf('\n');
+    if (nextLine === -1) {
+        return stack === message ? '' : stack;
+    }
+    const firstLine = stack.slice(0, nextLine);
+    return firstLine === message ? stack.slice(nextLine + 1) : stack;
+};
+exports.cutOffMessage = cutOffMessage;
+const cleanUp = (stack, message) => {
+    stack = cutOffLoaderExecution(stack);
+    stack = cutOffMessage(stack, message);
+    return stack;
+};
+exports.cleanUp = cleanUp;
+const cleanUpWebpackOptions = (stack, message) => {
+    stack = cutOffWebpackOptions(stack);
+    stack = cutOffMultilineMessage(stack, message);
+    return stack;
+};
+exports.cleanUpWebpackOptions = cleanUpWebpackOptions;

package/dist/base/errors/HarmonyLinkingError.d.ts

@@ -0,0 +1,4 @@
+import BaseError from './BaseError';
+export default class HarmonyLinkingError extends BaseError {
+    constructor(message: string);
+}

package/dist/base/errors/HarmonyLinkingError.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+class HarmonyLinkingError extends BaseError_1.default {
+    constructor(message) {
+        super(message);
+        this.name = 'HarmonyLinkingError';
+        this.hideStack = true;
+    }
+}
+exports.default = HarmonyLinkingError;

package/dist/base/errors/HookBaseError.d.ts

@@ -0,0 +1,10 @@
+import BaseError from './BaseError';
+declare class HookBaseError extends BaseError {
+    hook: string;
+    error: Error;
+    constructor(error: Error, hook: string);
+}
+declare const makeBaseError: (error: any, hook: string) => BaseError;
+declare const makeBaseErrorCallback: (callback: any, hook: string) => (err: any, result: any) => void;
+declare const tryRunOrBaseError: (fn: any, hook: string) => any;
+export { HookBaseError, makeBaseError, makeBaseErrorCallback, tryRunOrBaseError };

package/dist/base/errors/HookBaseError.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryRunOrBaseError = exports.makeBaseErrorCallback = exports.makeBaseError = exports.HookBaseError = void 0;
+const BaseError_1 = __importDefault(require("./BaseError"));
+class HookBaseError extends BaseError_1.default {
+    constructor(error, hook) {
+        super(error.message);
+        this.name = 'HookBaseError';
+        this.hook = hook;
+        this.error = error;
+        this.hideStack = true;
+        this.details = `caused by plugins in ${hook}\n${error.stack}`;
+        this.stack += `\n-- inner error --\n${error.stack}`;
+    }
+}
+exports.HookBaseError = HookBaseError;
+const makeBaseError = (error, hook) => {
+    if (error instanceof BaseError_1.default)
+        return error;
+    return new HookBaseError(error, hook);
+};
+exports.makeBaseError = makeBaseError;
+const makeBaseErrorCallback = (callback, hook) => (err, result) => {
+    if (err) {
+        if (err instanceof BaseError_1.default) {
+            callback(err);
+            return;
+        }
+        callback(new HookBaseError(err, hook));
+        return;
+    }
+    callback(null, result);
+};
+exports.makeBaseErrorCallback = makeBaseErrorCallback;
+const tryRunOrBaseError = (fn, hook) => {
+    let r;
+    try {
+        r = fn();
+    }
+    catch (err) {
+        if (err instanceof BaseError_1.default) {
+            throw err;
+        }
+        throw new HookBaseError(err, hook);
+    }
+    return r;
+};
+exports.tryRunOrBaseError = tryRunOrBaseError;

package/dist/base/errors/InvalidDependenciesModuleWarning.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class InvalidDependenciesModuleWarning extends BaseError {
+    constructor(module: any, deps: Iterable<string>);
+}
+export default InvalidDependenciesModuleWarning;

package/dist/base/errors/InvalidDependenciesModuleWarning.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class InvalidDependenciesModuleWarning extends BaseError_1.default {
+    constructor(module, deps) {
+        const orderedDeps = deps ? Array.from(deps).sort() : [];
+        const depsList = orderedDeps.map(dep => ` * ${JSON.stringify(dep)}`);
+        super(`Invalid dependencies have been reported by plugins or loaders for this module. All reported dependencies need to be absolute paths.
+Invalid dependencies may lead to broken watching and caching.
+As best effort we try to convert all invalid values to absolute paths and converting globs into context dependencies, but this is deprecated behavior.
+Loaders: Pass absolute paths to this.addDependency (existing files), this.addMissingDependency (not existing files), and this.addContextDependency (directories).
+Plugins: Pass absolute paths to fileDependencies (existing files), missingDependencies (not existing files), and contextDependencies (directories).
+Globs: They are not supported. Pass absolute path to the directory as context dependencies.
+The following invalid values have been reported:
+${depsList.slice(0, 3).join('\n')}${depsList.length > 3 ? '\n * and more ...' : ''}`);
+        this.name = 'InvalidDependenciesModuleWarning';
+        this.details = depsList.slice(3).join('\n');
+        this.module = module;
+    }
+}
+(0, makeSerializable_1.default)(InvalidDependenciesModuleWarning, 'mp-compiler/base/errors/InvalidDependenciesModuleWarning');
+exports.default = InvalidDependenciesModuleWarning;

package/dist/base/errors/MinMaxSizeWarning.d.ts

@@ -0,0 +1,5 @@
+import BaseError from '@/base/errors/BaseError';
+declare class MinMaxSizeWarning extends BaseError {
+    constructor(keys: string[], minSize: number, maxSize: number);
+}
+export default MinMaxSizeWarning;

package/dist/base/errors/MinMaxSizeWarning.js

@@ -0,0 +1,45 @@
+"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 SizeFormatHelpers = __importStar(require("@/base/SizeFormatHelpers"));
+const BaseError_1 = __importDefault(require("@/base/errors/BaseError"));
+class MinMaxSizeWarning extends BaseError_1.default {
+    constructor(keys, minSize, maxSize) {
+        let keysMessage = 'Fallback cache group';
+        if (keys) {
+            keysMessage =
+                keys.length > 1 ? `Cache groups ${keys.sort().join(', ')}` : `Cache group ${keys[0]}`;
+        }
+        super(`SplitChunksPlugin\n` +
+            `${keysMessage}\n` +
+            `Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
+            `bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +
+            'This seem to be a invalid optimization.splitChunks configuration.');
+    }
+}
+exports.default = MinMaxSizeWarning;

package/dist/base/errors/ModuleBuildError.d.ts

@@ -0,0 +1,9 @@
+import BaseError from './BaseError';
+declare class ModuleBuildError extends BaseError {
+    constructor(err: any, { from }?: {
+        from?: null | undefined;
+    });
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ModuleBuildError;

package/dist/base/errors/ModuleBuildError.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ErrorHelpers_1 = require("./ErrorHelpers");
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class ModuleBuildError extends BaseError_1.default {
+    constructor(err, { from = null } = {}) {
+        let message = 'Module build failed';
+        let details;
+        if (from) {
+            message += ` (from ${from}):\n`;
+        }
+        else {
+            message += ': ';
+        }
+        if (err !== null && typeof err === 'object') {
+            if (typeof err.stack === 'string' && err.stack) {
+                const stack = (0, ErrorHelpers_1.cutOffLoaderExecution)(err.stack);
+                if (!err.hideStack) {
+                    message += stack;
+                }
+                else {
+                    details = stack;
+                    if (typeof err.message === 'string' && err.message) {
+                        message += err.message;
+                    }
+                    else {
+                        message += err;
+                    }
+                }
+            }
+            else if (typeof err.message === 'string' && err.message) {
+                message += err.message;
+            }
+            else {
+                message += String(err);
+            }
+        }
+        else {
+            message += String(err);
+        }
+        super(message);
+        this.name = 'ModuleBuildError';
+        this.details = details;
+        this.error = err;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.error);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.error = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ModuleBuildError, 'mp-compiler/base/errors/ModuleBuildError');
+exports.default = ModuleBuildError;

package/dist/base/errors/ModuleDependencyError.d.ts

@@ -0,0 +1,8 @@
+import BaseError from './BaseError';
+declare class ModuleDependencyError extends BaseError {
+    /**
+     * Creates an instance of ModuleDependencyError.
+     */
+    constructor(module: any, err: any, loc: any);
+}
+export default ModuleDependencyError;

package/dist/base/errors/ModuleDependencyError.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 BaseError_1 = __importDefault(require("./BaseError"));
+class ModuleDependencyError extends BaseError_1.default {
+    /**
+     * Creates an instance of ModuleDependencyError.
+     */
+    constructor(module, err, loc) {
+        super(err.message);
+        this.name = 'ModuleDependencyError';
+        this.details = err && !err.hideStack ? err.stack.split('\n').slice(1).join('\n') : undefined;
+        this.module = module;
+        this.loc = loc;
+        /** error is not (de)serialized, so it might be undefined after deserialization */
+        this.error = err;
+        if (err === null || err === void 0 ? void 0 : err.hideStack) {
+            this.stack = `${err.stack.split('\n').slice(1).join('\n')}\n\n${this.stack}`;
+        }
+    }
+}
+exports.default = ModuleDependencyError;

package/dist/base/errors/ModuleDependencyWarning.d.ts

@@ -0,0 +1,6 @@
+import BaseError from './BaseError';
+declare class ModuleDependencyWarning extends BaseError {
+    error: any;
+    constructor(module: any, err: any, loc: any);
+}
+export default ModuleDependencyWarning;

package/dist/base/errors/ModuleDependencyWarning.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class ModuleDependencyWarning extends BaseError_1.default {
+    constructor(module, err, loc) {
+        super(err ? err.message : '');
+        this.name = 'ModuleDependencyWarning';
+        this.details = err && !err.hideStack ? err.stack.split('\n').slice(1).join('\n') : undefined;
+        this.module = module;
+        this.loc = loc;
+        /** error is not (de)serialized, so it might be undefined after deserialization */
+        this.error = err;
+        if (err === null || err === void 0 ? void 0 : err.hideStack) {
+            this.stack = `${err.stack.split('\n').slice(1).join('\n')}\n\n${this.stack}`;
+        }
+    }
+}
+(0, makeSerializable_1.default)(ModuleDependencyWarning, 'mp-compiler/base/errors/ModuleDependencyWarning');
+exports.default = ModuleDependencyWarning;

package/dist/base/errors/ModuleError.d.ts

@@ -0,0 +1,10 @@
+import BaseError from './BaseError';
+declare class ModuleError extends BaseError {
+    error: any;
+    constructor(err: any, { from }?: {
+        from?: null | undefined;
+    });
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default ModuleError;

package/dist/base/errors/ModuleError.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ErrorHelpers_1 = require("./ErrorHelpers");
+const BaseError_1 = __importDefault(require("./BaseError"));
+const makeSerializable_1 = __importDefault(require("../../serialization/makeSerializable"));
+class ModuleError extends BaseError_1.default {
+    constructor(err, { from = null } = {}) {
+        let message = 'Module Error';
+        if (from) {
+            message += ` (from ${from}):\n`;
+        }
+        else {
+            message += ': ';
+        }
+        if (err && typeof err === 'object' && err.message) {
+            message += err.message;
+        }
+        else if (err) {
+            message += err;
+        }
+        super(message);
+        this.name = 'ModuleError';
+        this.error = err;
+        this.details =
+            err && typeof err === 'object' && err.stack ? (0, ErrorHelpers_1.cleanUp)(err.stack, this.message) : undefined;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.error);
+        super.serialize(context);
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.error = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(ModuleError, 'mp-compiler/base/errors/ModuleError');
+exports.default = ModuleError;

package/dist/base/errors/ModuleHashingError.d.ts

@@ -0,0 +1,5 @@
+import BaseError from './BaseError';
+declare class ModuleHashingError extends BaseError {
+    constructor(module: any, error: any);
+}
+export default ModuleHashingError;