zhaojiahui/wechatpay-enterprise-web
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
jefferyzhao
2025-07-31 17:44:12 +08:00
commit b9bdc8598b
42390 changed files with 4467935 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

357
node_modules/webpack-merge/CHANGELOG.md generated vendored Normal file
View File

@ -0,0 +1,357 @@
4.2.2 / 2019-08-27
=================
* Fix - Update minimum version of lodash to 4.17.15 in order to avoid `npm audit warning`. #116
* Docs - Improve `merge.unique` documentation. #103
* Docs - Add clear note about precedence. #115
4.2.1 / 2019-01-04
==================
* Feature - Support `oneOf` at `merge.smart`. #111
* Fix - If there's only single array to merge, clone it. #106
4.1.4 / 2018-08-01
==================
* Maintenance - Remove bitHound from the README as it closed down. #102
4.1.3 / 2018-06-14
==================
* Fix - Smart merge respects the existing loader order #79, #101
4.1.2 / 2017-02-22
==================
* Maintenance - Update lodash, #97, #98
4.1.1 / 2017-11-01
==================
* Docs - Add `customizeArray` and `customizeObject` examples. #93
4.1.0 / 2017-03-16
==================
* Feature - `merge.multiple` to allow working with webpack multi-compiler mode. It accepts multiple objects and returns an array you can push to webpack. #74
4.0.0 / 2017-03-06
==================
* Breaking feature - `merge.smart` allows re-ordering loaders like below. #70
```javascript
merge.smart({
loaders: [{
test: /\.js$/,
loaders: ['babel']
}]
}, {
loaders: [{
test: /\.js$/,
loaders: ['react-hot', 'babel']
}]
});
// will become
{
loaders: [{
test: /\.js$/,
// order of second argument is respected
loaders: ['react-hot', 'babel']
}]
}
```
3.0.0 / 2017-02-19
==================
* Breaking fix - `merge.smart` should not merge a child missing `include`/`exclude` to a parent that has either. This is safer and more predictable behavior than the old one. #69
2.6.1 / 2017-01-29
==================
* Bug fix - `merge.smart` should not merge rules that have differing `enforce` fields. #65
2.6.0 / 2017-01-27
==================
* Bug fix - Support `replace` mode for `merge.smartStrategy`. #63
2.5.0 / 2017-01-26
==================
* Bug fix - Make sure `merge.smartStrategy` works with higher level nesting like `'module.rules.use': 'prepend'`. #64
2.4.0 / 2017-01-12
==================
* Feature - Add `merge.unique` helper that plugs into `customizeArray`. This allows you to force only one plugin of a type to the end result. #58
2.3.1 / 2017-01-06
==================
* Bug fix - Clear up `CopyWebpackPlugin` handling. #56
2.3.0 / 2017-01-06
==================
* Refactor - Depend only on `lodash` instead of individual packages as latter has been discontinued. #52
2.2.0 / 2017-01-05
==================
* Bug fix - Drop `merge.smartStrategy(rules, plugins)` as that caused other issues (prototype copying for complex cases). That needs a better approach. #55
2.1.1 / 2017-01-05
==================
* Bug fix - Avoid recursion at `merge.smart`. #53
2.1.0 / 2017-01-05
==================
* Feature - Allow `merge.smartStrategy` to merge plugin contents. API: `merge.smartStrategy(rules, plugins)`. #44. Example:
```javascript
const output = merge.smartStrategy(
{
entry: 'prepend', // or 'replace'
'module.loaders': 'prepend'
},
['LoaderOptionsPlugin']
)(object1, object2, object3, ...);
```
2.0.0 / 2016-12-22
==================
* Breaking - Disallow overriding configuration with empty arrays/objects (#48). If you want to override, use `merge.strategy`. Example:
```javascript
const a = {
entry: ['foo']
};
const b = {
entry: []
};
merge(a, b); // Yields a result, not b like before.
```
1.1.2 / 2016-12-18
==================
* Bug fix - `merge({ entry: {} })` should return the same result as input instead of a function.
1.1.1 / 2016-12-11
==================
* Bug fix - Support previously undocumented, yet used, `merge([<object>])` format. This works with all available functions. #46
1.1.0 / 2016-12-09
==================
* Feature - Allow `merge` behavior to be customized with overrides. Example:
```javascript
var output = merge({
customizeArray(a, b, key) { return [...a, ...b]; },
customizeObject(a, b, key) { return mergeWith(a, b); }
})(object1, object2, object3, ...);
```
This allows you to guarantee array uniqueness and so on.
1.0.2 / 2016-11-29
==================
* Bug fix - `merge` should not mutate inputs with mismatched keys.
1.0.0 / 2016-11-28
==================
* Feature: Support merging Webpack 2 Rule.use. #38
* Bug fix - Don't concat loaders if the first matching entry's include/exclude doesn't match. #39
0.20.0 / 2016-11-27
===================
* Feature: Add support for merging functions. This feature has been designed `postcss` in mind. It executes the functions, picks their results, and packs them again.
0.19.0 / 2016-11-26
===================
* Feature: Add support for 'replace' option at `merge.strategy`. It literally replaces the old field value with the newer one. #40
0.18.0 / 2016-11-24
===================
* Feature: Add support for recursive definitions at `merge.strategy`. Example:
```javascript
var output = merge.strategy({
entry: 'prepend',
'module.loaders': 'prepend'
})(object1, object2, object3, ...);
```
* Feature: Add `merge.smartStrategy`. This combines the ideas of `merge.smart` and `merge.strategy` into one. Example:
```javascript
var output = merge.smartStrategy({
entry: 'prepend',
'module.loaders': 'prepend'
})(object1, object2, object3, ...);
```
0.17.0 / 2016-11-16
===================
* Feature: Add support for `merge.strategy`. Now you can customize merging behavior per root level configuration field. Example: `merge.strategy({ entry: 'prepend' })(object1, object2, object3, ...);`. #17
0.16.0 / 2016-11-14
===================
* Feature: Add support for webpack 2 at `merge.smart`. It should pick up `module.rules` as you might expect now. #35
0.15.0 / 2016-10-18
===================
* Breaking: Rework `merge.smart` so that it **appends** loaders instead of **prepending** them. This is the logical thing to do as it allows you to specify behavior better as you `merge`. #32
0.14.1 / 2016-07-25
===================
* Docs: Improve package description. #23.
* Bug fix - Let `merge.smart` merge loaders based on their full name instead of first letter. Thanks to @choffmeister. #26.
0.14.0 / 2016-06-05
===================
* Feature: Allow `merge.smart` to merge `loaders` if `exclude` is the same. Thanks to @mshwery. #21.
0.13.0 / 2016-05-24
===================
* Bug fix: Allow `merge.smart` to merge configuration if `include` is defined. Thanks to @blackrabbit99. #20.
0.12.0 / 2016-04-19
===================
* Feature: Support `include/exclude` at `merge.smart` for `loader` definition too. Thanks to @Whoaa512. #16.
0.11.0 / 2016-04-18
===================
* Feature: Support `include/exclude` at `merge.smart` when its set only in a parent. #15.
0.10.0 / 2016-04-10
===================
* Feature: Support `include/exclude` at `merge.smart`. Thanks to @siready. #14.
0.9.0 / 2016-04-08
==================
* Feature: Allow existing objects/arrays to be emptied with an empty object/array later in merge. This overriding behavior is useful for example emptying your `entry` configuration.
0.8.4 / 2016-03-17
==================
* Bug fix: *webpack-merge* should not mutate inputs. #12
0.8.3 / 2016-03-02
==================
* Bug fix: Drop `files` field from *package.json* as it wasn't including the dist correctly.
0.8.0 / 2016-03-02
==================
* Breaking: Change merging behavior so that only loaders get prepended. The rest follow appending logic. This makes `entry` array merging behavior logical. Prepend makes sense only for loaders after all. #10
0.7.3 / 2016-01-11
==================
* Bug fix: Do not error when there are no matching loaders. Thanks @GreenGremlin!
0.7.2 / 2016-01-08
==================
* Regenerate tarball. The problem was that there were some old dependencies included. Closes #7.
0.7.1 / 2016-01-03
==================
* Improve performance by defaulting to `concat` and by dropping a redundant check. Thanks @davegomez!
0.7.0 / 2015-12-31
==================
* Bug fix: Arrays get merged within nested structures correctly now. Array items are prepended (reverse order compared to earlier). This is related to the change made in *0.6.0*. Incidentally this change affects normal merge as well.
* Smart merge: If a loader contains either `include` or `exclude`, it will generate separate entries instead of merging. Without this the configuration might change in an unpredictable manner.
0.6.0 / 2015-12-30
==================
* Support `preLoaders` and `postLoaders`. Previously only `loaders` were supported.
* Breaking: Change smart merging behavior for `loaders` field so that it prepends loaders instead of appending them. The benefit of this is that now it's possible to specialize loader setup in a predictable manner. For example you can have a linter set up at the root and expect it to become evaluated first always.
0.5.1 / 2015-12-26
==================
* Fix `merge` object/array case (missing `bind`). The behavior should be correct now.
0.5.0 / 2015-12-26
==================
* Breaking: Push smart merging behind `merge.smart`. Now `merge` behaves exactly as in *0.3.0* series.
0.4.0 / 2015-12-23
==================
* Dropped changelog generator. It's better to write these by hand.
* Breaking: Added smart merging (@GreenGremlin)
0.3.2 / 2015-11-23
==================
* Tweaked changelog generator process.
0.3.1 / 2015-11-23
==================
* Added changelog generator.
0.3.0 / 2015-11-13
==================
* Improved formatting
* Allowed an arbitrary amount of objects to be merged
0.2.0 / 2015-08-30
==================
* Only require lodash modules used by the package (@montogeek)
* Removed lodash.isarray dependency, use Array.isArray standard object
0.1.3 / 2015-08-10
==================
* Improved README example
0.1.2 / 2015-07-01
==================
* Simplified example
0.1.1 / 2015-06-26
==================
* Fixed travis link
0.1.0 / 2015-06-26
==================
* Initial implementation

20
node_modules/webpack-merge/LICENSE generated vendored Normal file
View File

@ -0,0 +1,20 @@
Copyright (c) 2015 Juho Vepsalainen
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

469
node_modules/webpack-merge/README.md generated vendored Normal file
View File

@ -0,0 +1,469 @@
[![build status](https://secure.travis-ci.org/survivejs/webpack-merge.svg)](http://travis-ci.org/survivejs/webpack-merge) [![codecov](https://codecov.io/gh/survivejs/webpack-merge/branch/master/graph/badge.svg)](https://codecov.io/gh/survivejs/webpack-merge)
# webpack-merge - Merge designed for Webpack
**webpack-merge** provides a `merge` function that concatenates arrays and merges objects creating a new object. If functions are encountered, it will execute them, run the results through the algorithm, and then wrap the returned values within a function again.
This behavior is particularly useful in configuring webpack although it has uses beyond it. Whenever you need to merge configuration objects, **webpack-merge** can come in handy.
There's also a webpack specific merge variant known as `merge.smart` that's able to take webpack specifics into account (i.e., it can flatten loader definitions).
## Standard Merging
### **`merge(...configuration | [...configuration])`**
`merge` is the core, and the most important idea, of the API. Often this is all you need unless you want further customization.
```javascript
// Default API
var output = merge(object1, object2, object3, ...);
// You can pass an array of objects directly.
// This works with all available functions.
var output = merge([object1, object2, object3]);
// Please note that where keys match,
// the objects to the right take precedence:
var output = merge(
{ fruit: "apple", color: "red" },
{ fruit: "strawberries" }
);
console.log(output);
// { color: "red", fruit: "strawberries"}
```
### **`merge({ customizeArray, customizeObject })(...configuration | [...configuration])`**
`merge` behavior can be customized per field through a curried customization API.
```javascript
// Customizing array/object behavior
var output = merge(
{
customizeArray(a, b, key) {
if (key === 'extensions') {
return _.uniq([...a, ...b]);
}
// Fall back to default merging
return undefined;
},
customizeObject(a, b, key) {
if (key === 'module') {
// Custom merging
return _.merge({}, a, b);
}
// Fall back to default merging
return undefined;
}
}
)(object1, object2, object3, ...);
```
For example, if the previous code was invoked with only `object1` and `object2`
with `object1` as:
```
{
foo1: ['object1'],
foo2: ['object1'],
bar1: { object1: {} },
bar2: { object1: {} },
}
```
and `object2` as:
```
{
foo1: ['object2'],
foo2: ['object2'],
bar1: { object2: {} },
bar2: { object2: {} },
}
```
then `customizeArray` will be invoked for each property of `Array` type, i.e:
```
customizeArray(['object1'], ['object2'], 'foo1');
customizeArray(['object1'], ['object2'], 'foo2');
```
and `customizeObject` will be invoked for each property of `Object` type, i.e:
```
customizeObject({ object1: {} }, { object2: {} }, bar1);
customizeObject({ object1: {} }, { object2: {} }, bar2);
```
### **`merge.unique(<field>, <fields>, field => field)`**
The first <field> is the config property to look through for duplicates.
<fields> represents the values that should be unique when you run the field => field function on each duplicate.
```javascript
const output = merge({
customizeArray: merge.unique(
'plugins',
['HotModuleReplacementPlugin'],
plugin => plugin.constructor && plugin.constructor.name
)
})({
plugins: [
new webpack.HotModuleReplacementPlugin()
]
}, {
plugins: [
new webpack.HotModuleReplacementPlugin()
]
});
// Output contains only single HotModuleReplacementPlugin now.
```
## Merging with Strategies
### **`merge.strategy({ <field>: '<prepend|append|replace>''})(...configuration | [...configuration])`**
Given you may want to configure merging behavior per field, there's a strategy variant:
```javascript
// Merging with a specific merge strategy
var output = merge.strategy(
{
entry: 'prepend', // or 'replace', defaults to 'append'
'module.rules': 'prepend'
}
)(object1, object2, object3, ...);
```
### **`merge.smartStrategy({ <key>: '<prepend|append|replace>''})(...configuration | [...configuration])`**
The same idea works with smart merging too (described below in greater detail).
```javascript
var output = merge.smartStrategy(
{
entry: 'prepend', // or 'replace'
'module.rules': 'prepend'
}
)(object1, object2, object3, ...);
```
## Smart Merging
### **`merge.smart(...configuration | [...configuration])`**
*webpack-merge* tries to be smart about merging loaders when `merge.smart` is used. Loaders with matching tests will be merged into a single loader value.
Note that the logic picks up webpack 2 `rules` kind of syntax as well. The examples below have been written in webpack 1 syntax.
**package.json**
```json5
{
"scripts": {
"start": "webpack-dev-server",
"build": "webpack"
},
// ...
}
```
**webpack.config.js**
```javascript
var path = require('path');
var merge = require('webpack-merge');
var TARGET = process.env.npm_lifecycle_event;
var common = {
entry: path.join(__dirname, 'app'),
...
module: {
loaders: [
{
test: /\.css$/,
loaders: ['style', 'css'],
},
],
},
};
if(TARGET === 'start') {
module.exports = merge(common, {
module: {
// loaders will get concatenated!
loaders: [
{
test: /\.jsx?$/,
loader: 'babel?stage=1',
include: path.join(ROOT_PATH, 'app'),
},
],
},
...
});
}
if(TARGET === 'build') {
module.exports = merge(common, {
...
});
}
...
```
**Loader string values `loader: 'babel'` override each other.**
```javascript
merge.smart({
loaders: [{
test: /\.js$/,
loader: 'babel'
}]
}, {
loaders: [{
test: /\.js$/,
loader: 'coffee'
}]
});
// will become
{
loaders: [{
test: /\.js$/,
loader: 'coffee'
}]
}
```
**Loader array values `loaders: ['babel']` will be merged, without duplication.**
```javascript
merge.smart({
loaders: [{
test: /\.js$/,
loaders: ['babel']
}]
}, {
loaders: [{
test: /\.js$/,
loaders: ['coffee']
}]
});
// will become
{
loaders: [{
test: /\.js$/,
// appended because Webpack evaluated these from right to left
// this way you can specialize behavior and build the loader chain
loaders: ['babel', 'coffee']
}]
}
```
**Loader array values `loaders: ['babel']` can be reordered by including
original loaders.**
```javascript
merge.smart({
loaders: [{
test: /\.js$/,
loaders: ['babel']
}]
}, {
loaders: [{
test: /\.js$/,
loaders: ['react-hot', 'babel']
}]
});
// will become
{
loaders: [{
test: /\.js$/,
// order of second argument is respected
loaders: ['react-hot', 'babel']
}]
}
```
This also works in reverse - the existing order will be maintained if possible:
```javascript
merge.smart({
loaders: [{
test: /\.css$/,
use: [
{ loader: 'css-loader', options: { myOptions: true } },
{ loader: 'style-loader' }
]
}]
}, {
loaders: [{
test: /\.css$/,
use: [
{ loader: 'style-loader', options: { someSetting: true } }
]
}]
});
// will become
{
loaders: [{
test: /\.css$/,
use: [
{ loader: 'css-loader', options: { myOptions: true } },
{ loader: 'style-loader', options: { someSetting: true } }
]
}]
}
```
In the case of an order conflict, the second order wins:
```javascript
merge.smart({
loaders: [{
test: /\.css$/,
use: [
{ loader: 'css-loader' },
{ loader: 'style-loader' }
]
}]
}, {
loaders: [{
test: /\.css$/,
use: [
{ loader: 'style-loader' },
{ loader: 'css-loader' }
]
}]
});
// will become
{
loaders: [{
test: /\.css$/,
use: [
{ loader: 'style-loader' }
{ loader: 'css-loader' },
]
}]
}
```
**Loader query strings `loaders: ['babel?plugins[]=object-assign']` will be overridden.**
```javascript
merge.smart({
loaders: [{
test: /\.js$/,
loaders: ['babel?plugins[]=object-assign']
}]
}, {
loaders: [{
test: /\.js$/,
loaders: ['babel', 'coffee']
}]
});
// will become
{
loaders: [{
test: /\.js$/,
loaders: ['babel', 'coffee']
}]
}
```
**Loader arrays in source values will have loader strings merged into them.**
```javascript
merge.smart({
loaders: [{
test: /\.js$/,
loader: 'babel'
}]
}, {
loaders: [{
test: /\.js$/,
loaders: ['coffee']
}]
});
// will become
{
loaders: [{
test: /\.js$/,
// appended because Webpack evaluated these from right to left!
loaders: ['babel', 'coffee']
}]
}
```
**Loader strings in source values will always override.**
```javascript
merge.smart({
loaders: [{
test: /\.js$/,
loaders: ['babel']
}]
}, {
loaders: [{
test: /\.js$/,
loader: 'coffee'
}]
});
// will become
{
loaders: [{
test: /\.js$/,
loader: 'coffee'
}]
}
```
## Multiple Merging
### **`merge.multiple(...configuration | [...configuration])`**
Sometimes you may need to support multiple targets, *webpack-merge* will accept an object where each key represents the target configuration. The output becomes an *array* of configurations where matching keys are merged and non-matching keys are added.
```javascript
var path = require('path');
var baseConfig = {
server: {
target: 'node',
output: {
path: path.resolve(__dirname, 'dist'),
filename: 'lib.node.js'
}
},
client: {
output: {
path: path.resolve(__dirname, 'dist'),
filename: 'lib.js'
}
}
};
// specialized configuration
var production = {
client: {
output: {
path: path.resolve(__dirname, 'dist'),
filename: '[name].[hash].js'
}
}
}
module.exports = merge.multiple(baseConfig, production)
```
> Check out [SurviveJS - Webpack and React](http://survivejs.com/) to dig deeper into the topic.
## Development
1. `npm i`
1. `npm run build`
1. `npm run watch`
Before contributing, please open an issue where to discuss.
## License
*webpack-merge* is available under MIT. See LICENSE for more details.

157
node_modules/webpack-merge/lib/index.js generated vendored Normal file
View File

@ -0,0 +1,157 @@
'use strict';
var _values2 = require('lodash/values');
var _values3 = _interopRequireDefault(_values2);
var _unionWith2 = require('lodash/unionWith');
var _unionWith3 = _interopRequireDefault(_unionWith2);
var _mergeWith2 = require('lodash/mergeWith');
var _mergeWith3 = _interopRequireDefault(_mergeWith2);
var _differenceWith2 = require('lodash/differenceWith');
var _differenceWith3 = _interopRequireDefault(_differenceWith2);
var _joinArrays = require('./join-arrays');
var _joinArrays2 = _interopRequireDefault(_joinArrays);
var _joinArraysSmart = require('./join-arrays-smart');
var _unique = require('./unique');
var _unique2 = _interopRequireDefault(_unique);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
function merge() {
for (var _len = arguments.length, sources = Array(_len), _key = 0; _key < _len; _key++) {
sources[_key] = arguments[_key];
}
// This supports
// merge([<object>] | ...<object>)
// merge({ customizeArray: <fn>, customizeObject: <fn>})([<object>] | ...<object>)
// where fn = (a, b, key)
if (sources.length === 1) {
if (Array.isArray(sources[0])) {
return _mergeWith3.default.apply(undefined, [{}].concat(_toConsumableArray(sources[0]), [(0, _joinArrays2.default)(sources[0])]));
}
if (sources[0].customizeArray || sources[0].customizeObject) {
return function () {
for (var _len2 = arguments.length, structures = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
structures[_key2] = arguments[_key2];
}
if (Array.isArray(structures[0])) {
return _mergeWith3.default.apply(undefined, [{}].concat(_toConsumableArray(structures[0]), [(0, _joinArrays2.default)(sources[0])]));
}
return _mergeWith3.default.apply(undefined, [{}].concat(structures, [(0, _joinArrays2.default)(sources[0])]));
};
}
return sources[0];
}
return _mergeWith3.default.apply(undefined, [{}].concat(sources, [(0, _joinArrays2.default)()]));
}
var mergeSmart = merge({
customizeArray: function customizeArray(a, b, key) {
if (isRule(key.split('.').slice(-1)[0])) {
return (0, _unionWith3.default)(a, b, _joinArraysSmart.uniteRules.bind(null, {}, key));
}
return null;
}
});
var mergeMultiple = function mergeMultiple() {
for (var _len3 = arguments.length, sources = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
sources[_key3] = arguments[_key3];
}
return (0, _values3.default)(merge(sources));
};
// rules: { <field>: <'append'|'prepend'|'replace'> }
// All default to append but you can override here
var mergeStrategy = function mergeStrategy() {
var rules = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
return merge({
customizeArray: _customizeArray(rules),
customizeObject: customizeObject(rules)
});
};
var mergeSmartStrategy = function mergeSmartStrategy() {
var rules = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
return merge({
customizeArray: function customizeArray(a, b, key) {
var topKey = key.split('.').slice(-1)[0];
if (isRule(topKey)) {
switch (rules[key]) {
case 'prepend':
return [].concat(_toConsumableArray((0, _differenceWith3.default)(b, a, function (newRule, seenRule) {
return (0, _joinArraysSmart.uniteRules)(rules, key, newRule, seenRule, 'prepend');
})), _toConsumableArray(a));
case 'replace':
return b;
default:
// append
return (0, _unionWith3.default)(a, b, _joinArraysSmart.uniteRules.bind(null, rules, key));
}
}
return _customizeArray(rules)(a, b, key);
},
customizeObject: customizeObject(rules)
});
};
function _customizeArray(rules) {
return function (a, b, key) {
switch (rules[key]) {
case 'prepend':
return [].concat(_toConsumableArray(b), _toConsumableArray(a));
case 'replace':
return b;
default:
// append
return false;
}
};
}
function customizeObject(rules) {
return function (a, b, key) {
switch (rules[key]) {
case 'prepend':
return (0, _mergeWith3.default)({}, b, a, (0, _joinArrays2.default)());
case 'replace':
return b;
default:
// append
return false;
}
};
}
function isRule(key) {
return ['preLoaders', 'loaders', 'postLoaders', 'rules'].indexOf(key) >= 0;
}
module.exports = merge;
module.exports.multiple = mergeMultiple;
module.exports.smart = mergeSmart;
module.exports.strategy = mergeStrategy;
module.exports.smartStrategy = mergeSmartStrategy;
module.exports.unique = _unique2.default;

1
node_modules/webpack-merge/lib/index.js.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

237
node_modules/webpack-merge/lib/join-arrays-smart.js generated vendored Normal file
View File

@ -0,0 +1,237 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.uniteEntries = exports.uniteRules = undefined;
var _unionWith2 = require('lodash/unionWith');
var _unionWith3 = _interopRequireDefault(_unionWith2);
var _differenceWith2 = require('lodash/differenceWith');
var _differenceWith3 = _interopRequireDefault(_differenceWith2);
var _mergeWith2 = require('lodash/mergeWith');
var _mergeWith3 = _interopRequireDefault(_mergeWith2);
var _isEqual2 = require('lodash/isEqual');
var _isEqual3 = _interopRequireDefault(_isEqual2);
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
var isArray = Array.isArray;
function uniteRules(rules, key, newRule, rule) {
if (String(rule.test) !== String(newRule.test) || (newRule.enforce || rule.enforce) && rule.enforce !== newRule.enforce || newRule.include && !isSameValue(rule.include, newRule.include) || newRule.exclude && !isSameValue(rule.exclude, newRule.exclude)) {
return false;
} else if (!rule.test && !rule.include && !rule.exclude && (rule.loader && rule.loader.split('?')[0]) !== (newRule.loader && newRule.loader.split('?')[0])) {
// Don't merge the rule if there isn't any identifying fields and the loaders don't match
return false;
} else if ((rule.include || rule.exclude) && !newRule.include && !newRule.exclude) {
// Don't merge child without include/exclude to parent that has either
return false;
}
// apply the same logic for oneOf
if (rule.oneOf && newRule.oneOf) {
rule.oneOf = (0, _unionWith3.default)(rule.oneOf, newRule.oneOf, uniteRules.bind(null, {}, 'oneOf'));
return true;
}
// newRule.loader should always override use, loaders and oneOf
if (newRule.loader) {
var optionsKey = newRule.options ? 'options' : newRule.query && 'query';
delete rule.use;
delete rule.loaders;
delete rule.oneOf;
rule.loader = newRule.loader;
if (optionsKey) {
rule[optionsKey] = newRule[optionsKey];
}
} else if (newRule.oneOf) {
delete rule.use;
delete rule.loaders;
delete rule.loader;
rule.oneOf = newRule.oneOf;
} else if ((rule.use || rule.loaders || rule.loader) && (newRule.use || newRule.loaders)) {
var expandEntry = function expandEntry(loader) {
return typeof loader === 'string' ? { loader: loader } : loader;
};
// this is only here to avoid breaking existing tests
var unwrapEntry = function unwrapEntry(entry) {
return !entry.options && !entry.query ? entry.loader : entry;
};
var entries = void 0;
if (rule.loader) {
var _optionsKey = rule.options ? 'options' : rule.query && 'query';
entries = [{ loader: rule.loader }];
if (_optionsKey) {
entries[0][_optionsKey] = rule[_optionsKey];
}
delete rule.loader;
if (_optionsKey) {
delete rule[_optionsKey];
}
} else {
entries = [].concat(rule.use || rule.loaders).map(expandEntry);
}
var newEntries = [].concat(newRule.use || newRule.loaders).map(expandEntry);
var loadersKey = rule.use || newRule.use ? 'use' : 'loaders';
var resolvedKey = key + '.' + loadersKey;
switch (rules[resolvedKey]) {
case 'prepend':
rule[loadersKey] = [].concat(_toConsumableArray((0, _differenceWith3.default)(newEntries, entries, uniteEntries)), _toConsumableArray(entries)).map(unwrapEntry);
break;
case 'replace':
rule[loadersKey] = newRule.use || newRule.loaders;
break;
default:
rule[loadersKey] = combineEntries(newEntries, entries).map(unwrapEntry);
}
}
if (newRule.include) {
rule.include = newRule.include;
}
if (newRule.exclude) {
rule.exclude = newRule.exclude;
}
return true;
}
/**
* Check equality of two values using lodash's isEqual
* Arrays need to be sorted for equality checking
* but clone them first so as not to disrupt the sort order in tests
*/
function isSameValue(a, b) {
var _map = [a, b].map(function (value) {
return isArray(value) ? [].concat(_toConsumableArray(value)).sort() : value;
}),
_map2 = _slicedToArray(_map, 2),
propA = _map2[0],
propB = _map2[1];
return (0, _isEqual3.default)(propA, propB);
}
function areEqualEntries(newEntry, entry) {
var loaderNameRe = /^([^?]+)/ig;
var _entry$loader$match = entry.loader.match(loaderNameRe),
_entry$loader$match2 = _slicedToArray(_entry$loader$match, 1),
loaderName = _entry$loader$match2[0];
var _newEntry$loader$matc = newEntry.loader.match(loaderNameRe),
_newEntry$loader$matc2 = _slicedToArray(_newEntry$loader$matc, 1),
newLoaderName = _newEntry$loader$matc2[0];
return loaderName === newLoaderName;
}
function uniteEntries(newEntry, entry) {
if (areEqualEntries(newEntry, entry)) {
// Replace query values with newer ones
(0, _mergeWith3.default)(entry, newEntry);
return true;
}
return false;
}
/* Combines entries and newEntries, while respecting the order of loaders in each.
Iterates through new entries. If the new entry also exists in existing entries,
we'll put in all of the loaders from existing entries that come before it (in case
those are pre-requisites). Any remaining existing entries are added at the end.
Since webpack processes right-to-left, we're working backwards through the arrays
*/
function combineEntries(newEntries, existingEntries) {
var resultSet = [];
// We're iterating through newEntries, this keeps track of where we are in the existingEntries
var existingEntriesIteratorIndex = existingEntries.length - 1;
for (var i = newEntries.length - 1; i >= 0; i -= 1) {
var currentEntry = newEntries[i];
var indexInExistingEntries = findLastIndexUsingComparinator(existingEntries, currentEntry, areEqualEntries, existingEntriesIteratorIndex);
var hasEquivalentEntryInExistingEntries = indexInExistingEntries !== -1;
if (hasEquivalentEntryInExistingEntries) {
// If the same entry exists in existing entries, we should add all of the entries that
// come before to maintain order
for (var j = existingEntriesIteratorIndex; j > indexInExistingEntries; j -= 1) {
var existingEntry = existingEntries[j];
// If this entry also exists in new entries, we'll add as part of iterating through
// new entries so that if there's a conflict between existing entries and new entries,
// new entries order wins
var hasMatchingEntryInNewEntries = findLastIndexUsingComparinator(newEntries, existingEntry, areEqualEntries, i) !== -1;
if (!hasMatchingEntryInNewEntries) {
resultSet.unshift(existingEntry);
}
existingEntriesIteratorIndex -= 1;
}
uniteEntries(currentEntry, existingEntries[existingEntriesIteratorIndex]);
// uniteEntries mutates the second parameter to be a merged version, so that's what's pushed
resultSet.unshift(existingEntries[existingEntriesIteratorIndex]);
existingEntriesIteratorIndex -= 1;
} else {
var alreadyHasMatchingEntryInResultSet = findLastIndexUsingComparinator(resultSet, currentEntry, areEqualEntries) !== -1;
if (!alreadyHasMatchingEntryInResultSet) {
resultSet.unshift(currentEntry);
}
}
}
// Add remaining existing entries
for (existingEntriesIteratorIndex; existingEntriesIteratorIndex >= 0; existingEntriesIteratorIndex -= 1) {
var _existingEntry = existingEntries[existingEntriesIteratorIndex];
var _alreadyHasMatchingEntryInResultSet = findLastIndexUsingComparinator(resultSet, _existingEntry, areEqualEntries) !== -1;
if (!_alreadyHasMatchingEntryInResultSet) {
resultSet.unshift(_existingEntry);
}
}
return resultSet;
}
function findLastIndexUsingComparinator(entries, entryToFind, comparinator, startingIndex) {
startingIndex = startingIndex || entries.length - 1;
for (var i = startingIndex; i >= 0; i -= 1) {
if (areEqualEntries(entryToFind, entries[i])) {
return i;
}
}
return -1;
}
exports.uniteRules = uniteRules;
exports.uniteEntries = uniteEntries;

1
node_modules/webpack-merge/lib/join-arrays-smart.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

71
node_modules/webpack-merge/lib/join-arrays.js generated vendored Normal file
View File

@ -0,0 +1,71 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _mergeWith2 = require('lodash/mergeWith');
var _mergeWith3 = _interopRequireDefault(_mergeWith2);
var _isPlainObject2 = require('lodash/isPlainObject');
var _isPlainObject3 = _interopRequireDefault(_isPlainObject2);
var _isFunction2 = require('lodash/isFunction');
var _isFunction3 = _interopRequireDefault(_isFunction2);
var _cloneDeep2 = require('lodash/cloneDeep');
var _cloneDeep3 = _interopRequireDefault(_cloneDeep2);
exports.default = joinArrays;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
var isArray = Array.isArray;
function joinArrays() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
customizeArray = _ref.customizeArray,
customizeObject = _ref.customizeObject,
key = _ref.key;
return function _joinArrays(a, b, k) {
var newKey = key ? key + '.' + k : k;
if ((0, _isFunction3.default)(a) && (0, _isFunction3.default)(b)) {
return function () {
return _joinArrays(a.apply(undefined, arguments), b.apply(undefined, arguments), k);
};
}
if (isArray(a) && isArray(b)) {
var customResult = customizeArray && customizeArray(a, b, newKey);
return customResult || [].concat(_toConsumableArray(a), _toConsumableArray(b));
}
if ((0, _isPlainObject3.default)(a) && (0, _isPlainObject3.default)(b)) {
var _customResult = customizeObject && customizeObject(a, b, newKey);
return _customResult || (0, _mergeWith3.default)({}, a, b, joinArrays({
customizeArray: customizeArray,
customizeObject: customizeObject,
key: newKey
}));
}
if ((0, _isPlainObject3.default)(b)) {
return (0, _cloneDeep3.default)(b);
}
if (isArray(b)) {
return [].concat(_toConsumableArray(b));
}
return b;
};
}

1
node_modules/webpack-merge/lib/join-arrays.js.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"join-arrays.js","sourceRoot":"","sources":["../src/join-arrays.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,iCAAyE;AAGzE,IAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;AAE9B,SAAwB,UAAU,CAAC,EAQ7B;QAR6B,4BAQ7B,EAPJ,kCAAc,EACd,oCAAe,EACf,YAAG;IAMH,OAAO,SAAS,WAAW,CAAC,CAAM,EAAE,CAAM,EAAE,CAAM;QAChD,IAAM,MAAM,GAAG,GAAG,CAAC,CAAC,CAAI,GAAG,SAAI,CAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAEvC,IAAI,mBAAU,CAAC,CAAC,CAAC,IAAI,mBAAU,CAAC,CAAC,CAAC,EAAE;YAClC,OAAO;gBAAC,cAAc;qBAAd,UAAc,EAAd,qBAAc,EAAd,IAAc;oBAAd,yBAAc;;gBAAK,OAAA,WAAW,CAAC,CAAC,wBAAI,IAAI,IAAG,CAAC,wBAAI,IAAI,IAAG,CAAC,CAAC;YAAtC,CAAsC,CAAC;SACnE;QACD,IAAI,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE;YAC5B,IAAM,YAAY,GAAG,cAAc,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;YAEpE,OAAO,YAAY,aAAQ,CAAC,EAAK,CAAC,CAAC,CAAC;SACrC;QAED,IAAI,sBAAa,CAAC,CAAC,CAAC,IAAI,sBAAa,CAAC,CAAC,CAAC,EAAE;YACxC,IAAM,YAAY,GAAG,eAAe,IAAI,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;YAEtE,OAAO,CACL,YAAY;gBACZ,kBAAS,CACP,EAAE,EACF,CAAC,EACD,CAAC,EACD,UAAU,CAAC;oBACT,cAAc,gBAAA;oBACd,eAAe,iBAAA;oBACf,GAAG,EAAE,MAAM;iBACZ,CAAC,CACH,CACF,CAAC;SACH;QAED,IAAI,sBAAa,CAAC,CAAC,CAAC,EAAE;YACpB,OAAO,kBAAS,CAAC,CAAC,CAAC,CAAC;SACrB;QAED,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE;YACd,gBAAW,CAAC,EAAE;SACf;QAED,OAAO,CAAC,CAAC;IACX,CAAC,CAAC;AACJ,CAAC;AAjDD,6BAiDC"}

21
node_modules/webpack-merge/lib/types.js generated vendored Normal file
View File

@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ArrayRule;
(function (ArrayRule) {
ArrayRule["PreLoaders"] = "preLoaders";
ArrayRule["Loaders"] = "loaders";
ArrayRule["PostLoaders"] = "postLoaders";
ArrayRule["Rules"] = "rules";
})(ArrayRule = exports.ArrayRule || (exports.ArrayRule = {}));
var CustomizeRule;
(function (CustomizeRule) {
CustomizeRule["Append"] = "append";
CustomizeRule["Prepend"] = "prepend";
CustomizeRule["Replace"] = "replace";
})(CustomizeRule = exports.CustomizeRule || (exports.CustomizeRule = {}));
var Enforce;
(function (Enforce) {
Enforce["Pre"] = "pre";
Enforce["Post"] = "Post";
})(Enforce = exports.Enforce || (exports.Enforce = {}));
//# sourceMappingURL=types.js.map

1
node_modules/webpack-merge/lib/types.js.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;AAKA,IAAY,SAKX;AALD,WAAY,SAAS;IACnB,sCAAyB,CAAA;IACzB,gCAAmB,CAAA;IACnB,wCAA2B,CAAA;IAC3B,4BAAe,CAAA;AACjB,CAAC,EALW,SAAS,GAAT,iBAAS,KAAT,iBAAS,QAKpB;AAKD,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,kCAAiB,CAAA;IACjB,oCAAmB,CAAA;IACnB,oCAAmB,CAAA;AACrB,CAAC,EAJW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAIxB;AAED,IAAY,OAGX;AAHD,WAAY,OAAO;IACjB,sBAAW,CAAA;IACX,wBAAa,CAAA;AACf,CAAC,EAHW,OAAO,GAAP,eAAO,KAAP,eAAO,QAGlB"}

27
node_modules/webpack-merge/lib/unique.js generated vendored Normal file
View File

@ -0,0 +1,27 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _differenceWith2 = require('lodash/differenceWith');
var _differenceWith3 = _interopRequireDefault(_differenceWith2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
function mergeUnique(key, uniques) {
var getter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function (a) {
return a;
};
return function (a, b, k) {
return k === key && [].concat(_toConsumableArray(a), _toConsumableArray((0, _differenceWith3.default)(b, a, function (item) {
return uniques.indexOf(getter(item)) >= 0;
})));
};
}
exports.default = mergeUnique;

1
node_modules/webpack-merge/lib/unique.js.map generated vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"unique.js","sourceRoot":"","sources":["../src/unique.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,iCAAwC;AAExC,SAAS,WAAW,CAAC,GAAW,EAAE,OAAiB,EAAE,MAAqB;IAArB,uBAAA,EAAA,mBAAU,CAAK,IAAK,OAAA,CAAC,EAAD,CAAC;IACxE,OAAO,UAAC,CAAK,EAAE,CAAK,EAAE,CAAS;QAC7B,OAAA,CAAC,KAAK,GAAG,aACJ,CAAC,EACD,uBAAc,CAAC,CAAC,EAAE,CAAC,EAAE,UAAA,IAAI,IAAI,OAAA,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAlC,CAAkC,CAAC,CACpE;IAHD,CAGC,CAAC;AACN,CAAC;AAED,kBAAe,WAAW,CAAC"}

74
node_modules/webpack-merge/package.json generated vendored Normal file
View File

@ -0,0 +1,74 @@
{
"name": "webpack-merge",
"description": "Variant of merge that's useful for webpack configuration",
"author": "Juho Vepsalainen <bebraw@gmail.com>",
"version": "4.2.2",
"scripts": {
"build": "babel src -d lib",
"watch": "npm-watch",
"test": "mocha tests/test-*",
"test:coverage": "istanbul cover node_modules/.bin/_mocha tests/test-*",
"test:lint": "eslint src/ tests/ --cache",
"preversion": "npm run test:lint && npm run build && npm test && git commit --allow-empty -am \"Update lib\""
},
"main": "lib/index.js",
"files": [
"lib"
],
"dependencies": {
"lodash": "^4.17.15"
},
"devDependencies": {
"babel-cli": "^6.26.0",
"babel-plugin-lodash": "^3.3.2",
"babel-preset-es2015": "^6.24.1",
"copy-webpack-plugin": "^4.4.1",
"eslint": "^3.19.0",
"eslint-config-airbnb": "^14.1.0",
"eslint-plugin-import": "^2.9.0",
"eslint-plugin-jsx-a11y": "^3.0.2",
"eslint-plugin-react": "^6.10.3",
"git-prepush-hook": "^1.0.2",
"istanbul": "^0.4.5",
"mocha": "^3.5.3",
"npm-watch": "^0.1.9",
"webpack": "^1.15.0"
},
"repository": {
"type": "git",
"url": "https://github.com/survivejs/webpack-merge.git"
},
"homepage": "https://github.com/survivejs/webpack-merge",
"bugs": {
"url": "https://github.com/survivejs/webpack-merge/issues"
},
"keywords": [
"webpack",
"merge"
],
"license": "MIT",
"pre-push": [
"test:lint",
"build",
"test"
],
"watch": {
"build": {
"patterns": [
"src/**/*.js"
]
},
"test": {
"patterns": [
"src/**/*.js",
"tests/**/*.js"
]
},
"test:lint": {
"patterns": [
"src/**/*.js",
"tests/**/*.js"
]
}
}
}