How to use the internal-ip.v4 function in 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
  });
};

// In development, we always serve from the root. This makes config easier.
var publicPath = '/';
// `publicUrl` is just like `publicPath`, but we will provide it to our app
// as %PUBLIC_URL% in `index.html` and `process.env.PUBLIC_URL` in JavaScript.
// Omit trailing slash as %PUBLIC_PATH%/xyz looks better than %PUBLIC_PATH%xyz.
var publicUrl = '';
var entry = {};

if (isProducation) {
  entry['index.bundle.min'] = [paths.appIndexJs];
} else {
  entry['index.bundle'] = [paths.appIndexJs];
}

if (!isProducation) {
  var ip = internalIp.v4();
  var port = 8080;
  var webUrl = 'http://' + ip + ':' + port;
  var bundleUrl = 'http://' + ip + ':' + port + '/js/index.bundle.js';
  var weexBundleUrl = bundleUrl + '?_wx_tpl=' + bundleUrl;

  qrcode.generate(webUrl, {small: true});
  console.log('Web: scan above QRCode ' + webUrl + ' or direct open in browser.\n');

  qrcode.generate(weexBundleUrl, {small: true});
  console.log('Weex: scan above QRCode ' + weexBundleUrl + ' use weex playground.\n');
}

module.exports = {
  // Compile target should "web" when use hot reload
  target: isProducation ? 'node' : 'web',

res.locals.isomorphic = {
                exports: data.exports,
                buildManifest: data.buildManifest,
            };
            next();
        },
        // Setup the render middlewares that will call render() & renderError()
        render(),
        renderError()
    );

    // Start server
    await pify(app.listen).call(app, port, host);

    const url = `http://${host === '0.0.0.0' ? '127.0.0.1' : host}:${port}`;
    const lanUrl = `http://${await internalIp.v4()}:${port}`;

    process.stdout.write(`Server address:            ${url}\n`);
    process.stdout.write(`LAN server address:        ${lanUrl}\n`);
    process.stdout.write(`Compression:               ${compress ? 'on' : 'off'}\n`);
    process.stdout.write('\nServer is now up and running, press CTRL-C to stop.\n');
}

module.exports = function createDomain(options) {
	const protocol = options.https ? "https" : "http";

	// the formatted domain (url without path) of the webpack server
	return options.public ? `${protocol}://${options.public}` : url.format({
		protocol: protocol,
		hostname: options.useLocalIp ? internalIp.v4() : options.host,
		port: options.socket ? 0 : options.port.toString()
	});
};

var buffer = require('vinyl-buffer')
/* eslint-disable no-unused-vars */
var babelify = require('babelify')
/* eslint-enable no-unused-vars */
var gutil = require('gulp-util')
var autoprefixer = require('gulp-autoprefixer')
var less = require('gulp-less')
var rename = require('gulp-rename')
var eventStream = require('event-stream')
var username = require('username')
var replace = require('gulp-replace')
var internalIp = require('internal-ip')


var basePath = path.resolve(__dirname, '..')
var ipv4Address = internalIp.v4()

gulp.task('default', () =>
  /*****
  * Note: really need to have browserify run first as I ran into a big issue
  * that was hard to track down because the bundle files hadn't been updated.
  */
  runSequence(
    'browserify',
    'nodemon',
    'browser-sync',
    'watch-less',
    'watch-js'
  )
)

gulp.task('nodemon', cb => {

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Koa = require("koa");
var internalIP = require("internal-ip");
var path = require("path");
var body = require("koa-body");
var logger = require("koa-logger");
var compress = require("koa-compress");
var staticServer = require("koa-static");
var router = require("./router");
var app = new Koa();
var host = internalIP.v4() || '0.0.0.0';
var port = 3000;
app.use(staticServer(path.join(__dirname, './public')))
    .use(body())
    .use(logger())
    .use(compress())
    .use(router.routes())
    .use(router.allowedMethods());
app.listen(port, function () {
    console.log("koa app start at port " + port);
});

app.use(require('webpack-dev-middleware')(compiler, {
  noInfo: true,
  publicPath: config.output.publicPath,
  stats: {
    colors: true
  }
}));

app.use(require('webpack-hot-middleware')(compiler));

app.get('*', function (req, res) {
  res.sendFile(path.join(__dirname, './spec/index.html'));
});

const port = 8081;
const ip = internalIp.v4();

app.listen(port, (err) => {
  if (err) {
    console.log(err);
    return;
  }

  console.log(' --------------------------------------');
  console.log(`    Local: http://0.0.0.0:${port}`);
  console.log(` External: http://${ip}:${port}`);
  console.log(' --------------------------------------');
});

compiler.plugin('done', () => {
      const url = `http://${this.host}:${this.port}`
      console.log(`> Running on ${url}`)
      if (this.host === '0.0.0.0') {
        console.log(chalk.dim(`To visit it on other device, connect your devices to the same network and open http://${require('internal-ip').v4()}:${this.port}`))
      }
      if (this.open) {
        require('opn')(url)
      }
    })
  }

if (didFire) {
          callback && callback();
          return;
        }
        const port = compiler.options.devServer.port || '';

        const isHostCorrect =
          compiler.options.devServer.host.trim() === '0.0.0.0';

        if (!isHostCorrect) {
          showHostWarning();
          callback && callback();
          return;
        }

        const ip = internalIp.v4().then( ip => {
          const address = `http://${ip}${port && `:${port}`}`;

          const { size } = this.options;

          qrCode.generate(address, { small: size === 'small'}, code => {
            console.log('QR Code generated');
            console.log('Scan code below to visit', address);
            console.log(code);
            didFire = true;
            callback && callback();
          });
        }).catch( err => {
          return callback && callback(err);
        });
      });
    } else {

async play({ name, type, index, infoHash }, cb) {
    const { selectedPlayer } = root;

    const ipAddr = await ip.v4();
    if (selectedPlayer) {
      const src = `http://${ipAddr}:${window.location
        .port}/api/download/${infoHash}/${+index}/${name}`;

      selectedPlayer.play(
        src,
        {
          type,
          title: name,
        },
        (err) => {
          if (err) {
            showToast(err.message, 'error');
            this.connect(selectedPlayer);
          }
          if (cb) cb(err);