保誠-保戶業務員媒合平台
HelenHuang
2022-06-09 9bdb95c9e34cef640534e5e5a1e2225a80442000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
"use strict";
 
const ConstDependency = require("./dependencies/ConstDependency");
 
const NullFactory = require("./NullFactory");
 
/** @typedef {import("./Compiler")} Compiler */
 
class CompatibilityPlugin {
    /**
     * Apply the plugin
     * @param {Compiler} compiler Webpack Compiler
     * @returns {void}
     */
    apply(compiler) {
        compiler.hooks.compilation.tap(
            "CompatibilityPlugin",
            (compilation, { normalModuleFactory }) => {
                compilation.dependencyFactories.set(ConstDependency, new NullFactory());
                compilation.dependencyTemplates.set(
                    ConstDependency,
                    new ConstDependency.Template()
                );
 
                normalModuleFactory.hooks.parser
                    .for("javascript/auto")
                    .tap("CompatibilityPlugin", (parser, parserOptions) => {
                        if (
                            parserOptions.browserify !== undefined &&
                            !parserOptions.browserify
                        )
                            return;
 
                        parser.hooks.call
                            .for("require")
                            .tap("CompatibilityPlugin", expr => {
                                // support for browserify style require delegator: "require(o, !0)"
                                if (expr.arguments.length !== 2) return;
                                const second = parser.evaluateExpression(expr.arguments[1]);
                                if (!second.isBoolean()) return;
                                if (second.asBool() !== true) return;
                                const dep = new ConstDependency("require", expr.callee.range);
                                dep.loc = expr.loc;
                                if (parser.state.current.dependencies.length > 1) {
                                    const last =
                                        parser.state.current.dependencies[
                                            parser.state.current.dependencies.length - 1
                                        ];
                                    if (
                                        last.critical &&
                                        last.options &&
                                        last.options.request === "." &&
                                        last.userRequest === "." &&
                                        last.options.recursive
                                    )
                                        parser.state.current.dependencies.pop();
                                }
                                parser.state.current.addDependency(dep);
                                return true;
                            });
                    });
            }
        );
    }
}
module.exports = CompatibilityPlugin;