xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/DefinePlugin.d.ts

@@ -0,0 +1,15 @@
+declare class RuntimeValue {
+    fn: any;
+    options: any;
+    constructor(fn: any, options?: any);
+    get fileDependencies(): any;
+    exec(parser: any, valueCacheVersions: Map<string, string | Set<string>>, key: string): any;
+    getCacheVersion(): any;
+}
+declare class DefinePlugin {
+    definitions: any;
+    constructor(definitions: any);
+    static runtimeValue(fn: any, options: any): RuntimeValue;
+    apply(compiler: any): void;
+}
+export default DefinePlugin;

package/dist/plugins/DefinePlugin.js

@@ -0,0 +1,400 @@
+"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 ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const BaseError_1 = __importDefault(require("@/base/errors/BaseError"));
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const BasicEvaluatedExpression_1 = __importDefault(require("@/module/javascript/BasicEvaluatedExpression"));
+const JavascriptParserHelpers_1 = require("@/module/javascript/JavascriptParserHelpers");
+const createHash_1 = __importDefault(require("@/base/createHash"));
+class RuntimeValue {
+    constructor(fn, options) {
+        this.fn = fn;
+        if (Array.isArray(options)) {
+            options = {
+                fileDependencies: options,
+            };
+        }
+        this.options = options || {};
+    }
+    get fileDependencies() {
+        return this.options === true ? true : this.options.fileDependencies;
+    }
+    exec(parser, valueCacheVersions, key) {
+        const buildInfo = parser.state.module.buildInfo;
+        if (this.options === true) {
+            buildInfo.cacheable = false;
+        }
+        else {
+            if (this.options.fileDependencies) {
+                for (const dep of this.options.fileDependencies) {
+                    buildInfo.fileDependencies.add(dep);
+                }
+            }
+            if (this.options.contextDependencies) {
+                for (const dep of this.options.contextDependencies) {
+                    buildInfo.contextDependencies.add(dep);
+                }
+            }
+            if (this.options.missingDependencies) {
+                for (const dep of this.options.missingDependencies) {
+                    buildInfo.missingDependencies.add(dep);
+                }
+            }
+            if (this.options.buildDependencies) {
+                for (const dep of this.options.buildDependencies) {
+                    buildInfo.buildDependencies.add(dep);
+                }
+            }
+        }
+        return this.fn({
+            module: parser.state.module,
+            key,
+            get version() {
+                return valueCacheVersions.get(VALUE_DEP_PREFIX + key);
+            },
+        });
+    }
+    getCacheVersion() {
+        return this.options === true
+            ? undefined
+            : (typeof this.options.version === 'function'
+                ? this.options.version()
+                : this.options.version) || 'unset';
+    }
+}
+const stringifyObj = (obj, parser, valueCacheVersions, key, runtimeTemplate, logger, asiSafe, objKeys) => {
+    let code;
+    const arr = Array.isArray(obj);
+    if (arr) {
+        code = `[${obj
+            .map(code => toCode(code, parser, valueCacheVersions, key, runtimeTemplate, logger, null))
+            .join(',')}]`;
+    }
+    else {
+        let keys = Object.keys(obj);
+        if (objKeys) {
+            if (objKeys.size === 0)
+                keys = [];
+            else
+                keys = keys.filter(k => objKeys.has(k));
+        }
+        code = `{${keys
+            .map(key => {
+            const code = obj[key];
+            return (`${JSON.stringify(key)}:${toCode(code, parser, valueCacheVersions, key, runtimeTemplate, logger, null)}`);
+        })
+            .join(',')}}`;
+    }
+    switch (asiSafe) {
+        case null:
+            return code;
+        case true:
+            return arr ? code : `(${code})`;
+        case false:
+            return arr ? `;${code}` : `;(${code})`;
+        default:
+            return `/*#__PURE__*/Object(${code})`;
+    }
+};
+/**
+ * Convert code to a string that evaluates
+ */
+const toCode = (code, parser, valueCacheVersions, key, runtimeTemplate, logger, asiSafe, objKeys) => {
+    const transformToCode = () => {
+        if (code === null) {
+            return 'null';
+        }
+        if (code === undefined) {
+            return 'undefined';
+        }
+        if (Object.is(code, -0)) {
+            return '-0';
+        }
+        if (code instanceof RuntimeValue) {
+            return toCode(code.exec(parser, valueCacheVersions, key), parser, valueCacheVersions, key, runtimeTemplate, logger, asiSafe);
+        }
+        if (code instanceof RegExp && code.toString) {
+            return code.toString();
+        }
+        // @ts-ignore
+        if (typeof code === 'function' && code.toString) {
+            // @ts-ignore
+            return `(${code.toString()})`;
+        }
+        if (typeof code === 'object') {
+            return stringifyObj(code, parser, valueCacheVersions, key, runtimeTemplate, logger, asiSafe, objKeys);
+        }
+        if (typeof code === 'bigint') {
+            return runtimeTemplate.supportsBigIntLiteral() ? `${code}n` : `BigInt("${code}")`;
+        }
+        return `${code}`;
+    };
+    const strCode = transformToCode();
+    logger.log(`Replaced "${key}" with "${strCode}"`);
+    return strCode;
+};
+const toCacheVersion = code => {
+    if (code === null) {
+        return 'null';
+    }
+    if (code === undefined) {
+        return 'undefined';
+    }
+    if (Object.is(code, -0)) {
+        return '-0';
+    }
+    if (code instanceof RuntimeValue) {
+        return code.getCacheVersion();
+    }
+    if (code instanceof RegExp && code.toString) {
+        return code.toString();
+    }
+    if (typeof code === 'function' && code.toString) {
+        return `(${code.toString()})`;
+    }
+    if (typeof code === 'object') {
+        const items = Object.keys(code).map(key => ({
+            key,
+            value: toCacheVersion(code[key]),
+        }));
+        if (items.some(({ value }) => value === undefined))
+            return undefined;
+        return `{${items.map(({ key, value }) => `${key}: ${value}`).join(', ')}}`;
+    }
+    if (typeof code === 'bigint') {
+        return `${code}n`;
+    }
+    return `${code}`;
+};
+const PLUGIN_NAME = 'DefinePlugin';
+const VALUE_DEP_PREFIX = `webpack/${PLUGIN_NAME} `;
+const VALUE_DEP_MAIN = `webpack/${PLUGIN_NAME}_hash`;
+const TYPEOF_OPERATOR_REGEXP = /^typeof\s+/;
+const WEBPACK_REQUIRE_FUNCTION_REGEXP = /__webpack_require__\s*(!?\.)/;
+const WEBPACK_REQUIRE_IDENTIFIER_REGEXP = /__webpack_require__/;
+class DefinePlugin {
+    constructor(definitions) {
+        this.definitions = definitions;
+    }
+    static runtimeValue(fn, options) {
+        return new RuntimeValue(fn, options);
+    }
+    apply(compiler) {
+        const definitions = this.definitions;
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            const logger = compilation.getLogger('webpack.DefinePlugin');
+            compilation.dependencyTemplates.set(ConstDependency_1.default, new ConstDependency_1.default.Template());
+            const { runtimeTemplate } = compilation;
+            const mainHash = (0, createHash_1.default)(compilation.outputOptions.hashFunction);
+            mainHash.update(compilation.valueCacheVersions.get(VALUE_DEP_MAIN) || '');
+            const handler = parser => {
+                const mainValue = compilation.valueCacheVersions.get(VALUE_DEP_MAIN);
+                parser.hooks.program.tap(PLUGIN_NAME, () => {
+                    const { buildInfo } = parser.state.module;
+                    if (!buildInfo.valueDependencies)
+                        buildInfo.valueDependencies = new Map();
+                    buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
+                });
+                const addValueDependency = key => {
+                    const { buildInfo } = parser.state.module;
+                    buildInfo.valueDependencies.set(VALUE_DEP_PREFIX + key, compilation.valueCacheVersions.get(VALUE_DEP_PREFIX + key));
+                };
+                const withValueDependency = (key, fn) => (...args) => {
+                    addValueDependency(key);
+                    return fn(...args);
+                };
+                const walkDefinitions = (definitions, prefix) => {
+                    Object.keys(definitions).forEach(key => {
+                        const code = definitions[key];
+                        if (code &&
+                            typeof code === 'object' &&
+                            !(code instanceof RuntimeValue) &&
+                            !(code instanceof RegExp)) {
+                            walkDefinitions(code, `${prefix + key}.`);
+                            applyObjectDefine(prefix + key, code);
+                            return;
+                        }
+                        applyDefineKey(prefix, key);
+                        applyDefine(prefix + key, code);
+                    });
+                };
+                const applyDefineKey = (prefix, key) => {
+                    const splittedKey = key.split('.');
+                    splittedKey.slice(1).forEach((_, i) => {
+                        const fullKey = prefix + splittedKey.slice(0, i + 1).join('.');
+                        parser.hooks.canRename.for(fullKey).tap(PLUGIN_NAME, () => {
+                            addValueDependency(key);
+                            return true;
+                        });
+                    });
+                };
+                const applyDefine = (key, code) => {
+                    const originalKey = key;
+                    const isTypeof = TYPEOF_OPERATOR_REGEXP.test(key);
+                    if (isTypeof)
+                        key = key.replace(TYPEOF_OPERATOR_REGEXP, '');
+                    let recurse = false;
+                    let recurseTypeof = false;
+                    if (!isTypeof) {
+                        parser.hooks.canRename.for(key).tap(PLUGIN_NAME, () => {
+                            addValueDependency(originalKey);
+                            return true;
+                        });
+                        parser.hooks.evaluateIdentifier.for(key).tap(PLUGIN_NAME, expr => {
+                            /**
+                             * this is needed in case there is a recursion in the DefinePlugin
+                             * to prevent an endless recursion
+                             * e.g.: new DefinePlugin({
+                             * "a": "b",
+                             * "b": "a"
+                             * });
+                             */
+                            if (recurse)
+                                return;
+                            addValueDependency(originalKey);
+                            recurse = true;
+                            const res = parser.evaluate(toCode(code, parser, compilation.valueCacheVersions, key, runtimeTemplate, logger, null));
+                            recurse = false;
+                            res.setRange(expr.range);
+                            return res;
+                        });
+                        parser.hooks.expression.for(key).tap(PLUGIN_NAME, expr => {
+                            addValueDependency(originalKey);
+                            let strCode = toCode(code, parser, compilation.valueCacheVersions, originalKey, runtimeTemplate, logger, !parser.isAsiPosition(expr.range[0]), parser.destructuringAssignmentPropertiesFor(expr));
+                            if (parser.scope.inShorthand) {
+                                strCode = `${parser.scope.inShorthand}:${strCode}`;
+                            }
+                            if (WEBPACK_REQUIRE_FUNCTION_REGEXP.test(strCode)) {
+                                return (0, JavascriptParserHelpers_1.toConstantDependency)(parser, strCode, [RuntimeGlobals.require])(expr);
+                            }
+                            if (WEBPACK_REQUIRE_IDENTIFIER_REGEXP.test(strCode)) {
+                                return (0, JavascriptParserHelpers_1.toConstantDependency)(parser, strCode, [RuntimeGlobals.requireScope])(expr);
+                            }
+                            return (0, JavascriptParserHelpers_1.toConstantDependency)(parser, strCode)(expr);
+                        });
+                    }
+                    parser.hooks.evaluateTypeof.for(key).tap(PLUGIN_NAME, expr => {
+                        /**
+                         * this is needed in case there is a recursion in the DefinePlugin
+                         * to prevent an endless recursion
+                         * e.g.: new DefinePlugin({
+                         * "typeof a": "typeof b",
+                         * "typeof b": "typeof a"
+                         * });
+                         */
+                        if (recurseTypeof)
+                            return;
+                        recurseTypeof = true;
+                        addValueDependency(originalKey);
+                        const codeCode = toCode(code, parser, compilation.valueCacheVersions, originalKey, runtimeTemplate, logger, null);
+                        const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`;
+                        const res = parser.evaluate(typeofCode);
+                        recurseTypeof = false;
+                        res.setRange(expr.range);
+                        return res;
+                    });
+                    parser.hooks.typeof.for(key).tap(PLUGIN_NAME, expr => {
+                        addValueDependency(originalKey);
+                        const codeCode = toCode(code, parser, compilation.valueCacheVersions, originalKey, runtimeTemplate, logger, null);
+                        const typeofCode = isTypeof ? codeCode : `typeof (${codeCode})`;
+                        const res = parser.evaluate(typeofCode);
+                        if (!res.isString())
+                            return;
+                        return (0, JavascriptParserHelpers_1.toConstantDependency)(parser, JSON.stringify(res.string)).bind(parser)(expr);
+                    });
+                };
+                const applyObjectDefine = (key, obj) => {
+                    parser.hooks.canRename.for(key).tap(PLUGIN_NAME, () => {
+                        addValueDependency(key);
+                        return true;
+                    });
+                    parser.hooks.evaluateIdentifier.for(key).tap(PLUGIN_NAME, expr => {
+                        addValueDependency(key);
+                        return new BasicEvaluatedExpression_1.default()
+                            .setTruthy()
+                            .setSideEffects(false)
+                            .setRange(expr.range);
+                    });
+                    parser.hooks.evaluateTypeof
+                        .for(key)
+                        .tap(PLUGIN_NAME, withValueDependency(key, (0, JavascriptParserHelpers_1.evaluateToString)('object')));
+                    parser.hooks.expression.for(key).tap(PLUGIN_NAME, expr => {
+                        addValueDependency(key);
+                        let strCode = stringifyObj(obj, parser, compilation.valueCacheVersions, key, runtimeTemplate, logger, !parser.isAsiPosition(expr.range[0]), parser.destructuringAssignmentPropertiesFor(expr));
+                        if (parser.scope.inShorthand) {
+                            strCode = `${parser.scope.inShorthand}:${strCode}`;
+                        }
+                        if (WEBPACK_REQUIRE_FUNCTION_REGEXP.test(strCode)) {
+                            return (0, JavascriptParserHelpers_1.toConstantDependency)(parser, strCode, [RuntimeGlobals.require])(expr);
+                        }
+                        if (WEBPACK_REQUIRE_IDENTIFIER_REGEXP.test(strCode)) {
+                            return (0, JavascriptParserHelpers_1.toConstantDependency)(parser, strCode, [RuntimeGlobals.requireScope])(expr);
+                        }
+                        return (0, JavascriptParserHelpers_1.toConstantDependency)(parser, strCode)(expr);
+                    });
+                    parser.hooks.typeof
+                        .for(key)
+                        .tap(PLUGIN_NAME, withValueDependency(key, (0, JavascriptParserHelpers_1.toConstantDependency)(parser, JSON.stringify('object'))));
+                };
+                walkDefinitions(definitions, '');
+            };
+            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);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM).tap(PLUGIN_NAME, handler);
+            const walkDefinitionsForValues = (definitions, prefix) => {
+                Object.keys(definitions).forEach(key => {
+                    const code = definitions[key];
+                    const version = toCacheVersion(code);
+                    const name = VALUE_DEP_PREFIX + prefix + key;
+                    mainHash.update(`|${prefix}${key}`);
+                    const oldVersion = compilation.valueCacheVersions.get(name);
+                    if (oldVersion === undefined) {
+                        compilation.valueCacheVersions.set(name, version);
+                    }
+                    else if (oldVersion !== version) {
+                        const warning = new BaseError_1.default(`${PLUGIN_NAME}\nConflicting values for '${prefix + key}'`);
+                        warning.details = `'${oldVersion}' !== '${version}'`;
+                        warning.hideStack = true;
+                        compilation.warnings.push(warning);
+                    }
+                    if (code &&
+                        typeof code === 'object' &&
+                        !(code instanceof RuntimeValue) &&
+                        !(code instanceof RegExp)) {
+                        walkDefinitionsForValues(code, `${prefix + key}.`);
+                    }
+                });
+            };
+            walkDefinitionsForValues(definitions, '');
+            compilation.valueCacheVersions.set(VALUE_DEP_MAIN, mainHash.digest('hex').slice(0, 8));
+        });
+    }
+}
+exports.default = DefinePlugin;

package/dist/plugins/NodeStuffPlugin.d.ts

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

package/dist/plugins/NodeStuffPlugin.js

@@ -0,0 +1,134 @@
+"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 ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const NodeStuffInWebError_1 = __importDefault(require("@/base/errors/NodeStuffInWebError"));
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const CachedConstDependency_1 = __importDefault(require("@/dependencies/const/CachedConstDependency"));
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const JavascriptParserHelpers_1 = require("@/module/javascript/JavascriptParserHelpers");
+const fs_1 = require("@/base/fs");
+const identifier_1 = require("@/base/identifier");
+const PLUGIN_NAME = 'NodeStuffPlugin';
+class NodeStuffPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        const options = this.options;
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            const handler = (parser, parserOptions) => {
+                if (parserOptions.node === false)
+                    return;
+                let localOptions = options;
+                if (parserOptions.node) {
+                    localOptions = Object.assign(Object.assign({}, localOptions), parserOptions.node);
+                }
+                if (localOptions.global !== false) {
+                    const withWarning = localOptions.global === 'warn';
+                    parser.hooks.expression.for('global').tap(PLUGIN_NAME, expr => {
+                        const dep = new ConstDependency_1.default(RuntimeGlobals.global, expr.range, [
+                            RuntimeGlobals.global,
+                        ]);
+                        dep.loc = expr.loc;
+                        parser.state.module.addPresentationalDependency(dep);
+                        // TODO webpack 6 remove
+                        if (withWarning) {
+                            parser.state.module.addWarning(new NodeStuffInWebError_1.default(dep.loc, 'global', "The global namespace object is a Node.js feature and isn't available in browsers."));
+                        }
+                    });
+                    parser.hooks.rename.for('global').tap(PLUGIN_NAME, expr => {
+                        const dep = new ConstDependency_1.default(RuntimeGlobals.global, expr.range, [
+                            RuntimeGlobals.global,
+                        ]);
+                        dep.loc = expr.loc;
+                        parser.state.module.addPresentationalDependency(dep);
+                        return false;
+                    });
+                }
+                const setModuleConstant = (expressionName, fn, warning) => {
+                    parser.hooks.expression.for(expressionName).tap(PLUGIN_NAME, expr => {
+                        const dep = new CachedConstDependency_1.default(JSON.stringify(fn(parser.state.module)), expr.range, expressionName);
+                        dep.loc = expr.loc;
+                        parser.state.module.addPresentationalDependency(dep);
+                        // TODO webpack 6 remove
+                        if (warning) {
+                            parser.state.module.addWarning(new NodeStuffInWebError_1.default(dep.loc, expressionName, warning));
+                        }
+                        return true;
+                    });
+                };
+                const setConstant = (expressionName, value, warning) => setModuleConstant(expressionName, () => value, warning);
+                const context = compiler.context;
+                if (localOptions.__filename) {
+                    switch (localOptions.__filename) {
+                        case 'mock':
+                            setConstant('__filename', '/index.js');
+                            break;
+                        case 'warn-mock':
+                            setConstant('__filename', '/index.js', "__filename is a Node.js feature and isn't available in browsers.");
+                            break;
+                        case true:
+                            setModuleConstant('__filename', module => (0, fs_1.relative)(compiler.inputFileSystem, context, module.resource));
+                            break;
+                    }
+                    parser.hooks.evaluateIdentifier.for('__filename').tap(PLUGIN_NAME, expr => {
+                        if (!parser.state.module)
+                            return;
+                        const resource = (0, identifier_1.parseResource)(parser.state.module.resource);
+                        return (0, JavascriptParserHelpers_1.evaluateToString)(resource.path)(expr);
+                    });
+                }
+                if (localOptions.__dirname) {
+                    switch (localOptions.__dirname) {
+                        case 'mock':
+                            setConstant('__dirname', '/');
+                            break;
+                        case 'warn-mock':
+                            setConstant('__dirname', '/', "__dirname is a Node.js feature and isn't available in browsers.");
+                            break;
+                        case true:
+                            setModuleConstant('__dirname', module => (0, fs_1.relative)(compiler.inputFileSystem, context, module.context));
+                            break;
+                    }
+                    parser.hooks.evaluateIdentifier.for('__dirname').tap(PLUGIN_NAME, expr => {
+                        if (!parser.state.module)
+                            return;
+                        return (0, JavascriptParserHelpers_1.evaluateToString)(parser.state.module.context)(expr);
+                    });
+                }
+                parser.hooks.expression
+                    .for('require.extensions')
+                    .tap(PLUGIN_NAME, (0, JavascriptParserHelpers_1.expressionIsUnsupported)(parser, 'require.extensions is not supported by webpack. Use a loader instead.'));
+            };
+            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);
+        });
+    }
+}
+exports.default = NodeStuffPlugin;

package/dist/plugins/ProgressPlugin.d.ts

@@ -0,0 +1,20 @@
+declare class ProgressPlugin {
+    invalid: boolean;
+    static defaultOptions: any;
+    profile: any;
+    handler: any;
+    modulesCount: any;
+    dependenciesCount: any;
+    showEntries: any;
+    showModules: any;
+    showDependencies: any;
+    showActiveModules: any;
+    percentBy: any;
+    static createDefaultHandler: (profile: boolean | null | undefined, logger: any) => (percentage: number, msg: string, ...args: string[]) => void;
+    static getReporter(compiler: any): any;
+    constructor(options?: any);
+    apply(compiler: any): void;
+    _applyOnMultiCompiler(compiler: any, handler: any): void;
+    _applyOnCompiler(compiler: any, handler: any): void;
+}
+export default ProgressPlugin;