xhs-mp-pack 1.1.0-beta.0

package/dist/library/EnableLibraryPlugin.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExportPropertyLibraryPlugin_1 = __importDefault(require("./ExportPropertyLibraryPlugin"));
+const UmdLibraryPlugin_1 = __importDefault(require("./UmdLibraryPlugin"));
+const enabledTypes = new WeakMap();
+const getEnabledTypes = compiler => {
+    let set = enabledTypes.get(compiler);
+    if (set === undefined) {
+        set = new Set();
+        enabledTypes.set(compiler, set);
+    }
+    return set;
+};
+class EnableLibraryPlugin {
+    constructor(type) {
+        this.type = type;
+    }
+    static setEnabled(compiler, type) {
+        getEnabledTypes(compiler).add(type);
+    }
+    static checkEnabled(compiler, type) {
+        if (!getEnabledTypes(compiler).has(type)) {
+            throw new Error(`${`Library type "${type}" is not enabled. ` +
+                'EnableLibraryPlugin need to be used to enable this type of library. ' +
+                'This usually happens through the "output.enabledLibraryTypes" option. ' +
+                'If you are using a function as entry which sets "library", you need to add all potential library types to "output.enabledLibraryTypes". ' +
+                'These types are enabled: '}${Array.from(getEnabledTypes(compiler)).join(', ')}`);
+        }
+    }
+    apply(compiler) {
+        const { type } = this;
+        // Only enable once
+        const enabled = getEnabledTypes(compiler);
+        if (enabled.has(type))
+            return;
+        enabled.add(type);
+        if (typeof type === 'string') {
+            const enableExportProperty = () => {
+                new ExportPropertyLibraryPlugin_1.default({
+                    type,
+                    nsObjectUsed: type !== 'module',
+                }).apply(compiler);
+            };
+            switch (type) {
+                // case 'var': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: [],
+                //     declare: 'var',
+                //     unnamed: 'error',
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'assign-properties': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: [],
+                //     declare: false,
+                //     unnamed: 'error',
+                //     named: 'copy',
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'assign': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: [],
+                //     declare: false,
+                //     unnamed: 'error',
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'this': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: ['this'],
+                //     declare: false,
+                //     unnamed: 'copy',
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'window': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: ['window'],
+                //     declare: false,
+                //     unnamed: 'copy',
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'self': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: ['self'],
+                //     declare: false,
+                //     unnamed: 'copy',
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'global': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: 'global',
+                //     declare: false,
+                //     unnamed: 'copy',
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'commonjs': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: ['exports'],
+                //     declare: false,
+                //     unnamed: 'copy',
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'commonjs-static': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: ['exports'],
+                //     declare: false,
+                //     unnamed: 'static',
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'commonjs2':
+                // case 'commonjs-module': {
+                //   new AssignLibraryPlugin({
+                //     type,
+                //     prefix: ['module', 'exports'],
+                //     declare: false,
+                //     unnamed: 'assign',
+                //   }).apply(compiler)
+                //   break
+                // }
+                case 'umd':
+                case 'umd2': {
+                    enableExportProperty();
+                    new UmdLibraryPlugin_1.default({
+                        type,
+                        optionalAmdExternalAsGlobal: type === 'umd2',
+                    }).apply(compiler);
+                    break;
+                }
+                // case 'jsonp': {
+                //   enableExportProperty()
+                //   new JsonpLibraryPlugin({
+                //     type,
+                //   }).apply(compiler)
+                //   break
+                // }
+                // case 'module': {
+                //   enableExportProperty()
+                //   new ModuleLibraryPlugin({
+                //     type,
+                //   }).apply(compiler)
+                //   break
+                // }
+                default:
+                    throw new Error(`Unsupported library type ${type}.
+Plugins which provide custom library types must call EnableLibraryPlugin.setEnabled(compiler, type) to disable this error.`);
+            }
+        }
+        else {
+            // TODO support plugin instances here
+            // apply them to the compiler
+        }
+    }
+}
+exports.default = EnableLibraryPlugin;

package/dist/library/ExportPropertyLibraryPlugin.d.ts

@@ -0,0 +1,22 @@
+import AbstractLibraryPlugin from './AbstractLibraryPlugin';
+declare class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
+    nsObjectUsed: any;
+    constructor({ type, nsObjectUsed }: {
+        type: any;
+        nsObjectUsed: any;
+    });
+    parseOptions(library: any): {
+        export: any;
+    };
+    finishEntryModule(module: any, entryName: any, { options, compilation, compilation: { moduleGraph } }: {
+        options: any;
+        compilation: {
+            moduleGraph: any;
+        };
+    }): void;
+    runtimeRequirements(chunk: any, set: any, libraryContext: any): void;
+    renderStartup(source: any, module: any, renderContext: any, { options }: {
+        options: any;
+    }): any;
+}
+export default ExportPropertyLibraryPlugin;

package/dist/library/ExportPropertyLibraryPlugin.js

@@ -0,0 +1,74 @@
+"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 webpack_sources_1 = require("webpack-sources");
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const AbstractLibraryPlugin_1 = __importDefault(require("./AbstractLibraryPlugin"));
+class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin_1.default {
+    constructor({ type, nsObjectUsed }) {
+        super({
+            pluginName: 'ExportPropertyLibraryPlugin',
+            type,
+        });
+        this.nsObjectUsed = nsObjectUsed;
+    }
+    parseOptions(library) {
+        return {
+            export: library.export,
+        };
+    }
+    finishEntryModule(module, entryName, { options, compilation, compilation: { moduleGraph } }) {
+        const runtime = (0, RuntimeHelpers_1.getEntryRuntime)(compilation, entryName);
+        if (options.export) {
+            const exportsInfo = moduleGraph.getExportInfo(module, Array.isArray(options.export) ? options.export[0] : options.export);
+            exportsInfo.setUsed(ExportsInfo_1.UsageState.Used, runtime);
+            exportsInfo.canMangleUse = false;
+        }
+        else {
+            const exportsInfo = moduleGraph.getExportsInfo(module);
+            if (this.nsObjectUsed) {
+                exportsInfo.setUsedInUnknownWay(runtime);
+            }
+            else {
+                exportsInfo.setAllKnownExportsUsed(runtime);
+            }
+        }
+        moduleGraph.addExtraReason(module, 'used as library export');
+    }
+    runtimeRequirements(chunk, set, libraryContext) { }
+    renderStartup(source, module, renderContext, { options }) {
+        if (!options.export)
+            return source;
+        const postfix = `${RuntimeGlobals.exports} = ${RuntimeGlobals.exports}${(0, propertyAccess_1.default)(Array.isArray(options.export) ? options.export : [options.export])};\n`;
+        return new webpack_sources_1.ConcatSource(source, postfix);
+    }
+}
+exports.default = ExportPropertyLibraryPlugin;

package/dist/library/JsonpLibraryPlugin.d.ts

@@ -0,0 +1,19 @@
+import { ConcatSource } from 'webpack-sources';
+import AbstractLibraryPlugin from './AbstractLibraryPlugin';
+declare class JsonpLibraryPlugin extends AbstractLibraryPlugin {
+    constructor(options: any);
+    parseOptions(library: any): {
+        name: string;
+    };
+    render(source: any, { chunk }: {
+        chunk: any;
+    }, { options, compilation }: {
+        options: any;
+        compilation: any;
+    }): ConcatSource;
+    chunkHash(chunk: any, hash: any, chunkHashContext: any, { options, compilation }: {
+        options: any;
+        compilation: any;
+    }): void;
+}
+export default JsonpLibraryPlugin;

package/dist/library/JsonpLibraryPlugin.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_sources_1 = require("webpack-sources");
+const AbstractLibraryPlugin_1 = __importDefault(require("./AbstractLibraryPlugin"));
+class JsonpLibraryPlugin extends AbstractLibraryPlugin_1.default {
+    constructor(options) {
+        super({
+            pluginName: 'JsonpLibraryPlugin',
+            type: options.type,
+        });
+    }
+    parseOptions(library) {
+        const { name } = library;
+        if (typeof name !== 'string') {
+            throw new Error(`Jsonp library name must be a simple string. ${AbstractLibraryPlugin_1.default.COMMON_LIBRARY_NAME_MESSAGE}`);
+        }
+        return {
+            name,
+        };
+    }
+    render(source, { chunk }, { options, compilation }) {
+        const name = compilation.getPath(options.name, {
+            chunk,
+        });
+        return new webpack_sources_1.ConcatSource(`${name}(`, source, ')');
+    }
+    chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+        hash.update('JsonpLibraryPlugin');
+        hash.update(compilation.getPath(options.name, { chunk }));
+    }
+}
+exports.default = JsonpLibraryPlugin;

package/dist/library/ModuleLibraryPlugin.d.ts

@@ -0,0 +1,16 @@
+import { ConcatSource } from 'webpack-sources';
+import AbstractLibraryPlugin from './AbstractLibraryPlugin';
+declare class ModuleLibraryPlugin extends AbstractLibraryPlugin {
+    constructor(options: any);
+    parseOptions(library: any): {
+        name: any;
+    };
+    renderStartup(source: any, module: any, { moduleGraph, chunk }: {
+        moduleGraph: any;
+        chunk: any;
+    }, { options, compilation }: {
+        options: any;
+        compilation: any;
+    }): ConcatSource;
+}
+export default ModuleLibraryPlugin;

package/dist/library/ModuleLibraryPlugin.js

@@ -0,0 +1,73 @@
+"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 webpack_sources_1 = require("webpack-sources");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const AbstractLibraryPlugin_1 = __importDefault(require("./AbstractLibraryPlugin"));
+class ModuleLibraryPlugin extends AbstractLibraryPlugin_1.default {
+    constructor(options) {
+        super({
+            pluginName: 'ModuleLibraryPlugin',
+            type: options.type,
+        });
+    }
+    parseOptions(library) {
+        const { name } = library;
+        if (name) {
+            throw new Error(`Library name must be unset. ${AbstractLibraryPlugin_1.default.COMMON_LIBRARY_NAME_MESSAGE}`);
+        }
+        return {
+            name,
+        };
+    }
+    renderStartup(source, module, { moduleGraph, chunk }, { options, compilation }) {
+        const result = new webpack_sources_1.ConcatSource(source);
+        const exportsInfo = moduleGraph.getExportsInfo(module);
+        const exports = [];
+        const isAsync = moduleGraph.isAsync(module);
+        if (isAsync) {
+            result.add(`${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`);
+        }
+        for (const exportInfo of exportsInfo.orderedExports) {
+            if (!exportInfo.provided)
+                continue;
+            const varName = `${RuntimeGlobals.exports}${Template_1.Template.toIdentifier(exportInfo.name)}`;
+            result.add(`var ${varName} = ${RuntimeGlobals.exports}${(0, propertyAccess_1.default)([
+                exportInfo.getUsedName(exportInfo.name, chunk.runtime),
+            ])};\n`);
+            exports.push(`${varName} as ${exportInfo.name}`);
+        }
+        if (exports.length > 0) {
+            result.add(`export { ${exports.join(', ')} };\n`);
+        }
+        return result;
+    }
+}
+exports.default = ModuleLibraryPlugin;

package/dist/library/UmdLibraryPlugin.d.ts

@@ -0,0 +1,22 @@
+import { ConcatSource } from 'webpack-sources';
+import AbstractLibraryPlugin from './AbstractLibraryPlugin';
+declare class UmdLibraryPlugin extends AbstractLibraryPlugin {
+    optionalAmdExternalAsGlobal: any;
+    constructor(options: any);
+    parseOptions(library: any): {
+        name: any;
+        names: any;
+        auxiliaryComment: any;
+        namedDefine: any;
+    };
+    render(source: any, { chunkGraph, runtimeTemplate, chunk, moduleGraph }: {
+        chunkGraph: any;
+        runtimeTemplate: any;
+        chunk: any;
+        moduleGraph: any;
+    }, { options, compilation }: {
+        options: any;
+        compilation: any;
+    }): ConcatSource;
+}
+export default UmdLibraryPlugin;

package/dist/library/UmdLibraryPlugin.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_sources_1 = require("webpack-sources");
+const ExternalModule_1 = __importDefault(require("@/module/ExternalModule"));
+const Template_1 = require("@/template/Template");
+const AbstractLibraryPlugin_1 = __importDefault(require("./AbstractLibraryPlugin"));
+const accessorToObjectAccess = (accessor) => accessor.map(a => `[${JSON.stringify(a)}]`).join('');
+const accessorAccess = (base, accessor, joinWith = ', ') => {
+    const accessors = Array.isArray(accessor) ? accessor : [accessor];
+    return accessors
+        .map((_, idx) => {
+        const a = base
+            ? base + accessorToObjectAccess(accessors.slice(0, idx + 1))
+            : accessors[0] + accessorToObjectAccess(accessors.slice(1, idx + 1));
+        if (idx === accessors.length - 1)
+            return a;
+        if (idx === 0 && base === undefined)
+            return `${a} = typeof ${a} === "object" ? ${a} : {}`;
+        return `${a} = ${a} || {}`;
+    })
+        .join(joinWith);
+};
+class UmdLibraryPlugin extends AbstractLibraryPlugin_1.default {
+    constructor(options) {
+        super({
+            pluginName: 'UmdLibraryPlugin',
+            type: options.type,
+        });
+        this.optionalAmdExternalAsGlobal = options.optionalAmdExternalAsGlobal;
+    }
+    parseOptions(library) {
+        let name;
+        let names;
+        if (typeof library.name === 'object' && !Array.isArray(library.name)) {
+            name = library.name.root || library.name.amd || library.name.commonjs;
+            names = library.name;
+        }
+        else {
+            name = library.name;
+            const singleName = Array.isArray(name) ? name[0] : name;
+            names = {
+                commonjs: singleName,
+                root: library.name,
+                amd: singleName,
+            };
+        }
+        return {
+            name,
+            names,
+            auxiliaryComment: library.auxiliaryComment,
+            namedDefine: library.umdNamedDefine,
+        };
+    }
+    render(source, { chunkGraph, runtimeTemplate, chunk, moduleGraph }, { options, compilation }) {
+        const modules = chunkGraph
+            .getChunkModules(chunk)
+            .filter(m => m instanceof ExternalModule_1.default && (m.externalType === 'umd' || m.externalType === 'umd2'));
+        let externals = modules;
+        const optionalExternals = [];
+        let requiredExternals = [];
+        if (this.optionalAmdExternalAsGlobal) {
+            for (const m of externals) {
+                if (m.isOptional(moduleGraph)) {
+                    optionalExternals.push(m);
+                }
+                else {
+                    requiredExternals.push(m);
+                }
+            }
+            externals = requiredExternals.concat(optionalExternals);
+        }
+        else {
+            requiredExternals = externals;
+        }
+        const replaceKeys = str => compilation.getPath(str, {
+            chunk,
+        });
+        const externalsDepsArray = modules => `[${replaceKeys(modules
+            .map(m => JSON.stringify(typeof m.request === 'object' ? m.request.amd : m.request))
+            .join(', '))}]`;
+        const externalsRootArray = modules => replaceKeys(modules
+            .map(m => {
+            let request = m.request;
+            if (typeof request === 'object')
+                request = request.root;
+            return `root${accessorToObjectAccess([].concat(request))}`;
+        })
+            .join(', '));
+        const externalsRequireArray = type => replaceKeys(externals
+            .map(m => {
+            let expr;
+            let request = m.request;
+            if (typeof request === 'object') {
+                request = request[type];
+            }
+            if (request === undefined) {
+                throw new Error(`Missing external configuration for type:${type}`);
+            }
+            if (Array.isArray(request)) {
+                expr = `require(${JSON.stringify(request[0])})${accessorToObjectAccess(request.slice(1))}`;
+            }
+            else {
+                expr = `require(${JSON.stringify(request)})`;
+            }
+            if (m.isOptional(moduleGraph)) {
+                expr = `(function webpackLoadOptionalExternalModule() { try { return ${expr}; } catch(e) {} }())`;
+            }
+            return expr;
+        })
+            .join(', '));
+        const externalsArguments = modules => modules
+            .map(m => `__WEBPACK_EXTERNAL_MODULE_${Template_1.Template.toIdentifier(`${chunkGraph.getModuleId(m)}`)}__`)
+            .join(', ');
+        const libraryName = library => JSON.stringify(replaceKeys([].concat(library).pop()));
+        let amdFactory;
+        if (optionalExternals.length > 0) {
+            const wrapperArguments = externalsArguments(requiredExternals);
+            const factoryArguments = requiredExternals.length > 0
+                ? `${externalsArguments(requiredExternals)}, ${externalsRootArray(optionalExternals)}`
+                : externalsRootArray(optionalExternals);
+            amdFactory =
+                `function webpackLoadOptionalExternalModuleAmd(${wrapperArguments}) {\n` +
+                    `			return factory(${factoryArguments});\n` +
+                    '		}';
+        }
+        else {
+            amdFactory = 'factory';
+        }
+        const { auxiliaryComment, namedDefine, names } = options;
+        const getAuxiliaryComment = type => {
+            if (auxiliaryComment) {
+                if (typeof auxiliaryComment === 'string')
+                    return `\t//${auxiliaryComment}\n`;
+                if (auxiliaryComment[type])
+                    return `\t//${auxiliaryComment[type]}\n`;
+            }
+            return '';
+        };
+        return new webpack_sources_1.ConcatSource(new webpack_sources_1.OriginalSource(`(function webpackUniversalModuleDefinition(root, factory) {\n${getAuxiliaryComment('commonjs2')}	if(typeof exports === 'object' && typeof module === 'object')\n` +
+            `		module.exports = factory(${externalsRequireArray('commonjs2')});\n${getAuxiliaryComment('amd')}	else if(typeof define === 'function' && define.amd)\n${requiredExternals.length > 0
+                ? names.amd && namedDefine === true
+                    ? `		define(${libraryName(names.amd)}, ${externalsDepsArray(requiredExternals)}, ${amdFactory});\n`
+                    : `		define(${externalsDepsArray(requiredExternals)}, ${amdFactory});\n`
+                : names.amd && namedDefine === true
+                    ? `		define(${libraryName(names.amd)}, [], ${amdFactory});\n`
+                    : `		define([], ${amdFactory});\n`}${names.root || names.commonjs
+                ? `${getAuxiliaryComment('commonjs')}	else if(typeof exports === 'object')\n` +
+                    `		exports[${libraryName(names.commonjs || names.root)}] = factory(${externalsRequireArray('commonjs')});\n${getAuxiliaryComment('root')}	else\n` +
+                    `		${replaceKeys(accessorAccess('root', names.root || names.commonjs))} = factory(${externalsRootArray(externals)});\n`
+                : `	else {\n${externals.length > 0
+                    ? `		var a = typeof exports === 'object' ? factory(${externalsRequireArray('commonjs')}) : factory(${externalsRootArray(externals)});\n`
+                    : '		var a = factory();\n'}		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n` +
+                    `	}\n`}})(${runtimeTemplate.outputOptions.globalObject}, ${runtimeTemplate.supportsArrowFunction()
+                ? `(${externalsArguments(externals)}) =>`
+                : `function(${externalsArguments(externals)})`} {\nreturn `, 'webpack/universalModuleDefinition'), source, ';\n})');
+    }
+}
+exports.default = UmdLibraryPlugin;

package/dist/module/ContextExclusionPlugin.d.ts

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

package/dist/module/ContextExclusionPlugin.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ContextExclusionPlugin {
+    constructor(negativeMatcher) {
+        this.negativeMatcher = negativeMatcher;
+    }
+    apply(compiler) {
+        compiler.hooks.contextModuleFactory.tap('ContextExclusionPlugin', cmf => {
+            cmf.hooks.contextModuleFiles.tap('ContextExclusionPlugin', files => files.filter(filePath => !this.negativeMatcher.test(filePath)));
+        });
+    }
+}
+exports.default = ContextExclusionPlugin;