initial commit taken from gitlab.lrz.de

node_modules/metro-core/README.md

@@ -0,0 +1,5 @@
+# Metro
+
+🚇 This package contains core files for [Metro](https://facebook.github.io/metro/).
+
+(TODO)

node_modules/metro-core/package.json

@@ -0,0 +1,90 @@
+{
+  "_args": [
+    [
+      "metro-core@^0.30.0",
+      "/home/bernhard/freifunk-app/node_modules/react-native"
+    ]
+  ],
+  "_from": "metro-core@>=0.30.0 <0.31.0",
+  "_id": "metro-core@0.30.2",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/metro-core",
+  "_nodeVersion": "8.9.4",
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/metro-core_0.30.2_1521165819134_0.2061729452128087"
+  },
+  "_npmUser": {
+    "email": "rafeca@gmail.com",
+    "name": "rafeca"
+  },
+  "_npmVersion": "5.6.0",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "metro-core",
+    "raw": "metro-core@^0.30.0",
+    "rawSpec": "^0.30.0",
+    "scope": null,
+    "spec": ">=0.30.0 <0.31.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/metro",
+    "/react-native"
+  ],
+  "_resolved": "https://registry.npmjs.org/metro-core/-/metro-core-0.30.2.tgz",
+  "_shasum": "380ae13cceee29e5be166df7acca9f1daa19fd7e",
+  "_shrinkwrap": null,
+  "_spec": "metro-core@^0.30.0",
+  "_where": "/home/bernhard/freifunk-app/node_modules/react-native",
+  "bugs": {
+    "url": "https://github.com/facebook/metro/issues"
+  },
+  "dependencies": {
+    "lodash.throttle": "^4.1.1",
+    "wordwrap": "^1.0.0"
+  },
+  "description": "🚇 Core files for Metro",
+  "devDependencies": {},
+  "directories": {},
+  "dist": {
+    "fileCount": 15,
+    "integrity": "sha512-2Y89PpD9sE/8QaHhYxaI21WFxkVmjbxdphiOPdsC9t7A3kQHMYOTQPYFon3bkYM7tL8k9YVBimXSv20JGglqUA==",
+    "shasum": "380ae13cceee29e5be166df7acca9f1daa19fd7e",
+    "tarball": "https://registry.npmjs.org/metro-core/-/metro-core-0.30.2.tgz",
+    "unpackedSize": 23664
+  },
+  "homepage": "https://github.com/facebook/metro#readme",
+  "main": "src/index.js",
+  "maintainers": [
+    {
+      "name": "cpojer",
+      "email": "christoph.pojer@gmail.com"
+    },
+    {
+      "name": "fb",
+      "email": "opensource+npm@fb.com"
+    },
+    {
+      "name": "kuvos",
+      "email": "npm-public@qfox.nl"
+    },
+    {
+      "name": "rafeca",
+      "email": "rafeca@gmail.com"
+    }
+  ],
+  "name": "metro-core",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/facebook/metro.git"
+  },
+  "scripts": {
+    "cleanup-release": "test ! -e build && mv src build && mv src.real src",
+    "prepare-release": "test -d build && rm -rf src.real && mv src src.real && mv build src"
+  },
+  "version": "0.30.2"
+}

node_modules/metro-core/src/Logger/Logger.js

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';var _extends = Object.assign || function (target) {for (var i = 1; i < arguments.length; i++) {var source = arguments[i];for (var key in source) {if (Object.prototype.hasOwnProperty.call(source, key)) {target[key] = source[key];}}}return target;};
+
+const os = require('os');var _require =
+
+require('events');const EventEmitter = _require.EventEmitter;
+
+const VERSION = require('../../package.json').version;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const log_session = `${os.hostname()}-${Date.now()}`;
+const eventEmitter = new EventEmitter();
+
+function on(event, handler) {
+  eventEmitter.on(event, handler);
+}
+
+function createEntry(data) {
+  const logEntry = typeof data === 'string' ? { log_entry_label: data } : data;
+
+  return _extends({},
+  logEntry, {
+    log_session,
+    metro_bundler_version: VERSION });
+
+}
+
+function createActionStartEntry(data) {
+  const logEntry = typeof data === 'string' ? { action_name: data } : data;const
+  action_name = logEntry.action_name;
+
+  return createEntry(_extends({},
+  logEntry, {
+    action_name,
+    action_phase: 'start',
+    log_entry_label: action_name,
+    start_timestamp: process.hrtime() }));
+
+}
+
+function createActionEndEntry(logEntry) {const
+  action_name = logEntry.action_name,action_phase = logEntry.action_phase,start_timestamp = logEntry.start_timestamp;
+
+  if (action_phase !== 'start' || !Array.isArray(start_timestamp)) {
+    throw new Error('Action has not started or has already ended');
+  }
+
+  const timeDelta = process.hrtime(start_timestamp);
+  const duration_ms = Math.round((timeDelta[0] * 1e9 + timeDelta[1]) / 1e6);
+
+  return createEntry(_extends({},
+  logEntry, {
+    action_name,
+    action_phase: 'end',
+    duration_ms,
+    log_entry_label: action_name }));
+
+}
+
+function log(logEntry) {
+  eventEmitter.emit('log', logEntry);
+  return logEntry;
+}
+
+module.exports = {
+  on,
+  createEntry,
+  createActionStartEntry,
+  createActionEndEntry,
+  log };

node_modules/metro-core/src/Logger/Logger.js.flow

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const os = require('os');
+
+const {EventEmitter} = require('events');
+
+const VERSION = require('../../package.json').version;
+
+type ActionLogEntryData = {
+  action_name: string,
+};
+
+type ActionStartLogEntry = {
+  action_name?: string,
+  action_phase?: string,
+  log_entry_label: string,
+  log_session?: string,
+  start_timestamp?: [number, number],
+};
+
+export type LogEntry = {
+  action_name?: string,
+  action_phase?: string,
+  duration_ms?: number,
+  log_entry_label: string,
+  log_session?: string,
+  start_timestamp?: [number, number],
+};
+
+const log_session = `${os.hostname()}-${Date.now()}`;
+const eventEmitter = new EventEmitter();
+
+function on(event: string, handler: (logEntry: LogEntry) => void): void {
+  eventEmitter.on(event, handler);
+}
+
+function createEntry(data: LogEntry | string): LogEntry {
+  const logEntry = typeof data === 'string' ? {log_entry_label: data} : data;
+
+  return {
+    ...logEntry,
+    log_session,
+    metro_bundler_version: VERSION,
+  };
+}
+
+function createActionStartEntry(data: ActionLogEntryData | string): LogEntry {
+  const logEntry = typeof data === 'string' ? {action_name: data} : data;
+  const {action_name} = logEntry;
+
+  return createEntry({
+    ...logEntry,
+    action_name,
+    action_phase: 'start',
+    log_entry_label: action_name,
+    start_timestamp: process.hrtime(),
+  });
+}
+
+function createActionEndEntry(logEntry: ActionStartLogEntry): LogEntry {
+  const {action_name, action_phase, start_timestamp} = logEntry;
+
+  if (action_phase !== 'start' || !Array.isArray(start_timestamp)) {
+    throw new Error('Action has not started or has already ended');
+  }
+
+  const timeDelta = process.hrtime(start_timestamp);
+  const duration_ms = Math.round((timeDelta[0] * 1e9 + timeDelta[1]) / 1e6);
+
+  return createEntry({
+    ...logEntry,
+    action_name,
+    action_phase: 'end',
+    duration_ms,
+    log_entry_label: action_name,
+  });
+}
+
+function log(logEntry: LogEntry): LogEntry {
+  eventEmitter.emit('log', logEntry);
+  return logEntry;
+}
+
+module.exports = {
+  on,
+  createEntry,
+  createActionStartEntry,
+  createActionEndEntry,
+  log,
+};

node_modules/metro-core/src/Logger/index.js

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+const Logger = require('./Logger');
+
+
+
+module.exports = Logger;

node_modules/metro-core/src/Logger/index.js.flow

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const Logger = require('./Logger');
+
+export type {LogEntry} from './Logger';
+
+module.exports = Logger;

node_modules/metro-core/src/Terminal/Terminal.js

@@ -0,0 +1,179 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+const readline = require('readline');
+const throttle = require('lodash.throttle');
+const tty = require('tty');
+const util = require('util');
+
+
+
+/**
+                               * Clear some text that was previously printed on an interactive stream,
+                               * without trailing newline character (so we have to move back to the
+                               * beginning of the line).
+                               */
+function clearStringBackwards(stream, str) {
+  readline.moveCursor(stream, -stream.columns, 0);
+  readline.clearLine(stream, 0);
+  let lineCount = (str.match(/\n/g) || []).length;
+  while (lineCount > 0) {
+    readline.moveCursor(stream, 0, -1);
+    readline.clearLine(stream, 0);
+    --lineCount;
+  }
+}
+
+/**
+   * Cut a string into an array of string of the specific maximum size. A newline
+   * ends a chunk immediately (it's not included in the "." RexExp operator), and
+   * is not included in the result.
+   * When counting we should ignore non-printable characters. In particular the
+   * ANSI escape sequences (regex: /\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?m/)
+   * (Not an exhaustive match, intended to match ANSI color escapes)
+   * https://en.wikipedia.org/wiki/ANSI_escape_code
+   */
+function chunkString(str, size) {
+  const ANSI_COLOR = '\x1B\\[([0-9]{1,2}(;[0-9]{1,2})?)?m';
+  const SKIP_ANSI = `(?:${ANSI_COLOR})*`;
+  return str.match(new RegExp(`(?:${SKIP_ANSI}.){1,${size}}`, 'g')) || [];
+}
+
+/**
+   * Get the stream as a TTY if it effectively looks like a valid TTY.
+   */
+function getTTYStream(stream) {
+  if (
+  stream instanceof tty.WriteStream &&
+  stream.isTTY &&
+  stream.columns >= 1)
+  {
+    return stream;
+  }
+  return null;
+}
+
+/**
+   * We don't just print things to the console, sometimes we also want to show
+   * and update progress. This utility just ensures the output stays neat: no
+   * missing newlines, no mangled log lines.
+   *
+   *     const terminal = Terminal.default;
+   *     terminal.status('Updating... 38%');
+   *     terminal.log('warning: Something happened.');
+   *     terminal.status('Updating, done.');
+   *     terminal.persistStatus();
+   *
+   * The final output:
+   *
+   *     warning: Something happened.
+   *     Updating, done.
+   *
+   * Without the status feature, we may get a mangled output:
+   *
+   *     Updating... 38%warning: Something happened.
+   *     Updating, done.
+   *
+   * This is meant to be user-readable and TTY-oriented. We use stdout by default
+   * because it's more about status information than diagnostics/errors (stderr).
+   *
+   * Do not add any higher-level functionality in this class such as "warning" and
+   * "error" printers, as it is not meant for formatting/reporting. It has the
+   * single responsibility of handling status messages.
+   */
+class Terminal {
+
+
+
+
+
+
+  constructor(stream) {
+    this._logLines = [];
+    this._nextStatusStr = '';
+    this._scheduleUpdate = throttle(this._update, 33);
+    this._statusStr = '';
+    this._stream = stream;
+  }
+
+  /**
+     * Clear and write the new status, logging in bulk in-between. Doing this in a
+     * throttled way (in a different tick than the calls to `log()` and
+     * `status()`) prevents us from repeatedly rewriting the status in case
+     * `terminal.log()` is called several times.
+     */
+  _update() {const
+    _statusStr = this._statusStr,_stream = this._stream;
+    const ttyStream = getTTYStream(_stream);
+    if (_statusStr === this._nextStatusStr && this._logLines.length === 0) {
+      return;
+    }
+    if (ttyStream != null) {
+      clearStringBackwards(ttyStream, _statusStr);
+    }
+    this._logLines.forEach(line => {
+      _stream.write(line);
+      _stream.write('\n');
+    });
+    this._logLines = [];
+    if (ttyStream != null) {
+      this._nextStatusStr = chunkString(
+      this._nextStatusStr,
+      ttyStream.columns).
+      join('\n');
+      _stream.write(this._nextStatusStr);
+    }
+    this._statusStr = this._nextStatusStr;
+  }
+
+  /**
+     * Shows some text that is meant to be overriden later. Return the previous
+     * status that was shown and is no more. Calling `status()` with no argument
+     * removes the status altogether. The status is never shown in a
+     * non-interactive terminal: for example, if the output is redirected to a
+     * file, then we don't care too much about having a progress bar.
+     */
+  status(format) {const
+    _nextStatusStr = this._nextStatusStr;for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {args[_key - 1] = arguments[_key];}
+    this._nextStatusStr = util.format.apply(util, [format].concat(args));
+    this._scheduleUpdate();
+    return _nextStatusStr;
+  }
+
+  /**
+     * Similar to `console.log`, except it moves the status/progress text out of
+     * the way correctly. In non-interactive terminals this is the same as
+     * `console.log`.
+     */
+  log(format) {for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {args[_key2 - 1] = arguments[_key2];}
+    this._logLines.push(util.format.apply(util, [format].concat(args)));
+    this._scheduleUpdate();
+  }
+
+  /**
+     * Log the current status and start from scratch. This is useful if the last
+     * status was the last one of a series of updates.
+     */
+  persistStatus() {
+    this.log(this._nextStatusStr);
+    this._nextStatusStr = '';
+  }
+
+  flush() {
+    // Useful if you're going to start calling console.log/console.error directly
+    // again; otherwise you could end up with mangled output when the queued
+    // update starts writing to stream after a delay.
+    this._scheduleUpdate.flush();
+  }}
+
+
+module.exports = Terminal;

node_modules/metro-core/src/Terminal/Terminal.js.flow

@@ -0,0 +1,179 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const readline = require('readline');
+const throttle = require('lodash.throttle');
+const tty = require('tty');
+const util = require('util');
+
+type UnderlyingStream = net$Socket | stream$Writable;
+
+/**
+ * Clear some text that was previously printed on an interactive stream,
+ * without trailing newline character (so we have to move back to the
+ * beginning of the line).
+ */
+function clearStringBackwards(stream: tty.WriteStream, str: string): void {
+  readline.moveCursor(stream, -stream.columns, 0);
+  readline.clearLine(stream, 0);
+  let lineCount = (str.match(/\n/g) || []).length;
+  while (lineCount > 0) {
+    readline.moveCursor(stream, 0, -1);
+    readline.clearLine(stream, 0);
+    --lineCount;
+  }
+}
+
+/**
+ * Cut a string into an array of string of the specific maximum size. A newline
+ * ends a chunk immediately (it's not included in the "." RexExp operator), and
+ * is not included in the result.
+ * When counting we should ignore non-printable characters. In particular the
+ * ANSI escape sequences (regex: /\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?m/)
+ * (Not an exhaustive match, intended to match ANSI color escapes)
+ * https://en.wikipedia.org/wiki/ANSI_escape_code
+ */
+function chunkString(str: string, size: number): Array<string> {
+  const ANSI_COLOR = '\x1B\\[([0-9]{1,2}(;[0-9]{1,2})?)?m';
+  const SKIP_ANSI = `(?:${ANSI_COLOR})*`;
+  return str.match(new RegExp(`(?:${SKIP_ANSI}.){1,${size}}`, 'g')) || [];
+}
+
+/**
+ * Get the stream as a TTY if it effectively looks like a valid TTY.
+ */
+function getTTYStream(stream: UnderlyingStream): ?tty.WriteStream {
+  if (
+    stream instanceof tty.WriteStream &&
+    stream.isTTY &&
+    stream.columns >= 1
+  ) {
+    return stream;
+  }
+  return null;
+}
+
+/**
+ * We don't just print things to the console, sometimes we also want to show
+ * and update progress. This utility just ensures the output stays neat: no
+ * missing newlines, no mangled log lines.
+ *
+ *     const terminal = Terminal.default;
+ *     terminal.status('Updating... 38%');
+ *     terminal.log('warning: Something happened.');
+ *     terminal.status('Updating, done.');
+ *     terminal.persistStatus();
+ *
+ * The final output:
+ *
+ *     warning: Something happened.
+ *     Updating, done.
+ *
+ * Without the status feature, we may get a mangled output:
+ *
+ *     Updating... 38%warning: Something happened.
+ *     Updating, done.
+ *
+ * This is meant to be user-readable and TTY-oriented. We use stdout by default
+ * because it's more about status information than diagnostics/errors (stderr).
+ *
+ * Do not add any higher-level functionality in this class such as "warning" and
+ * "error" printers, as it is not meant for formatting/reporting. It has the
+ * single responsibility of handling status messages.
+ */
+class Terminal {
+  _logLines: Array<string>;
+  _nextStatusStr: string;
+  _scheduleUpdate: () => void;
+  _statusStr: string;
+  _stream: UnderlyingStream;
+
+  constructor(stream: UnderlyingStream) {
+    this._logLines = [];
+    this._nextStatusStr = '';
+    this._scheduleUpdate = throttle(this._update, 33);
+    this._statusStr = '';
+    this._stream = stream;
+  }
+
+  /**
+   * Clear and write the new status, logging in bulk in-between. Doing this in a
+   * throttled way (in a different tick than the calls to `log()` and
+   * `status()`) prevents us from repeatedly rewriting the status in case
+   * `terminal.log()` is called several times.
+   */
+  _update(): void {
+    const {_statusStr, _stream} = this;
+    const ttyStream = getTTYStream(_stream);
+    if (_statusStr === this._nextStatusStr && this._logLines.length === 0) {
+      return;
+    }
+    if (ttyStream != null) {
+      clearStringBackwards(ttyStream, _statusStr);
+    }
+    this._logLines.forEach(line => {
+      _stream.write(line);
+      _stream.write('\n');
+    });
+    this._logLines = [];
+    if (ttyStream != null) {
+      this._nextStatusStr = chunkString(
+        this._nextStatusStr,
+        ttyStream.columns,
+      ).join('\n');
+      _stream.write(this._nextStatusStr);
+    }
+    this._statusStr = this._nextStatusStr;
+  }
+
+  /**
+   * Shows some text that is meant to be overriden later. Return the previous
+   * status that was shown and is no more. Calling `status()` with no argument
+   * removes the status altogether. The status is never shown in a
+   * non-interactive terminal: for example, if the output is redirected to a
+   * file, then we don't care too much about having a progress bar.
+   */
+  status(format: string, ...args: Array<mixed>): string {
+    const {_nextStatusStr} = this;
+    this._nextStatusStr = util.format(format, ...args);
+    this._scheduleUpdate();
+    return _nextStatusStr;
+  }
+
+  /**
+   * Similar to `console.log`, except it moves the status/progress text out of
+   * the way correctly. In non-interactive terminals this is the same as
+   * `console.log`.
+   */
+  log(format: string, ...args: Array<mixed>): void {
+    this._logLines.push(util.format(format, ...args));
+    this._scheduleUpdate();
+  }
+
+  /**
+   * Log the current status and start from scratch. This is useful if the last
+   * status was the last one of a series of updates.
+   */
+  persistStatus(): void {
+    this.log(this._nextStatusStr);
+    this._nextStatusStr = '';
+  }
+
+  flush(): void {
+    // Useful if you're going to start calling console.log/console.error directly
+    // again; otherwise you could end up with mangled output when the queued
+    // update starts writing to stream after a delay.
+    this._scheduleUpdate.flush();
+  }
+}
+
+module.exports = Terminal;

node_modules/metro-core/src/Terminal/index.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+const Terminal = require('./Terminal');
+
+module.exports = Terminal;

node_modules/metro-core/src/Terminal/index.js.flow

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const Terminal = require('./Terminal');
+
+module.exports = Terminal;

node_modules/metro-core/src/formatBanner/formatBanner.js

@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * $FlowFixMe
+ * Note: This file runs BEFORE transforms so DO NOT ADD ES6 or Flow in code!
+ * @PrettierFixMe
+ * Note: Cannot safely use Prettier because of trailing call arg comma rule!
+ */
+
+'use strict';
+
+var wordwrap = require('wordwrap');
+
+var HORIZONTAL_LINE = '\u2500';
+var VERTICAL_LINE = '\u2502';
+var TOP_LEFT = '\u250c';
+var TOP_RIGHT = '\u2510';
+var BOTTOM_LEFT = '\u2514';
+var BOTTOM_RIGHT = '\u2518';
+
+/**
+                              * Prints a banner with a border around it containing the given message. The
+                              * following options are supported:
+                              *
+                              * type Options = {
+                              *   // A function to apply to each line of text to decorate it
+                              *   chalkFunction: (string: message) => string;
+                              *   // The total width (max line length) of the banner, including margin and
+                              *   // padding (default = 80)
+                              *   width: number;
+                              *   // How much leading space to prepend to each line (default = 0)
+                              *   marginLeft: number;
+                              *   // How much trailing space to append to each line (default = 0)
+                              *   marginRight: number;
+                              *   // Space between the top banner border and the text (default = 0)
+                              *   paddingTop: number;
+                              *   // Space between the bottom banner border and the text (default = 0)
+                              *   paddingBottom: number;
+                              *   // Space between the left banner border and the text (default = 2)
+                              *   paddingLeft: number;
+                              *   // Space between the right banner border and the text (default = 2)
+                              *   paddingRight: number;
+                              * };
+                              *
+                              * @PrettierFixMe can't use comment-style flow syntax because prettier strips it
+                              *                https://github.com/prettier/prettier/issues/204
+                              */
+function formatBanner(message, options) {
+  options = options || {};
+
+  var width = options.width === undefined ? 80 : options.width;
+  var marginLeft = options.marginLeft === undefined ? 0 : options.marginLeft;
+  var marginRight = options.marginRight === undefined ? 0 : options.marginRight;
+  var paddingTop = options.paddingTop === undefined ? 0 : options.paddingTop;
+  var paddingBottom = options.paddingBottom === undefined ? 0 : options.paddingBottom;
+  var paddingLeft = options.paddingLeft === undefined ? 2 : options.paddingLeft;
+  var paddingRight = options.paddingRight === undefined ? 2 : options.paddingRight;
+
+  var horizSpacing = marginLeft + paddingLeft + paddingRight + marginRight;
+  // 2 for the banner borders
+  var maxLineWidth = width - horizSpacing - 2;
+  var wrap = wordwrap(maxLineWidth);
+  var body = wrap(message);
+
+  var left = spaces(marginLeft) + VERTICAL_LINE + spaces(paddingLeft);
+  var right = spaces(paddingRight) + VERTICAL_LINE + spaces(marginRight);
+  var bodyLines = [].concat(
+  arrayOf('', paddingTop),
+  body.split('\n'),
+  arrayOf('', paddingBottom)).
+  map(function (line) {
+    var padding = spaces(Math.max(0, maxLineWidth - line.length));
+    return left + (options.chalkFunction ? options.chalkFunction(line) : line) + padding + right;
+  });
+
+  var horizontalBorderLine = repeatString(
+  HORIZONTAL_LINE,
+  width - marginLeft - marginRight - 2);
+
+  var top =
+  spaces(marginLeft) +
+  TOP_LEFT +
+  horizontalBorderLine +
+  TOP_RIGHT +
+  spaces(marginRight);
+  var bottom =
+  spaces(marginLeft) +
+  BOTTOM_LEFT +
+  horizontalBorderLine +
+  BOTTOM_RIGHT +
+  spaces(marginRight);
+  return [].concat(top, bodyLines, bottom).join('\n');
+}
+
+function spaces(number) {
+  return repeatString(' ', number);
+}
+
+function repeatString(string, number) {
+  return new Array(number + 1).join(string);
+}
+
+function arrayOf(value, number) {
+  return Array.apply(null, Array(number)).map(function () {
+    return value;
+  });
+}
+
+module.exports = formatBanner;

node_modules/metro-core/src/formatBanner/index.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+const formatBanner = require('./formatBanner');
+
+module.exports = formatBanner;

node_modules/metro-core/src/formatBanner/index.js.flow

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const formatBanner = require('./formatBanner');
+
+module.exports = formatBanner;

node_modules/metro-core/src/index.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+const Logger = require('./Logger');
+const Terminal = require('./Terminal');
+
+const formatBanner = require('./formatBanner');
+
+module.exports = {
+  Logger,
+  Terminal,
+  formatBanner };

node_modules/metro-core/src/index.js.flow

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const Logger = require('./Logger');
+const Terminal = require('./Terminal');
+
+const formatBanner = require('./formatBanner');
+
+module.exports = {
+  Logger,
+  Terminal,
+  formatBanner,
+};