First commit

hGameTest/node_modules/webpack-dev-server/lib/OptionsValidationError.js

@@ -0,0 +1,152 @@
+'use strict';
+
+/* eslint no-param-reassign: 'off' */
+
+const optionsSchema = require('./optionsSchema.json');
+
+const indent = (str, prefix, firstLine) => {
+  if (firstLine) {
+    return prefix + str.replace(/\n(?!$)/g, `\n${prefix}`);
+  }
+  return str.replace(/\n(?!$)/g, `\n${prefix}`);
+};
+
+const getSchemaPart = (path, parents, additionalPath) => {
+  parents = parents || 0;
+  path = path.split('/');
+  path = path.slice(0, path.length - parents);
+  if (additionalPath) {
+    additionalPath = additionalPath.split('/');
+    path = path.concat(additionalPath);
+  }
+  let schemaPart = optionsSchema;
+  for (let i = 1; i < path.length; i++) {
+    const inner = schemaPart[path[i]];
+    if (inner) { schemaPart = inner; }
+  }
+  return schemaPart;
+};
+
+const getSchemaPartText = (schemaPart, additionalPath) => {
+  if (additionalPath) {
+    for (let i = 0; i < additionalPath.length; i++) {
+      const inner = schemaPart[additionalPath[i]];
+      if (inner) { schemaPart = inner; }
+    }
+  }
+  while (schemaPart.$ref) schemaPart = getSchemaPart(schemaPart.$ref);
+  let schemaText = OptionsValidationError.formatSchema(schemaPart); // eslint-disable-line
+  if (schemaPart.description) { schemaText += `\n${schemaPart.description}`; }
+  return schemaText;
+};
+
+class OptionsValidationError extends Error {
+  constructor(validationErrors) {
+    super();
+
+    if (Error.hasOwnProperty('captureStackTrace')) { // eslint-disable-line
+      Error.captureStackTrace(this, this.constructor);
+    }
+    this.name = 'WebpackDevServerOptionsValidationError';
+
+    this.message = `${'Invalid configuration object. ' +
+   'webpack-dev-server has been initialised using a configuration object that does not match the API schema.\n'}${
+      validationErrors.map(err => ` - ${indent(OptionsValidationError.formatValidationError(err), '   ', false)}`).join('\n')}`;
+    this.validationErrors = validationErrors;
+  }
+
+  static formatSchema(schema, prevSchemas) {
+    prevSchemas = prevSchemas || [];
+
+    const formatInnerSchema = (innerSchema, addSelf) => {
+      if (!addSelf) return OptionsValidationError.formatSchema(innerSchema, prevSchemas);
+      if (prevSchemas.indexOf(innerSchema) >= 0) return '(recursive)';
+      return OptionsValidationError.formatSchema(innerSchema, prevSchemas.concat(schema));
+    };
+
+    if (schema.type === 'string') {
+      if (schema.minLength === 1) { return 'non-empty string'; } else if (schema.minLength > 1) { return `string (min length ${schema.minLength})`; }
+      return 'string';
+    } else if (schema.type === 'boolean') {
+      return 'boolean';
+    } else if (schema.type === 'number') {
+      return 'number';
+    } else if (schema.type === 'object') {
+      if (schema.properties) {
+        const required = schema.required || [];
+        return `object { ${Object.keys(schema.properties).map((property) => {
+          if (required.indexOf(property) < 0) return `${property}?`;
+          return property;
+        }).concat(schema.additionalProperties ? ['...'] : []).join(', ')} }`;
+      }
+      if (schema.additionalProperties) {
+        return `object { <key>: ${formatInnerSchema(schema.additionalProperties)} }`;
+      }
+      return 'object';
+    } else if (schema.type === 'array') {
+      return `[${formatInnerSchema(schema.items)}]`;
+    }
+
+    switch (schema.instanceof) {
+      case 'Function':
+        return 'function';
+      case 'RegExp':
+        return 'RegExp';
+      default:
+    }
+
+    if (schema.$ref) return formatInnerSchema(getSchemaPart(schema.$ref), true);
+    if (schema.allOf) return schema.allOf.map(formatInnerSchema).join(' & ');
+    if (schema.oneOf) return schema.oneOf.map(formatInnerSchema).join(' | ');
+    if (schema.anyOf) return schema.anyOf.map(formatInnerSchema).join(' | ');
+    if (schema.enum) return schema.enum.map(item => JSON.stringify(item)).join(' | ');
+    return JSON.stringify(schema, 0, 2);
+  }
+
+  static formatValidationError(err) {
+    const dataPath = `configuration${err.dataPath}`;
+    if (err.keyword === 'additionalProperties') {
+      return `${dataPath} has an unknown property '${err.params.additionalProperty}'. These properties are valid:\n${getSchemaPartText(err.parentSchema)}`;
+    } else if (err.keyword === 'oneOf' || err.keyword === 'anyOf') {
+      if (err.children && err.children.length > 0) {
+        return `${dataPath} should be one of these:\n${getSchemaPartText(err.parentSchema)}\n` +
+     `Details:\n${err.children.map(e => ` * ${indent(OptionsValidationError.formatValidationError(e), '   ', false)}`).join('\n')}`;
+      }
+      return `${dataPath} should be one of these:\n${getSchemaPartText(err.parentSchema)}`;
+    } else if (err.keyword === 'enum') {
+      if (err.parentSchema && err.parentSchema.enum && err.parentSchema.enum.length === 1) {
+        return `${dataPath} should be ${getSchemaPartText(err.parentSchema)}`;
+      }
+      return `${dataPath} should be one of these:\n${getSchemaPartText(err.parentSchema)}`;
+    } else if (err.keyword === 'allOf') {
+      return `${dataPath} should be:\n${getSchemaPartText(err.parentSchema)}`;
+    } else if (err.keyword === 'type') {
+      switch (err.params.type) {
+        case 'object':
+          return `${dataPath} should be an object.`;
+        case 'string':
+          return `${dataPath} should be a string.`;
+        case 'boolean':
+          return `${dataPath} should be a boolean.`;
+        case 'number':
+          return `${dataPath} should be a number.`;
+        case 'array':
+          return `${dataPath} should be an array:\n${getSchemaPartText(err.parentSchema)}`;
+        default:
+      }
+      return `${dataPath} should be ${err.params.type}:\n${getSchemaPartText(err.parentSchema)}`;
+    } else if (err.keyword === 'instanceof') {
+      return `${dataPath} should be an instance of ${getSchemaPartText(err.parentSchema)}.`;
+    } else if (err.keyword === 'required') {
+      const missingProperty = err.params.missingProperty.replace(/^\./, '');
+      return `${dataPath} misses the property '${missingProperty}'.\n${getSchemaPartText(err.parentSchema, ['properties', missingProperty])}`;
+    } else if (err.keyword === 'minLength' || err.keyword === 'minItems') {
+      if (err.params.limit === 1) { return `${dataPath} should not be empty.`; }
+      return `${dataPath} ${err.message}`;
+    }
+    // eslint-disable-line no-fallthrough
+    return `${dataPath} ${err.message} (${JSON.stringify(err, 0, 2)}).\n${getSchemaPartText(err.parentSchema)}`;
+  }
+}
+
+module.exports = OptionsValidationError;

hGameTest/node_modules/webpack-dev-server/lib/Server.js

@@ -0,0 +1,728 @@
+'use strict';
+
+/* eslint func-names: off */
+require('./polyfills');
+
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+const url = require('url');
+const chokidar = require('chokidar');
+const compress = require('compression');
+const del = require('del');
+const express = require('express');
+const httpProxyMiddleware = require('http-proxy-middleware');
+const ip = require('ip');
+const killable = require('killable');
+const serveIndex = require('serve-index');
+const historyApiFallback = require('connect-history-api-fallback');
+const selfsigned = require('selfsigned');
+const sockjs = require('sockjs');
+const spdy = require('spdy');
+const webpack = require('webpack');
+const webpackDevMiddleware = require('webpack-dev-middleware');
+const OptionsValidationError = require('./OptionsValidationError');
+const optionsSchema = require('./optionsSchema.json');
+
+// Workaround for sockjs@~0.3.19
+// sockjs will remove Origin header, however Origin header is required for checking host.
+// See https://github.com/webpack/webpack-dev-server/issues/1604 for more information
+{
+  // eslint-disable-next-line global-require
+  const SockjsSession = require('sockjs/lib/transport').Session;
+  const decorateConnection = SockjsSession.prototype.decorateConnection;
+  SockjsSession.prototype.decorateConnection = function (req) {
+    decorateConnection.call(this, req);
+    const connection = this.connection;
+    if (connection.headers && !('origin' in connection.headers) && 'origin' in req.headers) {
+      connection.headers.origin = req.headers.origin;
+    }
+  };
+}
+
+const clientStats = { errorDetails: false };
+const log = console.log; // eslint-disable-line no-console
+
+function Server(compiler, options) {
+  // Default options
+  if (!options) options = {};
+
+  const validationErrors = webpack.validateSchema(optionsSchema, options);
+  if (validationErrors.length) {
+    throw new OptionsValidationError(validationErrors);
+  }
+
+  if (options.lazy && !options.filename) {
+    throw new Error("'filename' option must be set in lazy mode.");
+  }
+
+  this.hot = options.hot || options.hotOnly;
+  this.headers = options.headers;
+  this.clientLogLevel = options.clientLogLevel;
+  this.clientOverlay = options.overlay;
+  this.progress = options.progress;
+  this.disableHostCheck = !!options.disableHostCheck;
+  this.publicHost = options.public;
+  this.allowedHosts = options.allowedHosts;
+  this.sockets = [];
+  this.contentBaseWatchers = [];
+  this.watchOptions = options.watchOptions || {};
+
+  // Listening for events
+  const invalidPlugin = () => {
+    this.sockWrite(this.sockets, 'invalid');
+  };
+  if (this.progress) {
+    const progressPlugin = new webpack.ProgressPlugin((percent, msg, addInfo) => {
+      percent = Math.floor(percent * 100);
+      if (percent === 100) msg = 'Compilation completed';
+      if (addInfo) msg = `${msg} (${addInfo})`;
+      this.sockWrite(this.sockets, 'progress-update', { percent, msg });
+    });
+    compiler.apply(progressPlugin);
+  }
+  compiler.plugin('compile', invalidPlugin);
+  compiler.plugin('invalid', invalidPlugin);
+  compiler.plugin('done', (stats) => {
+    this._sendStats(this.sockets, stats.toJson(clientStats));
+    this._stats = stats;
+  });
+
+  // Init express server
+  const app = this.app = new express(); // eslint-disable-line
+
+  app.all('*', (req, res, next) => { // eslint-disable-line
+    if (this.checkHost(req.headers)) { return next(); }
+    res.send('Invalid Host header');
+  });
+
+  const wdmOptions = {};
+
+  if (options.quiet === true) {
+    wdmOptions.logLevel = 'silent';
+  }
+  if (options.noInfo === true) {
+    wdmOptions.logLevel = 'warn';
+  }
+  // middleware for serving webpack bundle
+  this.middleware = webpackDevMiddleware(compiler, Object.assign({}, options, wdmOptions));
+
+  app.get('/__webpack_dev_server__/live.bundle.js', (req, res) => {
+    res.setHeader('Content-Type', 'application/javascript');
+    fs.createReadStream(path.join(__dirname, '..', 'client', 'live.bundle.js')).pipe(res);
+  });
+
+  app.get('/__webpack_dev_server__/sockjs.bundle.js', (req, res) => {
+    res.setHeader('Content-Type', 'application/javascript');
+    fs.createReadStream(path.join(__dirname, '..', 'client', 'sockjs.bundle.js')).pipe(res);
+  });
+
+  app.get('/webpack-dev-server.js', (req, res) => {
+    res.setHeader('Content-Type', 'application/javascript');
+    fs.createReadStream(path.join(__dirname, '..', 'client', 'index.bundle.js')).pipe(res);
+  });
+
+  app.get('/webpack-dev-server/*', (req, res) => {
+    res.setHeader('Content-Type', 'text/html');
+    fs.createReadStream(path.join(__dirname, '..', 'client', 'live.html')).pipe(res);
+  });
+
+  app.get('/webpack-dev-server', (req, res) => {
+    res.setHeader('Content-Type', 'text/html');
+    res.write('<!DOCTYPE html><html><head><meta charset="utf-8"/></head><body>');
+    const outputPath = this.middleware.getFilenameFromUrl(options.publicPath || '/');
+    const filesystem = this.middleware.fileSystem;
+
+    function writeDirectory(baseUrl, basePath) {
+      const content = filesystem.readdirSync(basePath);
+      res.write('<ul>');
+      content.forEach((item) => {
+        const p = `${basePath}/${item}`;
+        if (filesystem.statSync(p).isFile()) {
+          res.write('<li><a href="');
+          res.write(baseUrl + item);
+          res.write('">');
+          res.write(item);
+          res.write('</a></li>');
+          if (/\.js$/.test(item)) {
+            const htmlItem = item.substr(0, item.length - 3);
+            res.write('<li><a href="');
+            res.write(baseUrl + htmlItem);
+            res.write('">');
+            res.write(htmlItem);
+            res.write('</a> (magic html for ');
+            res.write(item);
+            res.write(') (<a href="');
+            res.write(baseUrl.replace(/(^(https?:\/\/[^\/]+)?\/)/, "$1webpack-dev-server/") + htmlItem); // eslint-disable-line
+            res.write('">webpack-dev-server</a>)</li>');
+          }
+        } else {
+          res.write('<li>');
+          res.write(item);
+          res.write('<br>');
+          writeDirectory(`${baseUrl + item}/`, p);
+          res.write('</li>');
+        }
+      });
+      res.write('</ul>');
+    }
+    writeDirectory(options.publicPath || '/', outputPath);
+    res.end('</body></html>');
+  });
+
+  let contentBase;
+  if (options.contentBase !== undefined) { // eslint-disable-line
+    contentBase = options.contentBase; // eslint-disable-line
+  } else {
+    contentBase = process.cwd();
+  }
+
+  // Keep track of websocket proxies for external websocket upgrade.
+  const websocketProxies = [];
+
+  const features = {
+    compress() {
+      if (options.compress) {
+        // Enable gzip compression.
+        app.use(compress());
+      }
+    },
+
+    proxy() {
+      if (options.proxy) {
+        /**
+          * Assume a proxy configuration specified as:
+          * proxy: {
+          *   'context': { options }
+          * }
+          * OR
+          * proxy: {
+          *   'context': 'target'
+          * }
+          */
+        if (!Array.isArray(options.proxy)) {
+          options.proxy = Object.keys(options.proxy).map((context) => {
+            let proxyOptions;
+            // For backwards compatibility reasons.
+            const correctedContext = context.replace(/^\*$/, '**').replace(/\/\*$/, '');
+
+            if (typeof options.proxy[context] === 'string') {
+              proxyOptions = {
+                context: correctedContext,
+                target: options.proxy[context]
+              };
+            } else {
+              proxyOptions = Object.assign({}, options.proxy[context]);
+              proxyOptions.context = correctedContext;
+            }
+            proxyOptions.logLevel = proxyOptions.logLevel || 'warn';
+
+            return proxyOptions;
+          });
+        }
+
+        const getProxyMiddleware = (proxyConfig) => {
+          const context = proxyConfig.context || proxyConfig.path;
+
+          // It is possible to use the `bypass` method without a `target`.
+          // However, the proxy middleware has no use in this case, and will fail to instantiate.
+          if (proxyConfig.target) {
+            return httpProxyMiddleware(context, proxyConfig);
+          }
+        };
+
+        /**
+        * Assume a proxy configuration specified as:
+        * proxy: [
+        *   {
+        *     context: ...,
+        *     ...options...
+        *   },
+        *   // or:
+        *   function() {
+        *     return {
+        *       context: ...,
+        *       ...options...
+        *     };
+        *   }
+        * ]
+        */
+        options.proxy.forEach((proxyConfigOrCallback) => {
+          let proxyConfig;
+          let proxyMiddleware;
+
+          if (typeof proxyConfigOrCallback === 'function') {
+            proxyConfig = proxyConfigOrCallback();
+          } else {
+            proxyConfig = proxyConfigOrCallback;
+          }
+
+          proxyMiddleware = getProxyMiddleware(proxyConfig);
+          if (proxyConfig.ws) {
+            websocketProxies.push(proxyMiddleware);
+          }
+
+          app.use((req, res, next) => {
+            if (typeof proxyConfigOrCallback === 'function') {
+              const newProxyConfig = proxyConfigOrCallback();
+              if (newProxyConfig !== proxyConfig) {
+                proxyConfig = newProxyConfig;
+                proxyMiddleware = getProxyMiddleware(proxyConfig);
+              }
+            }
+            const bypass = typeof proxyConfig.bypass === 'function';
+            // eslint-disable-next-line
+            const bypassUrl = bypass && proxyConfig.bypass(req, res, proxyConfig) || false;
+
+            if (bypassUrl) {
+              req.url = bypassUrl;
+              next();
+            } else if (proxyMiddleware) {
+              return proxyMiddleware(req, res, next);
+            } else {
+              next();
+            }
+          });
+        });
+      }
+    },
+
+    historyApiFallback() {
+      if (options.historyApiFallback) {
+        // Fall back to /index.html if nothing else matches.
+        app.use(historyApiFallback(typeof options.historyApiFallback === 'object' ? options.historyApiFallback : null));
+      }
+    },
+
+    contentBaseFiles() {
+      if (Array.isArray(contentBase)) {
+        contentBase.forEach((item) => {
+          app.get('*', express.static(item));
+        });
+      } else if (/^(https?:)?\/\//.test(contentBase)) {
+        log('Using a URL as contentBase is deprecated and will be removed in the next major version. Please use the proxy option instead.');
+        log('proxy: {\n\t"*": "<your current contentBase configuration>"\n}'); // eslint-disable-line quotes
+        // Redirect every request to contentBase
+        app.get('*', (req, res) => {
+          res.writeHead(302, {
+            Location: contentBase + req.path + (req._parsedUrl.search || '')
+          });
+          res.end();
+        });
+      } else if (typeof contentBase === 'number') {
+        log('Using a number as contentBase is deprecated and will be removed in the next major version. Please use the proxy option instead.');
+        log('proxy: {\n\t"*": "//localhost:<your current contentBase configuration>"\n}'); // eslint-disable-line quotes
+        // Redirect every request to the port contentBase
+        app.get('*', (req, res) => {
+          res.writeHead(302, {
+            Location: `//localhost:${contentBase}${req.path}${req._parsedUrl.search || ''}`
+          });
+          res.end();
+        });
+      } else {
+        // route content request
+        app.get('*', express.static(contentBase, options.staticOptions));
+      }
+    },
+
+    contentBaseIndex() {
+      if (Array.isArray(contentBase)) {
+        contentBase.forEach((item) => {
+          app.get('*', serveIndex(item));
+        });
+      } else if (!/^(https?:)?\/\//.test(contentBase) && typeof contentBase !== 'number') {
+        app.get('*', serveIndex(contentBase));
+      }
+    },
+
+    watchContentBase: () => {
+      if (/^(https?:)?\/\//.test(contentBase) || typeof contentBase === 'number') {
+        throw new Error('Watching remote files is not supported.');
+      } else if (Array.isArray(contentBase)) {
+        contentBase.forEach((item) => {
+          this._watch(item);
+        });
+      } else {
+        this._watch(contentBase);
+      }
+    },
+
+    before: () => {
+      if (typeof options.before === 'function') {
+        options.before(app, this);
+      }
+    },
+
+    middleware: () => {
+      // include our middleware to ensure it is able to handle '/index.html' request after redirect
+      app.use(this.middleware);
+    },
+
+    after: () => {
+      if (typeof options.after === 'function') { options.after(app, this); }
+    },
+
+    headers: () => {
+      app.all('*', this.setContentHeaders.bind(this));
+    },
+
+    magicHtml: () => {
+      app.get('*', this.serveMagicHtml.bind(this));
+    },
+
+    setup: () => {
+      if (typeof options.setup === 'function') {
+        log('The `setup` option is deprecated and will be removed in v3. Please update your config to use `before`');
+        options.setup(app, this);
+      }
+    }
+  };
+
+  const defaultFeatures = ['before', 'setup', 'headers', 'middleware'];
+  if (options.proxy) { defaultFeatures.push('proxy', 'middleware'); }
+  if (contentBase !== false) { defaultFeatures.push('contentBaseFiles'); }
+  if (options.watchContentBase) { defaultFeatures.push('watchContentBase'); }
+  if (options.historyApiFallback) {
+    defaultFeatures.push('historyApiFallback', 'middleware');
+    if (contentBase !== false) { defaultFeatures.push('contentBaseFiles'); }
+  }
+  defaultFeatures.push('magicHtml');
+  if (contentBase !== false) { defaultFeatures.push('contentBaseIndex'); }
+  // compress is placed last and uses unshift so that it will be the first middleware used
+  if (options.compress) { defaultFeatures.unshift('compress'); }
+  if (options.after) { defaultFeatures.push('after'); }
+
+  (options.features || defaultFeatures).forEach((feature) => {
+    features[feature]();
+  });
+
+  if (options.https) {
+    // for keep supporting CLI parameters
+    if (typeof options.https === 'boolean') {
+      options.https = {
+        key: options.key,
+        cert: options.cert,
+        ca: options.ca,
+        pfx: options.pfx,
+        passphrase: options.pfxPassphrase,
+        requestCert: options.requestCert || false
+      };
+    }
+
+    let fakeCert;
+    if (!options.https.key || !options.https.cert) {
+      // Use a self-signed certificate if no certificate was configured.
+      // Cycle certs every 24 hours
+      const certPath = path.join(__dirname, '../ssl/server.pem');
+      let certExists = fs.existsSync(certPath);
+
+      if (certExists) {
+        const certStat = fs.statSync(certPath);
+        const certTtl = 1000 * 60 * 60 * 24;
+        const now = new Date();
+
+        // cert is more than 30 days old, kill it with fire
+        if ((now - certStat.ctime) / certTtl > 30) {
+          log('SSL Certificate is more than 30 days old. Removing.');
+          del.sync([certPath], { force: true });
+          certExists = false;
+        }
+      }
+
+      if (!certExists) {
+        log('Generating SSL Certificate');
+        const attrs = [{ name: 'commonName', value: 'localhost' }];
+        const pems = selfsigned.generate(attrs, {
+          algorithm: 'sha256',
+          days: 30,
+          keySize: 2048,
+          extensions: [{
+            name: 'basicConstraints',
+            cA: true
+          }, {
+            name: 'keyUsage',
+            keyCertSign: true,
+            digitalSignature: true,
+            nonRepudiation: true,
+            keyEncipherment: true,
+            dataEncipherment: true
+          }, {
+            name: 'subjectAltName',
+            altNames: [
+              {
+                // type 2 is DNS
+                type: 2,
+                value: 'localhost'
+              },
+              {
+                type: 2,
+                value: 'localhost.localdomain'
+              },
+              {
+                type: 2,
+                value: 'lvh.me'
+              },
+              {
+                type: 2,
+                value: '*.lvh.me'
+              },
+              {
+                type: 2,
+                value: '[::1]'
+              },
+              {
+                // type 7 is IP
+                type: 7,
+                ip: '127.0.0.1'
+              },
+              {
+                type: 7,
+                ip: 'fe80::1'
+              }
+            ]
+          }]
+        });
+
+        fs.writeFileSync(certPath, pems.private + pems.cert, { encoding: 'utf-8' });
+      }
+      fakeCert = fs.readFileSync(certPath);
+    }
+
+    options.https.key = options.https.key || fakeCert;
+    options.https.cert = options.https.cert || fakeCert;
+
+    if (!options.https.spdy) {
+      options.https.spdy = {
+        protocols: ['h2', 'http/1.1']
+      };
+    }
+
+    this.listeningApp = spdy.createServer(options.https, app);
+  } else {
+    this.listeningApp = http.createServer(app);
+  }
+
+  killable(this.listeningApp);
+
+  // Proxy websockets without the initial http request
+  // https://github.com/chimurai/http-proxy-middleware#external-websocket-upgrade
+  websocketProxies.forEach(function (wsProxy) {
+    this.listeningApp.on('upgrade', wsProxy.upgrade);
+  }, this);
+}
+
+Server.prototype.use = function () {
+  // eslint-disable-next-line
+  this.app.use.apply(this.app, arguments);
+};
+
+Server.prototype.setContentHeaders = function (req, res, next) {
+  if (this.headers) {
+    for (const name in this.headers) { // eslint-disable-line
+      res.setHeader(name, this.headers[name]);
+    }
+  }
+
+  next();
+};
+
+Server.prototype.checkHost = function (headers, headerToCheck) {
+  // allow user to opt-out this security check, at own risk
+  if (this.disableHostCheck) return true;
+
+  if (!headerToCheck) headerToCheck = 'host';
+  // get the Host header and extract hostname
+  // we don't care about port not matching
+  const hostHeader = headers[headerToCheck];
+  if (!hostHeader) return false;
+
+  // use the node url-parser to retrieve the hostname from the host-header.
+  const hostname = url.parse(
+    // if hostHeader doesn't have scheme, add // for parsing.
+    /^(.+:)?\/\//.test(hostHeader) ? hostHeader : `//${hostHeader}`,
+    false,
+    true
+  ).hostname;
+
+  // always allow requests with explicit IPv4 or IPv6-address.
+  // A note on IPv6 addresses: hostHeader will always contain the brackets denoting
+  // an IPv6-address in URLs, these are removed from the hostname in url.parse(),
+  // so we have the pure IPv6-address in hostname.
+  if (ip.isV4Format(hostname) || ip.isV6Format(hostname)) return true;
+
+  // always allow localhost host, for convience
+  if (hostname === 'localhost') return true;
+
+  // allow if hostname is in allowedHosts
+  if (this.allowedHosts && this.allowedHosts.length) {
+    for (let hostIdx = 0; hostIdx < this.allowedHosts.length; hostIdx++) {
+      const allowedHost = this.allowedHosts[hostIdx];
+      if (allowedHost === hostname) return true;
+
+      // support "." as a subdomain wildcard
+      // e.g. ".example.com" will allow "example.com", "www.example.com", "subdomain.example.com", etc
+      if (allowedHost[0] === '.') {
+        // "example.com"
+        if (hostname === allowedHost.substring(1)) return true;
+        // "*.example.com"
+        if (hostname.endsWith(allowedHost)) return true;
+      }
+    }
+  }
+
+  // allow hostname of listening adress
+  if (hostname === this.listenHostname) return true;
+
+  // also allow public hostname if provided
+  if (typeof this.publicHost === 'string') {
+    const idxPublic = this.publicHost.indexOf(':');
+    const publicHostname = idxPublic >= 0 ? this.publicHost.substr(0, idxPublic) : this.publicHost;
+    if (hostname === publicHostname) return true;
+  }
+
+  // disallow
+  return false;
+};
+
+// delegate listen call and init sockjs
+Server.prototype.listen = function (port, hostname, fn) {
+  this.listenHostname = hostname;
+  // eslint-disable-next-line
+
+  const returnValue = this.listeningApp.listen(port, hostname, (err) => {
+    const sockServer = sockjs.createServer({
+      // Use provided up-to-date sockjs-client
+      sockjs_url: '/__webpack_dev_server__/sockjs.bundle.js',
+      // Limit useless logs
+      log(severity, line) {
+        if (severity === 'error') {
+          log(line);
+        }
+      }
+    });
+
+    sockServer.on('connection', (conn) => {
+      if (!conn) return;
+      if (!this.checkHost(conn.headers) || !this.checkHost(conn.headers, 'origin')) {
+        this.sockWrite([conn], 'error', 'Invalid Host/Origin header');
+        conn.close();
+        return;
+      }
+      this.sockets.push(conn);
+
+      conn.on('close', () => {
+        const connIndex = this.sockets.indexOf(conn);
+        if (connIndex >= 0) {
+          this.sockets.splice(connIndex, 1);
+        }
+      });
+
+      if (this.clientLogLevel) { this.sockWrite([conn], 'log-level', this.clientLogLevel); }
+
+      if (this.progress) { this.sockWrite([conn], 'progress', this.progress); }
+
+      if (this.clientOverlay) { this.sockWrite([conn], 'overlay', this.clientOverlay); }
+
+      if (this.hot) this.sockWrite([conn], 'hot');
+
+      if (!this._stats) return;
+      this._sendStats([conn], this._stats.toJson(clientStats), true);
+    });
+
+    sockServer.installHandlers(this.listeningApp, {
+      prefix: '/sockjs-node'
+    });
+
+    if (fn) {
+      fn.call(this.listeningApp, err);
+    }
+  });
+
+  return returnValue;
+};
+
+Server.prototype.close = function (callback) {
+  this.sockets.forEach((sock) => {
+    sock.close();
+  });
+  this.sockets = [];
+
+  this.contentBaseWatchers.forEach((watcher) => {
+    watcher.close();
+  });
+  this.contentBaseWatchers = [];
+
+  this.listeningApp.kill(() => {
+    this.middleware.close(callback);
+  });
+};
+
+Server.prototype.sockWrite = function (sockets, type, data) {
+  sockets.forEach((sock) => {
+    sock.write(JSON.stringify({
+      type,
+      data
+    }));
+  });
+};
+
+Server.prototype.serveMagicHtml = function (req, res, next) {
+  const _path = req.path;
+  try {
+    if (!this.middleware.fileSystem.statSync(this.middleware.getFilenameFromUrl(`${_path}.js`)).isFile()) { return next(); }
+    // Serve a page that executes the javascript
+    res.write('<!DOCTYPE html><html><head><meta charset="utf-8"/></head><body><script type="text/javascript" charset="utf-8" src="');
+    res.write(_path);
+    res.write('.js');
+    res.write(req._parsedUrl.search || '');
+    res.end('"></script></body></html>');
+  } catch (e) {
+    return next();
+  }
+};
+
+// send stats to a socket or multiple sockets
+Server.prototype._sendStats = function (sockets, stats, force) {
+  if (!force &&
+  stats &&
+  (!stats.errors || stats.errors.length === 0) &&
+  stats.assets &&
+  stats.assets.every(asset => !asset.emitted)
+  ) { return this.sockWrite(sockets, 'still-ok'); }
+  this.sockWrite(sockets, 'hash', stats.hash);
+  if (stats.errors.length > 0) { this.sockWrite(sockets, 'errors', stats.errors); } else if (stats.warnings.length > 0) { this.sockWrite(sockets, 'warnings', stats.warnings); } else { this.sockWrite(sockets, 'ok'); }
+};
+
+Server.prototype._watch = function (watchPath) {
+  // duplicate the same massaging of options that watchpack performs
+  // https://github.com/webpack/watchpack/blob/master/lib/DirectoryWatcher.js#L49
+  // this isn't an elegant solution, but we'll improve it in the future
+  const usePolling = this.watchOptions.poll ? true : undefined; // eslint-disable-line no-undefined
+  const interval = typeof this.watchOptions.poll === 'number' ? this.watchOptions.poll : undefined; // eslint-disable-line no-undefined
+  const options = {
+    ignoreInitial: true,
+    persistent: true,
+    followSymlinks: false,
+    depth: 0,
+    atomic: false,
+    alwaysStat: true,
+    ignorePermissionErrors: true,
+    ignored: this.watchOptions.ignored,
+    usePolling,
+    interval
+  };
+  const watcher = chokidar.watch(watchPath, options).on('change', () => {
+    this.sockWrite(this.sockets, 'content-changed');
+  });
+
+  this.contentBaseWatchers.push(watcher);
+};
+
+Server.prototype.invalidate = function () {
+  if (this.middleware) this.middleware.invalidate();
+};
+
+// Export this logic, so that other implementations, like task-runners can use it
+Server.addDevServerEntrypoints = require('./util/addDevServerEntrypoints');
+
+module.exports = Server;

hGameTest/node_modules/webpack-dev-server/lib/optionsSchema.json

@@ -0,0 +1,336 @@
+{
+  "additionalProperties": false,
+  "properties": {
+    "hot": {
+      "description": "Enables Hot Module Replacement.",
+      "type": "boolean"
+    },
+    "hotOnly": {
+      "description": "Enables Hot Module Replacement without page refresh as fallback.",
+      "type": "boolean"
+    },
+    "lazy": {
+      "description": "Disables watch mode and recompiles bundle only on a request.",
+      "type": "boolean"
+    },
+    "bonjour": {
+      "description": "Publishes the ZeroConf DNS service",
+      "type": "boolean"
+    },
+    "host": {
+      "description": "The host the server listens to.",
+      "type": "string"
+    },
+    "allowedHosts": {
+      "description": "Specifies which hosts are allowed to access the dev server.",
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "filename": {
+      "description": "The filename that needs to be requested in order to trigger a recompile (only in lazy mode).",
+      "anyOf": [
+        {
+          "instanceof": "RegExp"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "publicPath": {
+      "description": "URL path where the webpack files are served from.",
+      "type": "string"
+    },
+    "port": {
+      "description": "The port the server listens to.",
+      "anyOf": [
+        {
+          "type": "number"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "socket": {
+      "description": "The Unix socket to listen to (instead of on a host).",
+      "type": "string"
+    },
+    "watchOptions": {
+      "description": "Options for changing the watch behavior.",
+      "type": "object"
+    },
+    "headers": {
+      "description": "Response headers that are added to each response.",
+      "type": "object"
+    },
+    "clientLogLevel": {
+      "description": "Controls the log messages shown in the browser.",
+      "enum": [
+        "none",
+        "info",
+        "warning",
+        "error"
+      ]
+    },
+    "overlay": {
+      "description": "Shows an error overlay in browser.",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "errors": {
+              "type": "boolean"
+            },
+            "warnings": {
+              "type": "boolean"
+            }
+          }
+        }
+      ]
+    },
+    "progress": {
+      "description": "Shows compilation progress in browser console.",
+      "type": "boolean"
+    },
+    "key": {
+      "description": "The contents of a SSL key.",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Buffer"
+        }
+      ]
+    },
+    "cert": {
+      "description": "The contents of a SSL certificate.",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Buffer"
+        }
+      ]
+    },
+    "ca": {
+      "description": "The contents of a SSL CA certificate.",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Buffer"
+        }
+      ]
+    },
+    "pfx": {
+      "description": "The contents of a SSL pfx file.",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Buffer"
+        }
+      ]
+    },
+    "pfxPassphrase": {
+      "description": "The passphrase to a (SSL) PFX file.",
+      "type": "string"
+    },
+    "requestCert": {
+      "description": "Enables request for client certificate. This is passed directly to the https server.",
+      "type": "boolean"
+    },
+    "inline": {
+      "description": "Enable inline mode to include client scripts in bundle (CLI-only).",
+      "type": "boolean"
+    },
+    "disableHostCheck": {
+      "description": "Disable the Host header check (Security).",
+      "type": "boolean"
+    },
+    "public": {
+      "description": "The public hostname/ip address of the server.",
+      "type": "string"
+    },
+    "https": {
+      "description": "Enable HTTPS for server.",
+      "anyOf": [
+        {
+          "type": "object"
+        },
+        {
+          "type": "boolean"
+        }
+      ]
+    },
+    "contentBase": {
+      "description": "A directory to serve files non-webpack files from.",
+      "anyOf": [
+        {
+          "items": {
+            "type": "string"
+          },
+          "minItems": 1,
+          "type": "array"
+        },
+        {
+          "enum": [
+            false
+          ]
+        },
+        {
+          "type": "number"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "watchContentBase": {
+      "description": "Watches the contentBase directory for changes.",
+      "type": "boolean"
+    },
+    "open": {
+      "description": "Let the CLI open your browser with the URL.",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "boolean"
+        }
+      ]
+    },
+    "useLocalIp": {
+      "description": "Let the browser open with your local IP.",
+      "type": "boolean"
+    },
+    "openPage": {
+      "description": "Let the CLI open your browser to a specific page on the site.",
+      "type": "string"
+    },
+    "features": {
+      "description": "The order of which the features will be triggered.",
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    "compress": {
+      "description": "Gzip compression for all requests.",
+      "type": "boolean"
+    },
+    "proxy": {
+      "description": "Proxy requests to another server.",
+      "anyOf": [
+        {
+          "items": {
+            "anyOf": [
+              {
+                "type": "object"
+              },
+              {
+                "instanceof": "Function"
+              }
+            ]
+          },
+          "minItems": 1,
+          "type": "array"
+        },
+        {
+          "type": "object"
+        }
+      ]
+    },
+    "historyApiFallback": {
+      "description": "404 fallback to a specified file.",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object"
+        }
+      ]
+    },
+    "staticOptions": {
+      "description": "Options for static files served with contentBase.",
+      "type": "object"
+    },
+    "setup": {
+      "description": "Exposes the Express server to add custom middleware or routes.",
+      "instanceof": "Function"
+    },
+    "before": {
+      "description": "Exposes the Express server to add custom middleware or routes before webpack-dev-middleware will be added.",
+      "instanceof": "Function"
+    },
+    "after": {
+      "description": "Exposes the Express server to add custom middleware or routes after webpack-dev-middleware got added.",
+      "instanceof": "Function"
+    },
+    "stats": {
+      "description": "Decides what bundle information is displayed.",
+      "anyOf": [
+        {
+          "type": "object"
+        },
+        {
+          "type": "boolean"
+        },
+        {
+          "enum": [
+            "none",
+            "errors-only",
+            "minimal",
+            "normal",
+            "verbose"
+          ]
+        }
+      ]
+    },
+    "reporter": {
+      "description": "Customize what the console displays when compiling.",
+      "instanceof": "Function"
+    },
+    "reportTime": {
+      "description": "Report time before and after compiling in console displays.",
+      "type": "boolean"
+    },
+    "noInfo": {
+      "description": "Hide all info messages on console.",
+      "type": "boolean"
+    },
+    "quiet": {
+      "description": "Hide all messages on console.",
+      "type": "boolean"
+    },
+    "serverSideRender": {
+      "description": "Expose stats for server side rendering (experimental).",
+      "type": "boolean"
+    },
+    "index": {
+      "description": "The filename that is considered the index file.",
+      "type": "string"
+    },
+    "log": {
+      "description": "Customize info logs for webpack-dev-middleware.",
+      "instanceof": "Function"
+    },
+    "warn": {
+      "description": "Customize warn logs for webpack-dev-middleware.",
+      "instanceof": "Function"
+    }
+  },
+  "type": "object"
+}

hGameTest/node_modules/webpack-dev-server/lib/polyfills.js

@@ -0,0 +1,8 @@
+'use strict';
+
+/* polyfills for Node 4.8.x users */
+
+// internal-ip@2.x uses [].includes
+const includes = require('array-includes');
+
+includes.shim();

hGameTest/node_modules/webpack-dev-server/lib/util/addDevServerEntrypoints.js

@@ -0,0 +1,40 @@
+'use strict';
+
+/* eslint no-param-reassign: 'off' */
+
+const createDomain = require('./createDomain');
+
+module.exports = function addDevServerEntrypoints(webpackOptions, devServerOptions, listeningApp) {
+  if (devServerOptions.inline !== false) {
+    // we're stubbing the app in this method as it's static and doesn't require
+    // a listeningApp to be supplied. createDomain requires an app with the
+    // address() signature.
+    const app = listeningApp || {
+      address() {
+        return { port: devServerOptions.port };
+      }
+    };
+    const domain = createDomain(devServerOptions, app);
+    const devClient = [`${require.resolve('../../client/')}?${domain}`];
+
+    if (devServerOptions.hotOnly) { devClient.push('webpack/hot/only-dev-server'); } else if (devServerOptions.hot) { devClient.push('webpack/hot/dev-server'); }
+
+    const prependDevClient = (entry) => {
+      if (typeof entry === 'function') {
+        return () => Promise.resolve(entry()).then(prependDevClient);
+      }
+      if (typeof entry === 'object' && !Array.isArray(entry)) {
+        const entryClone = {};
+        Object.keys(entry).forEach((key) => {
+          entryClone[key] = devClient.concat(entry[key]);
+        });
+        return entryClone;
+      }
+      return devClient.concat(entry);
+    };
+
+    [].concat(webpackOptions).forEach((wpOpt) => {
+      wpOpt.entry = prependDevClient(wpOpt.entry);
+    });
+  }
+};

hGameTest/node_modules/webpack-dev-server/lib/util/createDomain.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const url = require('url');
+const internalIp = require('internal-ip');
+
+
+module.exports = function createDomain(options, listeningApp) {
+  const protocol = options.https ? 'https' : 'http';
+  const appPort = listeningApp ? listeningApp.address().port : 0;
+  const port = options.socket ? 0 : appPort;
+  const hostname = options.useLocalIp ? internalIp.v4() : options.host;
+
+  // use explicitly defined public url (prefix with protocol if not explicitly given)
+  if (options.public) {
+    return /^[a-zA-Z]+:\/\//.test(options.public) ? `${options.public}` : `${protocol}://${options.public}`;
+  }
+  // the formatted domain (url without path) of the webpack server
+  return url.format({
+    protocol,
+    hostname,
+    port
+  });
+};