Precompiling for es5 compatiblity

Gruntfile.js

@@ -49,6 +49,20 @@ module.exports = function (grunt) {
         }]
       }
     },
+    babel: {
+      options: {
+        sourceMap: false
+      },
+      dist: {
+        files: [{
+          expand: true,
+          cwd: 'src/',
+          src: ['**/*.js','*.js'],
+          dest: 'dist/',
+          ext: '.js'
+        }]
+      }
+    },
     browserify: {
       dist: {
         options: {
@@ -129,7 +143,7 @@ module.exports = function (grunt) {
         }
       }
     },
-    clean: ["public/", "./package.noDevDeps.json"]
+    clean: ["public/", "./package.noDevDeps.json", "dist/"]
   });
 
   var lastNodeEnv;
@@ -166,5 +180,5 @@ module.exports = function (grunt) {
   grunt.registerTask('default', 'build');
   grunt.registerTask('auto-build-scripts', ['browserify:dev']);
   grunt.registerTask('auto-build-styles', ['sass:dev', 'watch:sass']);
-  grunt.registerTask('production', ['env-force-production', 'clean', 'build', 'uglify:dist', 'env-restore']);
+  grunt.registerTask('production', ['env-force-production', 'clean', 'build', 'uglify:dist', 'babel', 'env-restore']);
 };

asr/viewer/stores/EntryStore.js

@@ -1,7 +1,7 @@
 import Influx from 'react-influx'
 import keyMirror from 'keymirror'
 import Dispatcher from '../dispatchers/Dispatcher'
-import * as JSON2 from '../../../libs/JSON2'
+import * as JSON2 from '../../../src/libs/JSON2'
 
 const Events = keyMirror({
   DATABASE_READY: null,

deps.json

@@ -49,6 +49,16 @@
     "link": "https://github.com/babel/babel/tree/master/packages/babel-register",
     "comment": "6.4.3"
   },
+  {
+    "department": "kessler",
+    "relatedTo": "stuff",
+    "name": "babel-runtime",
+    "licensePeriod": "perpetual",
+    "material": "material",
+    "licenseType": "MIT",
+    "link": "https://github.com/babel/babel/tree/master/packages/babel-runtime",
+    "comment": "6.3.19"
+  },
   {
     "department": "kessler",
     "relatedTo": "stuff",
@@ -98,6 +108,16 @@
     "link": "git+https://github.com/chalk/chalk.git",
     "comment": "1.1.1"
   },
+  {
+    "department": "kessler",
+    "relatedTo": "stuff",
+    "name": "cssify",
+    "licensePeriod": "perpetual",
+    "material": "material",
+    "licenseType": "BSD",
+    "link": "git+https://github.com/davidguttman/cssify.git",
+    "comment": "1.0.2"
+  },
   {
     "department": "kessler",
     "relatedTo": "stuff",
@@ -105,8 +125,8 @@
     "licensePeriod": "perpetual",
     "material": "material",
     "licenseType": "MIT",
-    "link": "https://github.com/strongloop/express",
-    "comment": "4.13.3"
+    "link": "https://github.com/expressjs/express",
+    "comment": "4.13.4"
   },
   {
     "department": "kessler",
@@ -148,6 +168,16 @@
     "link": "git://github.com/jadejs/jade.git",
     "comment": "1.11.0"
   },
+  {
+    "department": "kessler",
+    "relatedTo": "stuff",
+    "name": "json-fn",
+    "licensePeriod": "perpetual",
+    "material": "material",
+    "licenseType": "MIT",
+    "link": "git://github.com/vkiryukhin/jsonfn.git",
+    "comment": "0.60.0"
+  },
   {
     "department": "kessler",
     "relatedTo": "stuff",
@@ -166,7 +196,7 @@
     "material": "material",
     "licenseType": "LGPLv3",
     "link": "git+https://github.com/mWater/minimongo.git",
-    "comment": "3.6.0"
+    "comment": "3.6.1"
   },
   {
     "department": "kessler",
@@ -196,7 +226,17 @@
     "material": "material",
     "licenseType": "Artistic-2.0",
     "link": "git+https://github.com/npm/npm.git",
-    "comment": "3.5.4"
+    "comment": "3.6.0"
+  },
+  {
+    "department": "kessler",
+    "relatedTo": "stuff",
+    "name": "nw-builder",
+    "licensePeriod": "perpetual",
+    "material": "material",
+    "licenseType": "MIT",
+    "link": "git://github.com/mllrsohn/nw-builder.git",
+    "comment": "2.2.0"
   },
   {
     "department": "kessler",
@@ -208,6 +248,16 @@
     "link": "https://github.com/jshttp/on-finished",
     "comment": "2.3.0"
   },
+  {
+    "department": "kessler",
+    "relatedTo": "stuff",
+    "name": "rc",
+    "licensePeriod": "perpetual",
+    "material": "material",
+    "licenseType": "(BSD-2-Clause OR MIT OR Apache-2.0)",
+    "link": "git+https://github.com/dominictarr/rc.git",
+    "comment": "1.1.6"
+  },
   {
     "department": "kessler",
     "relatedTo": "stuff",
@@ -326,7 +376,7 @@
     "material": "material",
     "licenseType": "MIT",
     "link": "git://github.com/visionmedia/superagent.git",
-    "comment": "1.7.0"
+    "comment": "1.7.1"
   },
   {
     "department": "kessler",

dist/libs/JSON2.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parse = parse;
+exports.stringify = stringify;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function parse(str, reviver) {
+  return JSON.parse(str, function (k, v) {
+    var rv = undefined;
+    if (typeof v === 'string') {
+      if (/^Promise \{(.*?)}$/g.test(v)) {
+        return new _promise2.default(function (r, e) {
+          return 0;
+        });
+      } else if (/^function ([a-zA-Z0-9_\$]*?)\((.*?)\)\s?\{(.*?)}$/g.test(rv = v.replace(/\n/g, ''))) {
+        try {
+          var x = undefined;
+          eval('x = ' + v);
+          if (x) {
+            return x;
+          }
+        } catch (e) {
+          // ignore
+        }
+      }
+
+      try {
+        if ((rv = new RegExp(v)).toString() === v) {
+          return rv;
+        }
+      } catch (e) {
+        // ignore
+      }
+    }
+
+    return v;
+  });
+}
+
+function stringify(obj, replacer, spaces) {
+  return (0, _stringify2.default)(obj, function (k, v) {
+    if (typeof v !== 'undefined' && v !== null) {
+      if (typeof v.then === 'function') {
+        return 'Promise { <pending> }';
+      } else if (typeof v === 'function') {
+        return v.toString().replace(/\[native code]/gm, '[native]');
+      } else if (v instanceof RegExp) {
+        return v.toString();
+      }
+    }
+
+    return v;
+  }, spaces);
+}

dist/libs/MultiValueMap.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _map = require("babel-runtime/core-js/map");
+
+var _map2 = _interopRequireDefault(_map);
+
+var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require("babel-runtime/helpers/createClass");
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _class = function () {
+  function _class() {
+    (0, _classCallCheck3.default)(this, _class);
+
+    this._map = new _map2.default();
+  }
+
+  (0, _createClass3.default)(_class, [{
+    key: "get",
+    value: function get(key) {
+      if (!this._map.has(key)) {
+        this._map.set(key, []);
+      }
+
+      return this._map.get(key);
+    }
+  }, {
+    key: "has",
+    value: function has(key) {
+      return Array.isArray(this._map.get(key));
+    }
+  }, {
+    key: "set",
+    value: function set(key) {
+      var data = this.get(key);
+
+      for (var _len = arguments.length, values = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        values[_key - 1] = arguments[_key];
+      }
+
+      this._map.set(key, data.concat.apply(data, values));
+
+      return this;
+    }
+  }, {
+    key: "remove",
+    value: function remove(key) {
+      this._map.set(key, []);
+    }
+  }, {
+    key: "move",
+    value: function move(old, key) {
+      this._map.set(key, this._map.get(old));
+      this._map.remove(old);
+    }
+  }]);
+  return _class;
+}();
+
+exports.default = _class;

dist/libs/inspect.js

@@ -0,0 +1,493 @@
+'use strict';
+
+var _getOwnPropertyDescriptor = require('babel-runtime/core-js/object/get-own-property-descriptor');
+
+var _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor);
+
+var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+
+var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _getOwnPropertyNames = require('babel-runtime/core-js/object/get-own-property-names');
+
+var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _weakMap = require('babel-runtime/core-js/weak-map');
+
+var _weakMap2 = _interopRequireDefault(_weakMap);
+
+var _set = require('babel-runtime/core-js/set');
+
+var _set2 = _interopRequireDefault(_set);
+
+var _map = require('babel-runtime/core-js/map');
+
+var _map2 = _interopRequireDefault(_map);
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Module dependencies.
+ */
+
+var fe = require('format-error').format;
+var strip = require('strip-ansi');
+
+function formatError(ctx, value) {
+  return fe(value).split('\n').map(function (m) {
+    m = strip(m);
+    if (m.indexOf('Error: ') > -1) {
+      return ctx.stylize(m, 'error');
+    }
+    return ctx.stylize(m, 'stack');
+  }).join('\n');
+}
+
+/**
+ * Module exports.
+ */
+
+module.exports = inspect;
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ * @license MIT (© Joyent)
+ */
+/* legacy: obj, showHidden, depth, colors*/
+
+function inspect(obj, opts) {
+  // default options
+  var ctx = {
+    seen: [],
+    stylize: stylizeNoColor
+  };
+  // legacy...
+  if (arguments.length >= 3) ctx.depth = arguments[2];
+  if (arguments.length >= 4) ctx.colors = arguments[3];
+  if (isBoolean(opts)) {
+    // legacy...
+    ctx.showHidden = opts;
+  } else if (opts) {
+    // got an "options" object
+    _extend(ctx, opts);
+  }
+  // set default options
+  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+  if (isUndefined(ctx.depth)) ctx.depth = 2;
+  if (isUndefined(ctx.colors)) ctx.colors = false;
+  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+  'bold': [1, 22],
+  'italic': [3, 23],
+  'underline': [4, 24],
+  'inverse': [7, 27],
+  'white': [37, 39],
+  'grey': [90, 39],
+  'black': [30, 39],
+  'blue': [34, 39],
+  'cyan': [36, 39],
+  'green': [32, 39],
+  'magenta': [35, 39],
+  'red': [31, 39],
+  'yellow': [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+  'special': 'cyan',
+  'number': 'yellow',
+  'boolean': 'yellow',
+  'undefined': 'grey',
+  'null': 'bold',
+  'string': 'green',
+  'date': 'magenta',
+  'error': ['bold', 'red'],
+  'stack': 'red',
+  // 'name': 'cyan',
+  'regexp': 'red',
+  'promise': 'green',
+  'map': 'cyan',
+  'set': 'cyan',
+  'weakmap': 'cyan',
+  'weakset': 'cyan'
+};
+
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+
+  if (Array.isArray(style)) {
+    for (var i = 0; i < style.length; i++) {
+      str = '\u001b[' + inspect.colors[style[i]][0] + 'm' + str + '\u001b[' + inspect.colors[style[i]][1] + 'm';
+    }
+
+    return str;
+  } else if (style) {
+    return '\u001b[' + inspect.colors[style][0] + 'm' + str + '\u001b[' + inspect.colors[style][1] + 'm';
+  } else {
+    return str;
+  }
+}
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+
+function isNull(arg) {
+  return arg === null;
+}
+
+function hasOwn(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+
+function isObject(arg) {
+  return (typeof arg === 'undefined' ? 'undefined' : (0, _typeof3.default)(arg)) === 'object' && arg !== null;
+}
+
+function isError(e) {
+  return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+
+function isDate(d) {
+  return isObject(d) && objectToString(d) === '[object Date]';
+}
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+function isPromise(p) {
+  return p instanceof _promise2.default;
+}
+
+function isMap(m) {
+  return m instanceof _map2.default;
+}
+
+function isSet(m) {
+  return m instanceof _set2.default;
+}
+
+function isWeakMap(m) {
+  return m instanceof _weakMap2.default;
+}
+
+function isWeakSet(m) {
+  return m instanceof isWeakSet;
+}
+
+function arrayToHash(array) {
+  var hash = {};
+
+  array.forEach(function (val, idx) {
+    hash[val] = true;
+  });
+
+  return hash;
+}
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (hasOwn(value, String(i))) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
+    } else {
+      output.push('');
+    }
+  }
+  keys.forEach(function (key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
+    }
+  });
+  return output;
+}
+
+function formatValue(ctx, value, recurseTimes) {
+  // Provide a hook for user-specified inspect functions.
+  // Check that value is an object with an inspect function on it
+  if (ctx.customInspect && value && isFunction(value.inspect) &&
+  // Filter out the util module, it's inspect function is special
+  value.inspect !== inspect &&
+  // Also filter out any prototype objects using the circular check.
+  !(value.constructor && value.constructor.prototype === value)) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+
+  // Primitive types cannot have properties
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+
+  // Look up the keys of the object.
+  var keys = (0, _keys2.default)(value);
+  var visibleKeys = arrayToHash(keys);
+
+  try {
+    if (ctx.showHidden && _getOwnPropertyNames2.default) {
+      keys = (0, _getOwnPropertyNames2.default)(value);
+    }
+  } catch (e) {}
+  // ignore
+
+  // IE doesn't make error fields non-enumerable
+  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+  if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+    return formatError(ctx, value);
+  }
+
+  // Some type of object without properties can be shortcutted.
+  if (keys.length === 0) {
+    if (isPromise(value)) {
+      return ctx.stylize('[Promise]', 'promise');
+    }
+    if (isWeakSet(value)) {
+      return ctx.stylize('[WeakSet] ', 'weakset') + inspect(JSON.parse((0, _stringify2.default)([].concat((0, _toConsumableArray3.default)(value)))), ctx);
+    }
+    if (isWeakMap(value)) {
+      return ctx.stylize('[WeakMap] ', 'weakmap') + inspect(JSON.parse((0, _stringify2.default)([].concat((0, _toConsumableArray3.default)(value)))), ctx);
+    }
+    if (isMap(value)) {
+      return ctx.stylize('[Map] ', 'map') + inspect(JSON.parse((0, _stringify2.default)([].concat((0, _toConsumableArray3.default)(value)))), ctx);
+    }
+    if (isSet(value)) {
+      return ctx.stylize('[Set] ', 'set') + inspect(JSON.parse((0, _stringify2.default)([].concat((0, _toConsumableArray3.default)(value)))), ctx);
+    }
+    if (isFunction(value)) {
+      var name = value.name ? ': ' + value.name : '';
+      return ctx.stylize('[Function' + name + ']', 'special');
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toString.call(value), 'date');
+    }
+    if (isError(value)) {
+      return formatError(ctx, value);
+    }
+  }
+
+  var base = '',
+      array = false,
+      braces = ['{', '}'];
+
+  // Make Array say that they are Array
+  if (Array.isArray(value)) {
+    array = true;
+    braces = ['[', ']'];
+  }
+
+  // Make functions say that they are functions
+  if (isFunction(value)) {
+    var n = value.name ? ': ' + value.name : '';
+    base = ' [Function' + n + ']';
+  }
+
+  // Make RegExps say that they are RegExps
+  if (isRegExp(value)) {
+    base = ' ' + RegExp.prototype.toString.call(value);
+  }
+
+  // Make dates with properties first say the date
+  if (isDate(value)) {
+    base = ' ' + Date.prototype.toUTCString.call(value);
+  }
+
+  // Make error with message first say the error
+  if (isError(value)) {
+    base = ' ' + formatError(ctx, value);
+  }
+
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+    } else {
+      return ctx.stylize('[Object]', 'special');
+    }
+  }
+
+  ctx.seen.push(value);
+
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function (key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+
+  ctx.seen.pop();
+
+  return reduceToSingleString(output, base, braces);
+}
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  desc = { value: void 0 };
+  try {
+    // ie6 › navigator.toString
+    // throws Error: Object doesn't support this property or method
+    desc.value = value[key];
+  } catch (e) {
+    // ignore
+  }
+  try {
+    // ie10 › Object.getOwnPropertyDescriptor(window.location, 'hash')
+    // throws TypeError: Object doesn't support this action
+    if (_getOwnPropertyDescriptor2.default) {
+      desc = (0, _getOwnPropertyDescriptor2.default)(value, key) || desc;
+    }
+  } catch (e) {
+    // ignore
+  }
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize('[Getter/Setter]', 'special');
+    } else {
+      str = ctx.stylize('[Getter]', 'special');
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize('[Setter]', 'special');
+    }
+  }
+  if (!hasOwn(visibleKeys, key)) {
+    name = '[' + key + ']';
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, null);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf('\n') > -1) {
+        if (array) {
+          str = str.split('\n').map(function (line) {
+            return '  ' + line;
+          }).join('\n').substr(2);
+        } else {
+          str = '\n' + str.split('\n').map(function (line) {
+            return '   ' + line;
+          }).join('\n');
+        }
+      }
+    } else {
+      str = ctx.stylize('[Circular]', 'special');
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = (0, _stringify2.default)('' + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, 'name');
+    } else {
+      name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, 'string');
+    }
+  }
+
+  return name + ': ' + str;
+}
+
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');
+  if (isString(value)) {
+    var simple = '\'' + (0, _stringify2.default)(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + '\'';
+    return ctx.stylize(simple, 'string');
+  }
+  if (isNumber(value)) return ctx.stylize('' + value, 'number');
+  if (isBoolean(value)) return ctx.stylize('' + value, 'boolean');
+  // For some reason typeof null is "object", so special case here.
+  if (isNull(value)) return ctx.stylize('null', 'null');
+}
+
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function (prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf('\n') >= 0) numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+  }, 0);
+
+  if (length > 60) {
+    return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n  ') + ' ' + braces[1];
+  }
+
+  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+function _extend(origin, add) {
+  // Don't do anything if add isn't an object
+  if (!add || !isObject(add)) return origin;
+
+  var keys = (0, _keys2.default)(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin;
+}

dist/readers/BasicConsole.js

@@ -0,0 +1,190 @@
+'use strict';
+
+var _assign = require('babel-runtime/core-js/object/assign');
+
+var _assign2 = _interopRequireDefault(_assign);
+
+var _getIterator2 = require('babel-runtime/core-js/get-iterator');
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _map = require('babel-runtime/core-js/map');
+
+var _map2 = _interopRequireDefault(_map);
+
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
+
+var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
+
+var _inherits2 = require('babel-runtime/helpers/inherits');
+
+var _inherits3 = _interopRequireDefault(_inherits2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _Console2 = require('./Console');
+
+var _Console3 = _interopRequireDefault(_Console2);
+
+var _callsite = require('callsite');
+
+var _callsite2 = _interopRequireDefault(_callsite);
+
+var _onFinished = require('on-finished');
+
+var _onFinished2 = _interopRequireDefault(_onFinished);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _time() {
+  if (typeof process !== 'undefined' && typeof process.hrtime === 'function') {
+    var duration = process.hrtime();
+    return duration[0] * 1000 + duration[1] / 1e6;
+  }
+
+  return Date.now();
+}
+
+var _class = function (_Console) {
+  (0, _inherits3.default)(_class, _Console);
+
+  function _class(app, id) {
+    (0, _classCallCheck3.default)(this, _class);
+
+    var _this = (0, _possibleConstructorReturn3.default)(this, (0, _getPrototypeOf2.default)(_class).call(this, app, id));
+
+    _this._times = new _map2.default();
+
+    // open loggers
+
+    _this.expose('trace');
+    _this.expose('log');
+    _this.expose('warn');
+    _this.expose('error');
+    _this.expose('info');
+    _this.expose('timing');
+    return _this;
+  }
+
+  (0, _createClass3.default)(_class, [{
+    key: 'date',
+    value: function date() {
+      this.transient('date', new Date());
+    }
+  }, {
+    key: 'time',
+    value: function time(label) {
+      this._times.set(label, _time());
+
+      return this;
+    }
+  }, {
+    key: 'middleware',
+    value: function middleware() {
+      var _this2 = this;
+
+      var expose = arguments.length <= 0 || arguments[0] === undefined ? 'express' : arguments[0];
+      var ignore = arguments.length <= 1 || arguments[1] === undefined ? [/(scribe)/g] : arguments[1];
+
+      this.expose(expose);
+
+      ignore = Array.isArray(ignore) ? ignore : [ignore];
+
+      return function (req, res, next) {
+        var start = _time();
+        (0, _onFinished2.default)(res, function () {
+          var originalUrl = req.originalUrl;
+          var _iteratorNormalCompletion = true;
+          var _didIteratorError = false;
+          var _iteratorError = undefined;
+
+          try {
+            for (var _iterator = (0, _getIterator3.default)(ignore), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              var k = _step.value;
+
+              if (new RegExp(k).test(originalUrl)) return;
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+
+          _this2[expose]({ req: req, res: res, duration: _time() - start });
+        });
+        next();
+      };
+    }
+  }, {
+    key: 'tag',
+    value: function tag() {
+      for (var _len = arguments.length, tags = Array(_len), _key = 0; _key < _len; _key++) {
+        tags[_key] = arguments[_key];
+      }
+
+      this.transient('tags', tags);
+
+      return this;
+    }
+  }, {
+    key: 'metric',
+    value: function metric() {
+      var map = {};
+      for (var i = 1; i < arguments.length; i += 2) {
+        map[arguments.length <= i - 1 + 0 ? undefined : arguments[i - 1 + 0]] = arguments.length <= i + 0 ? undefined : arguments[i + 0];
+      }
+
+      this.transient('metrics', (0, _assign2.default)(this.transient('metrics') || {}, map));
+
+      return this;
+    }
+  }, {
+    key: 'trace',
+    value: function trace(text) {
+      this.transient('callsite', this.callSite(4));
+      return this.out('trace', new Error(text));
+    }
+  }, {
+    key: 'timeEnd',
+    value: function timeEnd(label) {
+      var start = this._times.get(label);
+      if (!start) {
+        throw new Error('No such label: ' + label);
+      }
+
+      this._times.delete(label);
+
+      this.transient('callsite', this.callSite(5));
+
+      var duration = _time() - start;
+
+      return this.metric(label, duration).timing('');
+    }
+  }]);
+  return _class;
+}(_Console3.default);
+
+exports.default = _class;

dist/readers/Console.js

@@ -0,0 +1,223 @@
+'use strict';
+
+var _assign = require('babel-runtime/core-js/object/assign');
+
+var _assign2 = _interopRequireDefault(_assign);
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _callsite = require('callsite');
+
+var _callsite2 = _interopRequireDefault(_callsite);
+
+var _async = require('async');
+
+var _async2 = _interopRequireDefault(_async);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _class = function () {
+  function _class() {
+    var app = arguments.length <= 0 || arguments[0] === undefined ? 'Scribe' : arguments[0];
+    var id = arguments.length <= 1 || arguments[1] === undefined ? process.pid : arguments[1];
+    (0, _classCallCheck3.default)(this, _class);
+
+    this._transient = {};
+    this._persistent = {};
+    this._pipelines = {};
+    this._exposed = {};
+
+    this.persistent('app', app);
+    this.persistent('id', id);
+  }
+
+  (0, _createClass3.default)(_class, [{
+    key: 'transient',
+    value: function transient(key, value) {
+      if (arguments.length === 1) {
+        return this._transient[key];
+      }
+
+      this._transient[key] = value;
+      return this;
+    }
+  }, {
+    key: 'persistent',
+    value: function persistent(key, value) {
+      if (arguments.length === 1) {
+        return this._persistent[key];
+      }
+
+      this._persistent[key] = value;
+      return this;
+    }
+  }, {
+    key: 'exposed',
+    value: function exposed() {
+      return (0, _keys2.default)(this._exposed);
+    }
+  }, {
+    key: 'callSite',
+    value: function callSite() {
+      var idx = arguments.length <= 0 || arguments[0] === undefined ? 5 : arguments[0];
+
+      try {
+        var site = (0, _callsite2.default)()[idx];
+
+        return {
+          line: site.getLineNumber(),
+          file: site.getFileName(),
+          func: site.getFunctionName()
+        };
+
+        return site;
+      } catch (e) {
+        console.error(e);
+        return {};
+      }
+    }
+  }, {
+    key: 'preout',
+    value: function preout() {
+      // ignore
+    }
+  }, {
+    key: 'out',
+    value: function out(expose) {
+      var _this = this;
+
+      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      return new _promise2.default(function (resolve, reject) {
+        if (!_this._pipelines[expose]) {
+          return resolve();
+        }
+
+        _this.preout();
+
+        var pipelines = _this._pipelines[expose];
+        var transient = _this._transient;
+        var persistent = _this._persistent;
+        var errs = [];
+        var now = new Date();
+
+        if (!transient.date) {
+          transient.date = now;
+        }
+
+        if (!transient.callsite) {
+          transient.callsite = _this.callSite();
+        }
+
+        // reset before async
+        _this.reset();
+
+        _async2.default.forEachOfSeries(pipelines, function (pipeline, name, callback) {
+          var input = {
+            expose: expose, args: args, persistent: persistent, date: now,
+            transient: (0, _assign2.default)({}, transient)
+          };
+
+          _async2.default.eachSeries(pipeline, function (through, callback) {
+            if (!through) {
+              return callback();
+            }
+
+            through.through(input, function (err, output) {
+              if (err) errs.push(err);
+              input = output || input;
+              callback(err);
+            });
+          }, function () {
+            return callback();
+          });
+        }, function () {
+          if (errs.length) {
+            return reject(errs);
+          }
+
+          resolve();
+        });
+      });
+    }
+  }, {
+    key: 'expose',
+    value: function expose(_expose) {
+      if (typeof this[_expose] !== 'function') {
+        this[_expose] = this.out.bind(this, _expose);
+      }
+
+      this._exposed[_expose] = true;
+
+      return this;
+    }
+  }, {
+    key: 'pipe',
+    value: function pipe(expose, name) {
+      this.expose(expose);
+
+      for (var _len2 = arguments.length, throughs = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        throughs[_key2 - 2] = arguments[_key2];
+      }
+
+      if (throughs.length) {
+        var t = this._pipelines[expose] || {};
+        if (t[name]) {
+          throw new Error('Pipeline ' + name + ' for ' + expose + ' is already taken');
+        }
+
+        t[name] = throughs;
+        this._pipelines[expose] = t;
+      } else {
+        return this._pipelines[expose][name];
+      }
+
+      return this;
+    }
+  }, {
+    key: 'reset',
+    value: function reset() {
+      this._transient = {};
+      return this;
+    }
+  }, {
+    key: 'override',
+    value: function override() {
+      global._console = console;
+
+      delete global.console;
+
+      Object.defineProperty(global, 'console', {
+        enumerable: true,
+        configurable: true,
+        writable: false,
+        value: this
+      });
+
+      return this;
+    }
+  }]);
+  return _class;
+}();
+
+exports.default = _class;

dist/routers/viewer.js

@@ -0,0 +1,175 @@
+'use strict';
+
+var _maxSafeInteger = require('babel-runtime/core-js/number/max-safe-integer');
+
+var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger);
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _assign = require('babel-runtime/core-js/object/assign');
+
+var _assign2 = _interopRequireDefault(_assign);
+
+var _typeof2 = require('babel-runtime/helpers/typeof');
+
+var _typeof3 = _interopRequireDefault(_typeof2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.create = create;
+
+var _express = require('express');
+
+var _express2 = _interopRequireDefault(_express);
+
+var _mongoose = require('mongoose');
+
+var _mongoose2 = _interopRequireDefault(_mongoose);
+
+var _entry = require('../schemas/entry');
+
+var _entry2 = _interopRequireDefault(_entry);
+
+var _jade = require('jade');
+
+var _jade2 = _interopRequireDefault(_jade);
+
+var _expressSession = require('express-session');
+
+var _expressSession2 = _interopRequireDefault(_expressSession);
+
+var _bodyParser = require('body-parser');
+
+var _bodyParser2 = _interopRequireDefault(_bodyParser);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getObject(d, def) {
+  if (typeof d === 'undefined' || d === null) {
+    return def || {};
+  } else if ((typeof d === 'undefined' ? 'undefined' : (0, _typeof3.default)(d)) === 'object') {
+    return d;
+  } else {
+    try {
+      return JSON.parse(d);
+    } catch (e) {
+      return def || {};
+    }
+  }
+}
+
+var viewer = _jade2.default.compileFile(__dirname + '/../../views/viewer.jade');
+var login = _jade2.default.compileFile(__dirname + '/../../views/login.jade');
+
+function create() {
+  var mongoUri = arguments.length <= 0 || arguments[0] === undefined ? 'mongodb://localhost/scribe' : arguments[0];
+  var routerConfig = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+  var clientConfig = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+  var debug = arguments.length <= 3 || arguments[3] === undefined ? false : arguments[3];
+
+  routerConfig = (0, _assign2.default)({
+    sessionSecret: 'scribe-session',
+    useSession: true,
+    useBodyParser: true,
+    username: 'build',
+    password: 'build'
+  }, routerConfig);
+
+  _mongoose2.default.set('debug', debug);
+
+  var router = new _express.Router();
+  var conn = _mongoose2.default.createConnection(mongoUri);
+  var Entry = conn.model('Entry', _entry2.default);
+
+  router.use(_express2.default.static('public'));
+
+  function isAuthenticated(req, res, next) {
+    if (!routerConfig.authentication || req.session.authenticated) {
+      return next();
+    }
+
+    res.redirect(req.baseUrl);
+  }
+
+  if (routerConfig.useSession) {
+    router.use((0, _expressSession2.default)({ secret: routerConfig.sessionSecret, saveUninitialized: true, resave: true }));
+  }
+
+  if (routerConfig.useBodyParser) {
+    router.use(_bodyParser2.default.json());
+  }
+
+  router.post('/', function (req, res) {
+    req.session.authenticated |= !routerConfig.authentication || req.body.username === routerConfig.username && req.body.password === routerConfig.password;
+    if (req.session.authenticated) {
+      return res.json({ data: 'viewer' });
+    }
+
+    res.json({ status: 1, message: 'Invalid username/password' });
+  });
+
+  router.get('/', function (req, res) {
+    if (!routerConfig.authentication || req.session.authenticated) {
+      return res.redirect('viewer');
+    }
+
+    res.send(login());
+  });
+
+  router.get('/viewer', isAuthenticated, function (req, res) {
+    return res.send(viewer({
+      config: (0, _stringify2.default)(clientConfig)
+    }));
+  });
+
+  router.get('/rest/:collection', isAuthenticated, function (req, res) {
+    var collection = req.params.collection;
+    var selector = getObject(req.query.selector);
+    var fields = typeof req.query.fields === 'string' ? req.query.fields : '';
+    var sort = getObject(req.query.sort, { _id: -1 });
+    var limit = !isNaN(req.query.limit) ? Math.max(0, parseInt(Number(req.query.limit))) : _maxSafeInteger2.default;
+    var col = Entry; // defaulting to Entry for now
+
+    if (!col) {
+      return res.json({ err: 1, docs: [] });
+    }
+
+    col.find(selector).select(fields).sort(sort).limit(limit).lean().exec(function () {
+      var err = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0];
+      var docs = arguments.length <= 1 || arguments[1] === undefined ? [] : arguments[1];
+      return res.json({ err: err, docs: docs });
+    });
+  });
+
+  router.delete('/rest/:collection', isAuthenticated, function (req, res) {
+    var collection = rreq.params.collection;
+    var ids = req.query.id;
+
+    try {
+      ids = JSON.parse(ids);
+    } catch (e) {
+      // ignore
+    }
+
+    if (!Array.isArray(ids)) {
+      ids = [req.param('id')];
+    }
+
+    var col = Entry; // defaulting to Entry for now
+
+    if (col) {
+      return col.remove({ _id: { $in: ids } }, function (err) {
+        res.status(err ? 410 : 200);
+        res.send();
+      });
+    }
+
+    res.status(410);
+    res.send();
+  });
+
+  return router;
+}

dist/schemas/entry.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _mongoose = require('mongoose');
+
+var EntrySchema = new _mongoose.Schema({
+  transient: _mongoose.Schema.Types.Object,
+  persistent: _mongoose.Schema.Types.Object,
+  args: _mongoose.Schema.Types.Object,
+  date: { type: Date, default: Date.now },
+  expose: String,
+  serialized: String // experimental
+});
+
+EntrySchema.index({ 'persistent.app': 1, 'persistent.id': -1 });
+
+exports.default = EntrySchema;

dist/scribe.js

@@ -0,0 +1,174 @@
+'use strict';
+
+var _stringify = require('babel-runtime/core-js/json/stringify');
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _assign = require('babel-runtime/core-js/object/assign');
+
+var _assign2 = _interopRequireDefault(_assign);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Transform = exports.Reader = exports.Writer = undefined;
+
+exports.default = function () {
+  var id = arguments.length <= 0 || arguments[0] === undefined ? process.pid : arguments[0];
+  var opts = arguments.length <= 1 || arguments[1] === undefined ? (0, _rc2.default)('scribe', defaultOpts) : arguments[1];
+
+  opts = (0, _assign2.default)({}, defaultOpts, opts);
+
+  var console = new _BasicConsole2.default(opts.name, id || opts.instanceId);
+
+  console.exposed().forEach(function (expose) {
+    if (opts.mongoUri) {
+      console.pipe(expose, 'mongo-socket', new _ErrorExtractor2.default(), new _MongoDB2.default(opts.mongoUri, opts.debug), opts.socketPort ? new _SocketIO2.default(opts.socketPort, opts.debug) : null);
+    }
+
+    console.pipe(expose, 'bash', new _Inspector2.default(), new _DefaultConsole2.default());
+  });
+
+  if (opts.mongoUri) {
+    console.pipe('express', 'mongo-socket', new _ErrorExtractor2.default(), new _ExpressExtractor2.default(), new _MongoDB2.default(opts.mongoUri, opts.debug), opts.socketPort ? new _SocketIO2.default(opts.socketPort, opts.debug) : null);
+  }
+
+  console.pipe('express', 'bash', new _ExpressExtractor2.default(), new _ExpressInspector2.default(), new _Inspector2.default(), new _DefaultConsole2.default());
+
+  opts.web.client.socketUris = opts.web.client.socketPorts.map(function (port) {
+    return opts.publicUri + ':' + port;
+  });
+
+  console.viewer = _viewer.create.bind(null, opts.mongoUri, opts.web.router, opts.web.client, opts.debug);
+
+  console.build = function () {
+
+    // update
+    _package2.default.main = opts.publicUri + ':' + _path2.default.join(String(opts.web.client.port), opts.basePath);
+
+    // save
+    _fs2.default.writeFileSync('./native/package.json', (0, _stringify2.default)(_package2.default, null, 4), { encoding: 'utf8' });
+
+    var nw = new _nwBuilder2.default((0, _assign2.default)({
+      platforms: ['win', 'osx', 'linux'],
+      buildDir: './public/native',
+      version: '0.12.3',
+      zip: true
+    }, opts.nwjs, { files: './native/**/**' }));
+
+    if (opts.debug) {
+      nw.on('log', function (d) {
+        return console.log(d);
+      });
+    }
+
+    return nw.build();
+  };
+
+  process.on('uncaughtException', function (e) {
+    return console.error(e).then(function () {
+      return process.exit(1);
+    });
+  });
+
+  return console;
+};
+
+var _fs = require('fs');
+
+var _fs2 = _interopRequireDefault(_fs);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+var _Console = require('./readers/Console');
+
+var _Console2 = _interopRequireDefault(_Console);
+
+var _BasicConsole = require('./readers/BasicConsole');
+
+var _BasicConsole2 = _interopRequireDefault(_BasicConsole);
+
+var _Inspector = require('./transforms/Inspector');
+
+var _Inspector2 = _interopRequireDefault(_Inspector);
+
+var _ExpressInspector = require('./transforms/ExpressInspector');
+
+var _ExpressInspector2 = _interopRequireDefault(_ExpressInspector);
+
+var _ExpressExtractor = require('./transforms/ExpressExtractor');
+
+var _ExpressExtractor2 = _interopRequireDefault(_ExpressExtractor);
+
+var _ErrorExtractor = require('./transforms/ErrorExtractor');
+
+var _ErrorExtractor2 = _interopRequireDefault(_ErrorExtractor);
+
+var _MongoDB = require('./writers/MongoDB');
+
+var _MongoDB2 = _interopRequireDefault(_MongoDB);
+
+var _SocketIO = require('./writers/SocketIO');
+
+var _SocketIO2 = _interopRequireDefault(_SocketIO);
+
+var _DefaultConsole = require('./writers/DefaultConsole');
+
+var _DefaultConsole2 = _interopRequireDefault(_DefaultConsole);
+
+var _viewer = require('./routers/viewer');
+
+var _nwBuilder = require('nw-builder');
+
+var _nwBuilder2 = _interopRequireDefault(_nwBuilder);
+
+var _rc = require('rc');
+
+var _rc2 = _interopRequireDefault(_rc);
+
+var _package = require('./../native/package.json');
+
+var _package2 = _interopRequireDefault(_package);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Writer = exports.Writer = { MongoDB: _MongoDB2.default, DefaultConsole: _DefaultConsole2.default };
+var Reader = exports.Reader = { BasicConsole: _BasicConsole2.default, Console: _Console2.default };
+var Transform = exports.Transform = { Inspector: _Inspector2.default, ExpressInspector: _ExpressInspector2.default, ExpressExtractor: _ExpressExtractor2.default, ErrorExtractor: _ErrorExtractor2.default };
+
+var defaultOpts = {
+  name: 'Scribe',
+  mongoUri: 'mongodb://localhost/scribe',
+  publicUri: 'http://localhost',
+  basePath: 'scribe/',
+  socketPort: 4000,
+  web: {
+    router: {
+      username: 'build',
+      password: 'build',
+      authentication: true,
+      sessionSecret: 'scribe-session',
+      useBodyParser: true,
+      useSession: true
+    },
+    client: {
+      port: 4005,
+      socketPorts: [4000],
+      exposed: {
+        all: { label: 'all', query: { expose: { $exists: true } } },
+        error: { label: 'error', query: { expose: 'error' } },
+        express: { label: 'express', query: { expose: 'express' } },
+        info: { label: 'info', query: { expose: 'info' } },
+        log: { label: 'log', query: { expose: 'log' } },
+        warn: { label: 'warn', query: { expose: 'warn' } },
+        trace: { label: 'trace', query: { expose: 'trace' } }
+      }
+    }
+  },
+  nwjs: {},
+  debug: false
+};
+
+;

dist/transforms/ErrorExtractor.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _stringify = require("babel-runtime/core-js/json/stringify");
+
+var _stringify2 = _interopRequireDefault(_stringify);
+
+var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require("babel-runtime/helpers/createClass");
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var ErrorExtractor = function () {
+  function ErrorExtractor() {
+    (0, _classCallCheck3.default)(this, ErrorExtractor);
+  }
+
+  (0, _createClass3.default)(ErrorExtractor, [{
+    key: "through",
+    value: function through(data, callback) {
+      data.args = data.args.map(function (a) {
+        return a instanceof Error ? JSON.parse((0, _stringify2.default)(a, ["message", "arguments", "type", "name", "stack"])) : a;
+      });
+
+      callback(null, data);
+    }
+  }]);
+  return ErrorExtractor;
+}();
+
+exports.default = ErrorExtractor;

dist/transforms/ExpressExtractor.js

@@ -0,0 +1,109 @@
+'use strict';
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _chalk = require('chalk');
+
+var _chalk2 = _interopRequireDefault(_chalk);
+
+var _basicAuth = require('basic-auth');
+
+var _basicAuth2 = _interopRequireDefault(_basicAuth);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var ExpressExtractor = function () {
+  function ExpressExtractor() {
+    (0, _classCallCheck3.default)(this, ExpressExtractor);
+  }
+
+  (0, _createClass3.default)(ExpressExtractor, [{
+    key: 'ip',
+    value: function ip(req) {
+      return req.ip || req._remoteAddress || req.remoteAddress || req.connection && req.connection.remoteAddress || req.headers['x-forwarded-for'] || undefined;
+    }
+  }, {
+    key: 'header',
+    value: function header(res, field) {
+      if (!res._header) {
+        return undefined;
+      }
+
+      var header = res.getHeader(field);
+
+      return Array.isArray(header) ? header.join(', ') : header;
+    }
+  }, {
+    key: 'remoteUser',
+    value: function remoteUser(req) {
+      var credentials = (0, _basicAuth2.default)(req);
+      return credentials ? credentials.name : undefined;
+    }
+  }, {
+    key: 'httpVersion',
+    value: function httpVersion(req) {
+      return req.httpVersionMajor + '.' + req.httpVersionMinor;
+    }
+  }, {
+    key: 'referrer',
+    value: function referrer(req) {
+      return req.headers['referer'] || req.headers['referrer'] || req.headers['ref'];
+    }
+  }, {
+    key: 'status',
+    value: function status(res) {
+      return res._header ? String(res.statusCode) : undefined;
+    }
+  }, {
+    key: 'through',
+    value: function through(data, callback) {
+      var _data$args$ = data.args[0];
+      var req = _data$args$.req;
+      var res = _data$args$.res;
+      var duration = _data$args$.duration;
+
+      var status = this.status(res);
+      var url = req.url;
+      var referrer = this.referrer(req);
+      var remoteUser = this.remoteUser(req);
+      var httpVersion = this.httpVersion(req);
+      var ip = this.ip(req);
+      var contentLength = this.header(res, 'content-length') || 0;
+      var method = req.method;
+      var baseUrl = req.baseUrl;
+      var originalUrl = req.originalUrl;
+      var params = req.originalUrl;
+      var query = req.query;
+      var express = {
+        baseUrl: baseUrl, originalUrl: originalUrl, params: params, query: query,
+        url: url, method: method, status: status, referrer: referrer, remoteUser: remoteUser, httpVersion: httpVersion, ip: ip,
+        duration: duration, contentLength: contentLength, headers: {
+          req: req._headers,
+          res: res.headers
+        }
+      };
+
+      // add to default metrics object
+      var metrics = data.transient.metrics || {};
+      metrics.responseTime = duration;
+      data.transient.metrics = metrics;
+
+      data.args = [express];
+
+      callback(null, data);
+    }
+  }]);
+  return ExpressExtractor;
+}();
+
+exports.default = ExpressExtractor;

dist/transforms/ExpressInspector.js

@@ -0,0 +1,74 @@
+'use strict';
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _chalk = require('chalk');
+
+var _chalk2 = _interopRequireDefault(_chalk);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var ExpressInspector = function () {
+  function ExpressInspector() {
+    var colors = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0];
+    var symbols = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
+    (0, _classCallCheck3.default)(this, ExpressInspector);
+
+    this.colors = colors;
+    this.symbols = symbols;
+  }
+
+  (0, _createClass3.default)(ExpressInspector, [{
+    key: 'status',
+    value: function status(express) {
+      var stat = express.status;
+      var symbol = '✓';
+      var color = '';
+
+      if (100 <= stat && stat < 200) {
+        symbol = '';
+      } else if (200 <= stat && stat < 300) {
+        symbol = '✓';
+      } else if (300 <= stat && stat < 400) {
+        symbol = '';
+      } else if (400 <= stat && stat < 500) {
+        symbol = '✘';
+        color = 'red';
+      } else {
+        symbol = '';
+      }
+
+      var ret = undefined;
+      if (this.symbols) {
+        ret = symbol + ' ' + stat;
+      } else {
+        ret = '' + stat;
+      }
+
+      return color ? _chalk2.default[color](ret) : ret;
+    }
+  }, {
+    key: 'through',
+    value: function through(data, callback) {
+      var express = data.args[0];
+
+      data.transient['callsite'] = '' + express.ip;
+      data.args = [_chalk2.default.bgGreen.black(' ' + express.method + ' ') + ' ' + _chalk2.default.gray(express.url) + ' ' + this.status(express) + ' - ' + express.contentLength + ' ' + _chalk2.default.gray('(' + express.duration.toFixed(3) + 'ms)')];
+
+      callback(null, data);
+    }
+  }]);
+  return ExpressInspector;
+}();
+
+exports.default = ExpressInspector;

dist/transforms/Inspector.js

@@ -0,0 +1,171 @@
+'use strict';
+
+var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
+
+var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
+
+var _getIterator2 = require('babel-runtime/core-js/get-iterator');
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _underscore = require('underscore');
+
+var _underscore2 = _interopRequireDefault(_underscore);
+
+var _chalk = require('chalk');
+
+var _chalk2 = _interopRequireDefault(_chalk);
+
+var _inspect = require('../libs/inspect');
+
+var _inspect2 = _interopRequireDefault(_inspect);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Inspector = function () {
+  function Inspector() {
+    var inspectOpts = arguments.length <= 0 || arguments[0] === undefined ? { colors: true, showHidden: false, depth: 5 } : arguments[0];
+    (0, _classCallCheck3.default)(this, Inspector);
+
+    this.inspectOpts = inspectOpts;
+  }
+
+  (0, _createClass3.default)(Inspector, [{
+    key: 'format',
+    value: function format(f) {
+      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      var ctx = this.inspectOpts;
+
+      if (typeof f !== 'string') {
+        var objects = [];
+        var _iteratorNormalCompletion = true;
+        var _didIteratorError = false;
+        var _iteratorError = undefined;
+
+        try {
+          for (var _iterator = (0, _getIterator3.default)([f].concat(args)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var arg = _step.value;
+
+            objects.push((0, _inspect2.default)(arg, ctx));
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+
+        return objects.join(' ');
+      }
+
+      if (!args.length) {
+        return f;
+      }
+
+      var i = 0;
+      var len = args.length;
+      var str = String(f).replace(/%[sdj%]/g, function (x) {
+        if (x === '%%') return '%';
+        if (i >= len) return x;
+        switch (x) {
+          default:
+          case '%s':
+          case '%d':
+          case '%j':
+            return (0, _inspect2.default)(args[i++], ctx);
+        }
+      });
+
+      for (var x = args[i]; i < len; x = args[++i]) {
+        str += ' ' + (0, _inspect2.default)(x, ctx);
+      }
+
+      return str;
+    }
+  }, {
+    key: 'inspectArguments',
+    value: function inspectArguments(data) {
+      return this.format.apply(this, (0, _toConsumableArray3.default)(data.args));
+    }
+  }, {
+    key: 'inspectTags',
+    value: function inspectTags(data) {
+      return (data.persistent['tags'] || []).map(function (tag) {
+        return _chalk2.default.cyan('' + tag.toUpperCase());
+      }).concat((data.transient['tags'] || []).map(function (tag) {
+        return _chalk2.default.magenta('' + tag.toUpperCase());
+      })).join(' ');
+    }
+  }, {
+    key: 'inspectPre',
+    value: function inspectPre(data) {
+      return [_chalk2.default.yellow.bgBlack(data.persistent['app'] + '-' + data.persistent['id']), _chalk2.default.black.bgYellow(' ' + data.expose.toUpperCase() + ' ')].join(' ');
+    }
+  }, {
+    key: 'inspectMetrics',
+    value: function inspectMetrics(data) {
+      return _underscore2.default.map(data.transient['metrics'], function (value, key) {
+        return _chalk2.default.cyan(key + '(' + (typeof value === 'number' ? value.toFixed(3) : value) + ')');
+      }).join(' ');
+    }
+  }, {
+    key: 'inspectCallSite',
+    value: function inspectCallSite(data) {
+      var site = data.transient['callsite'];
+      if (typeof site === 'string') return _chalk2.default.gray.dim(site);
+
+      var _ref = site || { file: '', line: -1 };
+
+      var file = _ref.file;
+      var line = _ref.line;
+
+      return _chalk2.default.gray.dim(file.replace(/^.*[\\\/]/, '') + ':' + line);
+    }
+  }, {
+    key: 'through',
+    value: function through(data, callback) {
+      if (data.expose === 'metric') {
+        data.args = '';
+      }
+
+      var pre = this.inspectPre(data);
+      var tags = this.inspectTags(data);
+      var metrics = this.inspectMetrics(data);
+      var site = this.inspectCallSite(data);
+      var pretty = this.inspectArguments(data);
+      var inspected = pretty.split('\n').map(function (line) {
+        return pre + ' ' + [tags, metrics, line, site].join(' ');
+      });
+
+      data.inspected = inspected;
+
+      callback(null, data);
+    }
+  }]);
+  return Inspector;
+}();
+
+exports.default = Inspector;

dist/writers/DefaultConsole.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _underscore = require('underscore');
+
+var _underscore2 = _interopRequireDefault(_underscore);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var DefaultConsole = function () {
+  function DefaultConsole() {
+    (0, _classCallCheck3.default)(this, DefaultConsole);
+  }
+
+  (0, _createClass3.default)(DefaultConsole, [{
+    key: 'through',
+    value: function through(data, callback) {
+      _underscore2.default.map(data.inspected, function (a) {
+        return process.stdout.write(a + '\n');
+      });
+      callback();
+    }
+  }]);
+  return DefaultConsole;
+}();
+
+exports.default = DefaultConsole;

dist/writers/MongoDB.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _mongoose = require('mongoose');
+
+var _mongoose2 = _interopRequireDefault(_mongoose);
+
+var _entry = require('../schemas/entry');
+
+var _entry2 = _interopRequireDefault(_entry);
+
+var _JSON = require('../libs/JSON2');
+
+var JSON2 = _interopRequireWildcard(_JSON);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var MongoDB = function () {
+  function MongoDB() {
+    var address = arguments.length <= 0 || arguments[0] === undefined ? 'mongodb://localhost/scribe' : arguments[0];
+    var debug = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
+    (0, _classCallCheck3.default)(this, MongoDB);
+
+    _mongoose2.default.set('debug', debug);
+
+    var conn = _mongoose2.default.createConnection(address);
+    this._debug = debug;
+    this._entry = conn.model('Entry', _entry2.default);
+  }
+
+  (0, _createClass3.default)(MongoDB, [{
+    key: 'through',
+    value: function through(data, callback) {
+      var _this = this;
+
+      new this.Entry(JSON.parse(JSON2.stringify(data))).save(function (err, data) {
+        if (err && _this._debug) console.error(err);
+        callback(err, data);
+      });
+    }
+  }, {
+    key: 'Entry',
+    get: function get() {
+      return this._entry;
+    }
+  }]);
+  return MongoDB;
+}();
+
+exports.default = MongoDB;

dist/writers/SocketIO.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
+
+var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
+
+var _createClass2 = require('babel-runtime/helpers/createClass');
+
+var _createClass3 = _interopRequireDefault(_createClass2);
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _socket = require('socket.io');
+
+var _socket2 = _interopRequireDefault(_socket);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var sio = undefined;
+
+var SocketIO = function () {
+  function SocketIO() {
+    var port = arguments.length <= 0 || arguments[0] === undefined ? 4000 : arguments[0];
+    var debug = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
+    (0, _classCallCheck3.default)(this, SocketIO);
+
+    process.env.DEBUG = debug;
+
+    if (!sio) {
+      sio = (0, _socket2.default)(port);
+    }
+  }
+
+  (0, _createClass3.default)(SocketIO, [{
+    key: 'through',
+    value: function through(data, callback) {
+      sio.sockets.emit('data', data);
+      callback(null, data);
+    }
+  }]);
+  return SocketIO;
+}();
+
+exports.default = SocketIO;

examples/cluster-server.js

@@ -2,7 +2,7 @@ import cluster from 'cluster'
 import http from 'http'
 import express from 'express'
 import Scribe from '../index.js'
-import * as JSON2 from '../libs/JSON2'
+import * as JSON2 from '../src/libs/JSON2'
 
 const port = 4005;
 const socketPort = 50000;

examples/simple-server.js

@@ -1,6 +1,6 @@
 import express from 'express'
 import Scribe from '../index.js'
-import * as JSON2 from '../libs/JSON2'
+import * as JSON2 from '../src/libs/JSON2'
 
 const port = 4005;
 const socketPort = 50000;

herokuapp/app.js

@@ -1,6 +1,6 @@
 /* jshint -W079 */
 (function() {
-    var scribe = require('../scribe')(),
+    var scribe = require('../src/scribe')(),
         console = process.console,
         express = require('express'),
         path = require('path'),

index.js

@@ -1,3 +1 @@
-require('babel-register');
-
-module.exports = require('./scribe');
+module.exports = require('./dist/scribe').default;

package.json

@@ -27,15 +27,10 @@
       "url": "https://github.com/bluejamesbond/Scribe.js/blob/master/LICENSE-MIT"
     }
   ],
-  "main": "scribe.js",
+  "main": "index.js",
   "license": "MIT",
   "dependencies": {
     "async": "^1.5.2",
-    "babel-plugin-transform-object-rest-spread": "^6.3.13",
-    "babel-plugin-transform-runtime": "^6.4.3",
-    "babel-preset-es2015": "^6.3.13",
-    "babel-register": "^6.3.13",
-    "babel-runtime": "^6.3.19",
     "basic-auth": "^1.0.3",
     "body-parser": "^1.14.2",
     "brace": "^0.7.0",
@@ -78,6 +73,7 @@
     "cssify": "^1.0.2",
     "expect.js": "^0.3.1",
     "grunt": "^0.4.5",
+    "grunt-babel": "^6.0.0",
     "grunt-browserify": "^4.0.1",
     "grunt-contrib-clean": "^0.7.0",
     "grunt-contrib-copy": "^0.8.2",
@@ -89,6 +85,10 @@
     "license-report": "^1.0.8",
     "load-grunt-tasks": "^3.4.0",
     "mocha": "^2.3.4",
-    "time-grunt": "^1.3.0"
+    "time-grunt": "^1.3.0",
+    "babel-plugin-transform-object-rest-spread": "^6.3.13",
+    "babel-plugin-transform-runtime": "^6.4.3",
+    "babel-preset-es2015": "^6.3.13",
+    "babel-runtime": "^6.3.19"
   }
 }

src/routers/viewer.js

@@ -19,8 +19,8 @@ function getObject(d, def) {
   }
 }
 
-const viewer = jade.compileFile(`${__dirname}/../views/viewer.jade`);
-const login = jade.compileFile(`${__dirname}/../views/login.jade`);
+const viewer = jade.compileFile(`${__dirname}/../../views/viewer.jade`);
+const login = jade.compileFile(`${__dirname}/../../views/login.jade`);
 
 export function create(mongoUri = 'mongodb://localhost/scribe', routerConfig = {}, clientConfig = {}, debug = false) {
   routerConfig = Object.assign({

src/scribe.js

@@ -12,7 +12,7 @@ import DefaultConsole from './writers/DefaultConsole'
 import {create} from './routers/viewer'
 import NwBuilder from 'nw-builder'
 import rc from 'rc'
-import nativePackage from './native/package.json'
+import nativePackage from './../native/package.json'
 
 export const Writer = {MongoDB, DefaultConsole};
 export const Reader = {BasicConsole, Console};