First commit

hGameTest/node_modules/webpack-merge/lib/index.js

@@ -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;

hGameTest/node_modules/webpack-merge/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,iCAAsE;AAEtE,6CAAuC;AACvC,yDAAiD;AACjD,iCAQiB;AACjB,mCAA8B;AAsHrB,iBAtHF,gBAAM,CAsHE;AA/Gf,sCAAsC;AACtC,SAAgB,gBAAgB,CAAC,OAAiB;IAChD,OAAO;QAAC,oBAA8B;aAA9B,UAA8B,EAA9B,qBAA8B,EAA9B,IAA8B;YAA9B,+BAA8B;;QACpC,OAAA,kBAAS,yBAAC,EAAE,GAAK,UAAU,GAAE,qBAAU,CAAC,OAAO,CAAC;IAAhD,CAAiD,CAAC;AACtD,CAAC;AAHD,4CAGC;AAED,SAAS,KAAK;IAAC,iBAA2B;SAA3B,UAA2B,EAA3B,qBAA2B,EAA3B,IAA2B;QAA3B,4BAA2B;;IACxC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;QACxB,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE;YAC7B,OAAO,kBAAS,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,qBAAU,EAAE,CAAC,CAAC;SAChD;QAED,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;KACnB;IAED,OAAO,kBAAS,yBAAC,EAAE,GAAK,OAAO,GAAE,qBAAU,EAAE,IAAE;AACjD,CAAC;AAEY,QAAA,KAAK,GAAG,gBAAgB,CAAC;IACpC,cAAc,EAAE,UAAC,CAAM,EAAE,CAAM,EAAE,GAAQ;QACvC,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;YACvC,OAAO,kBAAS,CAAC,CAAC,EAAE,CAAC,EAAE,8BAAU,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;SACxD;QAED,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAC,CAAC;AAEH,8BAA8B;AACjB,QAAA,QAAQ,GAAG;IAAC,iBAA2B;SAA3B,UAA2B,EAA3B,qBAA2B,EAA3B,IAA2B;QAA3B,4BAA2B;;IAClD,OAAA,eAAM,CAAC,KAAK,wBAAI,OAAO,GAAE;AAAzB,CAAyB,CAAC;AAE5B,qDAAqD;AACrD,kDAAkD;AACrC,QAAA,QAAQ,GAAG,UAAC,KAA2B;IAA3B,sBAAA,EAAA,UAA2B;IAClD,OAAA,gBAAgB,CAAC;QACf,cAAc,EAAE,cAAc,CAAC,KAAK,CAAC;QACrC,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC;KACxC,CAAC;AAHF,CAGE,CAAC;AACQ,QAAA,kBAAkB,GAAG,UAAC,KAA2B;IAA3B,sBAAA,EAAA,UAA2B;IAC5D,OAAA,gBAAgB,CAAC;QACf,cAAc,EAAE,UAAC,CAAC,EAAE,CAAC,EAAE,GAAQ;YAC7B,IAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAE3C,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE;gBAClB,QAAQ,KAAK,CAAC,GAAG,CAAC,EAAE;oBAClB,KAAK,SAAS;wBACZ,gBACK,uBAAc,CACf,CAAC,EACD,CAAC;wBACD,4BAA4B;wBAC5B,UAAC,OAAc,EAAE,QAAe;4BAC9B,OAAA,8BAAU,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,CAAC;wBAAzC,CAAyC,CAC5C,EACE,CAAC,EACJ;oBACJ,KAAK,SAAS;wBACZ,OAAO,CAAC,CAAC;oBACX;wBACE,SAAS;wBACT,OAAO,kBAAS,CAAC,CAAC,EAAE,CAAC,EAAE,8BAAU,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;iBAC7D;aACF;YAED,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QAC1C,CAAC;QACD,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC;KACxC,CAAC;AA5BF,CA4BE,CAAC;AAEL,SAAS,cAAc,CAAC,KAAsB;IAC5C,OAAO,UAAC,CAAM,EAAE,CAAM,EAAE,GAAQ;QAC9B,QAAQ,KAAK,CAAC,GAAG,CAAC,EAAE;YAClB,KAAK,qBAAa,CAAC,OAAO;gBACxB,gBAAW,CAAC,EAAK,CAAC,EAAE;YACtB,KAAK,qBAAa,CAAC,OAAO;gBACxB,OAAO,CAAC,CAAC;YACX,KAAK,qBAAa,CAAC,MAAM,CAAC;YAC1B;gBACE,SAAS;gBACT,OAAO,KAAK,CAAC;SAChB;IACH,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,eAAe,CAAC,KAAsB;IAC7C,OAAO,UAAC,CAAM,EAAE,CAAM,EAAE,GAAQ;QAC9B,QAAQ,KAAK,CAAC,GAAG,CAAC,EAAE;YAClB,KAAK,qBAAa,CAAC,OAAO;gBACxB,OAAO,kBAAS,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,qBAAU,EAAE,CAAC,CAAC;YAC3C,KAAK,qBAAa,CAAC,OAAO;gBACxB,OAAO,CAAC,CAAC;YACX,KAAK,qBAAa,CAAC,MAAM,CAAC;YAC1B;gBACE,OAAO,KAAK,CAAC;SAChB;IACH,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,MAAM,CAAC,GAAQ;IACtB,OAAO,CACL;QACE,iBAAS,CAAC,UAAU;QACpB,iBAAS,CAAC,OAAO;QACjB,iBAAS,CAAC,WAAW;QACrB,iBAAS,CAAC,KAAK;KAChB,CAAC,OAAO,CAAC,GAAgB,CAAC,IAAI,CAAC,CACjC,CAAC;AACJ,CAAC;AAED,kBAAe,KAAK,CAAC"}

hGameTest/node_modules/webpack-merge/lib/join-arrays-smart.js

@@ -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;

hGameTest/node_modules/webpack-merge/lib/join-arrays.js

@@ -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;
+  };
+}

hGameTest/node_modules/webpack-merge/lib/join-arrays.js.map

@@ -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"}

hGameTest/node_modules/webpack-merge/lib/types.js

@@ -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

hGameTest/node_modules/webpack-merge/lib/types.js.map

@@ -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"}

hGameTest/node_modules/webpack-merge/lib/unique.js

@@ -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;

hGameTest/node_modules/webpack-merge/lib/unique.js.map

@@ -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"}