| 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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137 |
1
1
1
1
1
1
1
1
484
1
1
484
484
3433
3340
3340
3340
3340
3340
3340
3340
3340
3340
34
34
93
93
93
93
93
93
93
93
93
93
93
73
127
73
73
93
93
93
484
3433
107
113
113
26
107
3326
20
20
70
70
10
60
20
40
40
40
40
40
70
20
20
20
20
20
484
115
1
2
2
1
114
88
88
88
88
20
68
88
88
88
88
484
26
26
26
26
26
26
| /*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
var AMDRequireItemDependency = require("./AMDRequireItemDependency");
var AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
var AMDRequireContextDependency = require("./AMDRequireContextDependency");
var AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock");
var LocalModuleDependency = require("./LocalModuleDependency");
var ContextDependencyHelpers = require("./ContextDependencyHelpers");
var LocalModulesHelpers = require("./LocalModulesHelpers");
function AMDRequireDependenciesBlockParserPlugin(options) {
this.options = options;
}
module.exports = AMDRequireDependenciesBlockParserPlugin;
AMDRequireDependenciesBlockParserPlugin.prototype.apply = function(parser) {
var options = this.options;
parser.plugin("call require", function(expr) {
switch(expr.arguments.length) {
case 1:
var param = this.evaluateExpression(expr.arguments[0]);
var result;
var dep = new AMDRequireDependenciesBlock(expr, param.range, null, this.state.module, expr.loc);
var old = this.state.current;
this.state.current = dep;
this.inScope([], function() {
result = this.applyPluginsBailResult("call require:amd:array", expr, param);
}.bind(this));
this.state.current = old;
if(!result) return;
this.state.current.addBlock(dep);
return true;
case 2:
var param = this.evaluateExpression(expr.arguments[0]);
var dep = new AMDRequireDependenciesBlock(expr, param.range, expr.arguments[1].range, this.state.module, expr.loc);
dep.loc = expr.loc;
var old = this.state.current;
this.state.current = dep;
try {
var result;
this.inScope([], function() {
result = this.applyPluginsBailResult("call require:amd:array", expr, param);
}.bind(this));
Iif(!result) return;
if(expr.arguments[1].type === "FunctionExpression") {
this.inScope(expr.arguments[1].params.filter(function(i) {
return ["require", "module", "exports"].indexOf(i.name) < 0;
}), function() {
Eif(expr.arguments[1].body.type === "BlockStatement")
this.walkStatement(expr.arguments[1].body);
else
this.walkExpression(expr.arguments[1].body);
}.bind(this));
}
} finally {
this.state.current = old;
this.state.current.addBlock(dep);
}
return true;
}
});
parser.plugin("call require:amd:array", function(expr, param) {
if(param.isArray()) {
param.items.forEach(function(param) {
var result = this.applyPluginsBailResult("call require:amd:item", expr, param);
if(result === undefined) {
this.applyPluginsBailResult("call require:amd:context", expr, param);
}
}, this);
return true;
} else if(param.isConstArray()) {
var deps = [];
param.array.forEach(function(request) {
var dep, localModule;
if(request === "require") {
dep = "__webpack_require__";
} else if(["exports", "module"].indexOf(request) >= 0) {
dep = request;
} else Iif(localModule = LocalModulesHelpers.getLocalModule(this.state, request)) {
dep = new LocalModuleDependency(localModule);
dep.loc = expr.loc;
this.state.current.addDependency(dep);
} else {
dep = new AMDRequireItemDependency(request);
dep.loc = expr.loc;
dep.optional = !!this.scope.inTry;
this.state.current.addDependency(dep);
}
deps.push(dep);
}, this);
var dep = new AMDRequireArrayDependency(deps, param.range);
dep.loc = expr.loc;
dep.optional = !!this.scope.inTry;
this.state.current.addDependency(dep);
return true;
}
});
parser.plugin("call require:amd:item", function(expr, param) {
if(param.isConditional()) {
param.options.forEach(function(param) {
var result = this.applyPluginsBailResult("call require:amd:item", expr, param);
Iif(result === undefined) {
this.applyPluginsBailResult("call require:amd:context", expr, param);
}
}, this);
return true;
} else if(param.isString()) {
var dep, localModule;
Iif(param.string === "require") {
dep = new ConstDependency("__webpack_require__", param.string);
} else Iif(["exports", "module"].indexOf(param.string) >= 0) {
dep = new ConstDependency(param.string, param.range);
} else if(localModule = LocalModulesHelpers.getLocalModule(this.state, param.string)) {
dep = new LocalModuleDependency(localModule, param.range);
} else {
dep = new AMDRequireItemDependency(param.string, param.range);
}
dep.loc = expr.loc;
dep.optional = !!this.scope.inTry;
this.state.current.addDependency(dep);
return true;
}
});
parser.plugin("call require:amd:context", function(expr, param) {
var dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options);
Iif(!dep) return;
dep.loc = expr.loc;
dep.optional = !!this.scope.inTry;
this.state.current.addDependency(dep);
return true;
});
};
|