workers: classify.

lib/workers/child-browser.js

@@ -10,40 +10,42 @@ const assert = require('assert');
 const EventEmitter = require('events');
 
 /**
+ * Child
  * Represents a child process.
  * @alias module:workers.Child
- * @constructor
+ * @extends EventEmitter
  * @ignore
+ */
+
+class Child extends EventEmitter {
+  /**
+   * Represents a child process.
+   * @constructor
    * @param {String} file
    */
 
-function Child(file) {
+  constructor(file) {
-  if (!(this instanceof Child))
+    super();
-    return new Child(file);
-
-  EventEmitter.call(this);
 
     this.init(file);
-}
+  }
 
-Object.setPrototypeOf(Child.prototype, EventEmitter.prototype);
+  /**
-
-/**
    * Test whether child process support is available.
    * @returns {Boolean}
    */
 
-Child.hasSupport = function hasSupport() {
+  static hasSupport() {
     return typeof global.postMessage === 'function';
-};
+  }
 
-/**
+  /**
    * Initialize child process. Bind to events.
    * @private
    * @param {String} file
    */
 
-Child.prototype.init = function init(file) {
+  init(file) {
     this.child = new global.Worker(file);
 
     this.child.onerror = (event) => {
@@ -64,15 +66,15 @@ Child.prototype.init = function init(file) {
       }
       this.emit('data', data);
     };
-};
+  }
 
-/**
+  /**
    * Send data to child process.
    * @param {Buffer} data
    * @returns {Boolean}
    */
 
-Child.prototype.write = function write(data) {
+  write(data) {
     if (this.child.postMessage.length === 2) {
       data.__proto__ = Uint8Array.prototype;
       this.child.postMessage({ data }, [data]);
@@ -80,16 +82,17 @@ Child.prototype.write = function write(data) {
       this.child.postMessage(data.toString('hex'));
     }
     return true;
-};
+  }
 
-/**
+  /**
    * Destroy the child process.
    */
 
-Child.prototype.destroy = function destroy() {
+  destroy() {
     this.child.terminate();
     this.emit('exit', 15 | 0x80, 'SIGTERM');
-};
+  }
+}
 
 /*
  * Expose

lib/workers/child.js

@@ -14,42 +14,45 @@ const children = new Set();
 let exitBound = false;
 
 /**
+ * Child
  * Represents a child process.
  * @alias module:workers.Child
+ * @extends EventEmitter
+ * @ignore
+ */
+
+class Child extends EventEmitter {
+  /**
+   * Represents a child process.
    * @constructor
    * @param {String} file
    */
 
-function Child(file) {
+  constructor(file) {
-  if (!(this instanceof Child))
+    super();
-    return new Child(file);
-
-  EventEmitter.call(this);
 
     bindExit();
     children.add(this);
 
     this.init(file);
-}
+  }
 
-Object.setPrototypeOf(Child.prototype, EventEmitter.prototype);
+  /**
-
-/**
    * Test whether child process support is available.
    * @returns {Boolean}
    */
 
-Child.hasSupport = function hasSupport() {
+  static hasSupport() {
     return true;
-};
+  }
 
-/**
+  /**
    * Initialize child process (node.js).
    * @private
    * @param {String} file
    */
 
-Child.prototype.init = function init(file) {
+  init(file) {
     const bin = process.argv[0];
     const filename = path.resolve(__dirname, file);
     const options = { stdio: 'pipe', env: process.env };
@@ -85,25 +88,26 @@ Child.prototype.init = function init(file) {
     this.child.stdout.on('data', (data) => {
       this.emit('data', data);
     });
-};
+  }
 
-/**
+  /**
    * Send data to child process.
    * @param {Buffer} data
    * @returns {Boolean}
    */
 
-Child.prototype.write = function write(data) {
+  write(data) {
     return this.child.stdin.write(data);
-};
+  }
 
-/**
+  /**
    * Destroy the child process.
    */
 
-Child.prototype.destroy = function destroy() {
+  destroy() {
     this.child.kill('SIGTERM');
-};
+  }
+}
 
 /**
  * Cleanup all child processes.

lib/workers/framer.js

@@ -12,15 +12,17 @@ const bio = require('bufio');
 /**
  * Framer
  * @alias module:workers.Framer
+ */
+
+class Framer {
+  /**
+   * Create a framer.
    * @constructor
    */
 
-function Framer() {
+  constructor() {}
-  if (!(this instanceof Framer))
-    return new Framer();
-}
 
-Framer.prototype.packet = function packet(payload) {
+  packet(payload) {
     const size = 10 + payload.getSize();
     const bw = bio.write(size);
 
@@ -36,7 +38,8 @@ Framer.prototype.packet = function packet(payload) {
     msg.writeUInt32LE(msg.length - 10, 5, true);
 
     return msg;
-};
+  }
+}
 
 /*
  * Expose

lib/workers/master.js

@@ -18,16 +18,20 @@ const packets = require('./packets');
 const Parent = require('./parent');
 
 /**
+ * Master
  * Represents the master process.
  * @alias module:workers.Master
+ * @extends EventEmitter
+ */
+
+class Master extends EventEmitter {
+  /**
+   * Create the master process.
    * @constructor
    */
 
-function Master() {
+  constructor() {
-  if (!(this instanceof Master))
+    super();
-    return new Master();
-
-  EventEmitter.call(this);
 
     this.parent = new Parent();
     this.framer = new Framer();
@@ -36,16 +40,14 @@ function Master() {
     this.color = false;
 
     this.init();
-}
+  }
 
-Object.setPrototypeOf(Master.prototype, EventEmitter.prototype);
+  /**
-
-/**
    * Initialize master. Bind events.
    * @private
    */
 
-Master.prototype.init = function init() {
+  init() {
     this.parent.on('data', (data) => {
       this.parser.feed(data);
     });
@@ -66,82 +68,82 @@ Master.prototype.init = function init() {
     this.parser.on('packet', (packet) => {
       this.emit('packet', packet);
     });
-};
+  }
 
-/**
+  /**
    * Set environment.
    * @param {Object} env
    */
 
-Master.prototype.setEnv = function setEnv(env) {
+  setEnv(env) {
     this.color = env.BCOIN_WORKER_ISTTY === '1';
     this.set(env.BCOIN_WORKER_NETWORK);
-};
+  }
 
-/**
+  /**
    * Set primary network.
    * @param {NetworkType|Network} network
    */
 
-Master.prototype.set = function set(network) {
+  set(network) {
     return Network.set(network);
-};
+  }
 
-/**
+  /**
    * Send data to worker.
    * @param {Buffer} data
    * @returns {Boolean}
    */
 
-Master.prototype.write = function write(data) {
+  write(data) {
     return this.parent.write(data);
-};
+  }
 
-/**
+  /**
    * Frame and send a packet.
    * @param {Packet} packet
    * @returns {Boolean}
    */
 
-Master.prototype.send = function send(packet) {
+  send(packet) {
     return this.write(this.framer.packet(packet));
-};
+  }
 
-/**
+  /**
    * Emit an event on the worker side.
    * @param {String} event
    * @param {...Object} arg
    * @returns {Boolean}
    */
 
-Master.prototype.sendEvent = function sendEvent(...items) {
+  sendEvent(...items) {
     return this.send(new packets.EventPacket(items));
-};
+  }
 
-/**
+  /**
    * Destroy the worker.
    */
 
-Master.prototype.destroy = function destroy() {
+  destroy() {
     return this.parent.destroy();
-};
+  }
 
-/**
+  /**
    * Write a message to stdout in the master process.
    * @param {Object|String} obj
    * @param {...String} args
    */
 
-Master.prototype.log = function log() {
+  log() {
     const text = format.apply(null, arguments);
     this.send(new packets.LogPacket(text));
-};
+  }
 
-/**
+  /**
    * Listen for messages from master process (only if worker).
    */
 
-Master.prototype.listen = function listen() {
+  listen() {
     assert(!this.listening, 'Already listening.');
 
     this.listening = true;
@@ -157,15 +159,15 @@ Master.prototype.listen = function listen() {
         this.emit('error', e);
       }
     });
-};
+  }
 
-/**
+  /**
    * Handle packet.
    * @private
    * @param {Packet}
    */
 
-Master.prototype.handlePacket = function handlePacket(packet) {
+  handlePacket(packet) {
     let result;
 
     switch (packet.cmd) {
@@ -185,7 +187,8 @@ Master.prototype.handlePacket = function handlePacket(packet) {
         this.send(result);
         break;
     }
-};
+  }
+}
 
 /*
  * Expose

lib/workers/parent-browser.js

@@ -10,29 +10,31 @@ const assert = require('assert');
 const EventEmitter = require('events');
 
 /**
+ * Parent
  * Represents the parent process.
  * @alias module:workers.Parent
- * @constructor
+ * @extends EventEmitter
  * @ignore
  */
 
-function Parent() {
+class Parent extends EventEmitter {
-  if (!(this instanceof Parent))
+  /**
-    return new Parent();
+   * Create the parent process.
+   * @constructor
+   */
 
-  EventEmitter.call(this);
+  constructor() {
+    super();
 
     this.init();
-}
+  }
 
-Object.setPrototypeOf(Parent.prototype, EventEmitter.prototype);
+  /**
-
-/**
    * Initialize master (web workers).
    * @private
    */
 
-Parent.prototype.init = function init() {
+  init() {
     global.onerror = (event) => {
       this.emit('error', new Error('Worker error.'));
     };
@@ -50,15 +52,15 @@ Parent.prototype.init = function init() {
       }
       this.emit('data', data);
     };
-};
+  }
 
-/**
+  /**
    * Send data to parent process.
    * @param {Buffer} data
    * @returns {Boolean}
    */
 
-Parent.prototype.write = function write(data) {
+  write(data) {
     if (global.postMessage.length === 2) {
       data.__proto__ = Uint8Array.prototype;
       global.postMessage({ data }, [data]);
@@ -66,15 +68,16 @@ Parent.prototype.write = function write(data) {
       global.postMessage(data.toString('hex'));
     }
     return true;
-};
+  }
 
-/**
+  /**
    * Destroy the parent process.
    */
 
-Parent.prototype.destroy = function destroy() {
+  destroy() {
     global.close();
-};
+  }
+}
 
 /*
  * Expose

lib/workers/parent.js

@@ -9,28 +9,30 @@
 const EventEmitter = require('events');
 
 /**
+ * Parent
  * Represents the parent process.
  * @alias module:workers.Parent
+ * @extends EventEmitter
+ */
+
+class Parent extends EventEmitter {
+  /**
+   * Create the parent process.
    * @constructor
    */
 
-function Parent() {
+  constructor() {
-  if (!(this instanceof Parent))
+    super();
-    return new Parent();
-
-  EventEmitter.call(this);
 
     this.init();
-}
+  }
 
-Object.setPrototypeOf(Parent.prototype, EventEmitter.prototype);
+  /**
-
-/**
    * Initialize master (node.js).
    * @private
    */
 
-Parent.prototype.init = function init() {
+  init() {
     process.stdin.on('data', (data) => {
       this.emit('data', data);
     });
@@ -43,25 +45,26 @@ Parent.prototype.init = function init() {
     process.on('uncaughtException', (err) => {
       this.emit('exception', err);
     });
-};
+  }
 
-/**
+  /**
    * Send data to parent process.
    * @param {Buffer} data
    * @returns {Boolean}
    */
 
-Parent.prototype.write = function write(data) {
+  write(data) {
     return process.stdout.write(data);
-};
+  }
 
-/**
+  /**
    * Destroy the parent process.
    */
 
-Parent.prototype.destroy = function destroy() {
+  destroy() {
     return process.exit(0);
-};
+  }
+}
 
 /*
  * Expose

lib/workers/parser.js

@@ -1,5 +1,5 @@
 /*!
- * workers.js - worker processes for bcoin
+ * parser.js - worker parser for bcoin
  * Copyright (c) 2014-2015, Fedor Indutny (MIT License)
  * Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
  * https://github.com/bcoin-org/bcoin
@@ -14,24 +14,25 @@ const packets = require('./packets');
 /**
  * Parser
  * @alias module:workers.Parser
+ * @extends EventEmitter
+ */
+
+class Parser extends EventEmitter {
+  /**
+   * Create a parser.
    * @constructor
    */
 
-function Parser() {
+  constructor() {
-  if (!(this instanceof Parser))
+    super();
-    return new Parser();
-
-  EventEmitter.call(this);
 
     this.waiting = 9;
     this.header = null;
     this.pending = [];
     this.total = 0;
-}
+  }
 
-Object.setPrototypeOf(Parser.prototype, EventEmitter.prototype);
+  feed(data) {
-
-Parser.prototype.feed = function feed(data) {
     this.total += data.length;
     this.pending.push(data);
 
@@ -39,9 +40,9 @@ Parser.prototype.feed = function feed(data) {
       const chunk = this.read(this.waiting);
       this.parse(chunk);
     }
-};
+  }
 
-Parser.prototype.read = function read(size) {
+  read(size) {
     assert(this.total >= size, 'Reading too much.');
 
     if (size === 0)
@@ -80,9 +81,9 @@ Parser.prototype.read = function read(size) {
     this.total -= chunk.length;
 
     return chunk;
-};
+  }
 
-Parser.prototype.parse = function parse(data) {
+  parse(data) {
     let header = this.header;
 
     if (!header) {
@@ -118,16 +119,16 @@ Parser.prototype.parse = function parse(data) {
     packet.id = header.id;
 
     this.emit('packet', packet);
-};
+  }
 
-Parser.prototype.parseHeader = function parseHeader(data) {
+  parseHeader(data) {
     const id = data.readUInt32LE(0, true);
     const cmd = data.readUInt8(4, true);
     const size = data.readUInt32LE(5, true);
     return new Header(id, cmd, size);
-};
+  }
 
-Parser.prototype.parsePacket = function parsePacket(header, data) {
+  parsePacket(header, data) {
     switch (header.cmd) {
       case packets.types.ENV:
         return packets.EnvPacket.fromRaw(data);
@@ -174,18 +175,25 @@ Parser.prototype.parsePacket = function parsePacket(header, data) {
       default:
         throw new Error('Unknown packet.');
     }
-};
+  }
+}
 
 /**
  * Header
- * @constructor
  * @ignore
  */
 
-function Header(id, cmd, size) {
+class Header {
+  /**
+   * Create a header.
+   * @constructor
+   */
+
+  constructor(id, cmd, size) {
     this.id = id;
     this.cmd = cmd;
     this.size = size;
+  }
 }
 
 /*

lib/workers/workerpool.js

@@ -20,23 +20,26 @@ const Framer = require('./framer');
 const packets = require('./packets');
 
 /**
- * A worker pool.
+ * Worker Pool
  * @alias module:workers.WorkerPool
- * @constructor
+ * @extends EventEmitter
- * @param {Object} options
- * @param {Number} [options.size=num-cores] - Max pool size.
- * @param {Number} [options.timeout=120000] - Execution timeout.
  * @property {Number} size
  * @property {Number} timeout
  * @property {Map} children
  * @property {Number} uid
  */
 
-function WorkerPool(options) {
+class WorkerPool extends EventEmitter {
-  if (!(this instanceof WorkerPool))
+  /**
-    return new WorkerPool(options);
+   * Create a worker pool.
+   * @constructor
+   * @param {Object} options
+   * @param {Number} [options.size=num-cores] - Max pool size.
+   * @param {Number} [options.timeout=120000] - Execution timeout.
+   */
 
-  EventEmitter.call(this);
+  constructor(options) {
+    super();
 
     this.enabled = false;
     this.size = getCores();
@@ -47,16 +50,14 @@ function WorkerPool(options) {
     this.uid = 0;
 
     this.set(options);
-}
+  }
 
-Object.setPrototypeOf(WorkerPool.prototype, EventEmitter.prototype);
+  /**
-
-/**
    * Set worker pool options.
    * @param {Object} options
    */
 
-WorkerPool.prototype.set = function set(options) {
+  set(options) {
     if (!options)
       return;
 
@@ -81,33 +82,33 @@ WorkerPool.prototype.set = function set(options) {
       assert(typeof options.file === 'string');
       this.file = options.file;
     }
-};
+  }
 
-/**
+  /**
    * Open worker pool.
    * @returns {Promise}
    */
 
-WorkerPool.prototype.open = async function open() {
+  async open() {
     ;
-};
+  }
 
-/**
+  /**
    * Close worker pool.
    * @returns {Promise}
    */
 
-WorkerPool.prototype.close = async function close() {
+  async close() {
     this.destroy();
-};
+  }
 
-/**
+  /**
    * Spawn a new worker.
    * @param {Number} id - Worker ID.
    * @returns {Worker}
    */
 
-WorkerPool.prototype.spawn = function spawn(id) {
+  spawn(id) {
     const child = new Worker(this.file);
 
     child.id = id;
@@ -135,31 +136,31 @@ WorkerPool.prototype.spawn = function spawn(id) {
     this.emit('spawn', child);
 
     return child;
-};
+  }
 
-/**
+  /**
    * Allocate a new worker, will not go above `size` option
    * and will automatically load balance the workers.
    * @returns {Worker}
    */
 
-WorkerPool.prototype.alloc = function alloc() {
+  alloc() {
     const id = this.uid++ % this.size;
 
     if (!this.children.has(id))
       this.children.set(id, this.spawn(id));
 
     return this.children.get(id);
-};
+  }
 
-/**
+  /**
    * Emit an event on the worker side (all workers).
    * @param {String} event
    * @param {...Object} arg
    * @returns {Boolean}
    */
 
-WorkerPool.prototype.sendEvent = function sendEvent() {
+  sendEvent() {
     let result = true;
 
     for (const child of this.children.values()) {
@@ -168,25 +169,25 @@ WorkerPool.prototype.sendEvent = function sendEvent() {
     }
 
     return result;
-};
+  }
 
-/**
+  /**
    * Destroy all workers.
    */
 
-WorkerPool.prototype.destroy = function destroy() {
+  destroy() {
     for (const child of this.children.values())
       child.destroy();
-};
+  }
 
-/**
+  /**
    * Call a method for a worker to execute.
    * @param {Packet} packet
    * @param {Number} timeout
    * @returns {Promise}
    */
 
-WorkerPool.prototype.execute = function execute(packet, timeout) {
+  execute(packet, timeout) {
     if (!this.enabled || !Child.hasSupport()) {
       return new Promise((resolve, reject) => {
         setImmediate(() => {
@@ -208,9 +209,9 @@ WorkerPool.prototype.execute = function execute(packet, timeout) {
     const child = this.alloc();
 
     return child.execute(packet, timeout);
-};
+  }
 
-/**
+  /**
    * Execute the tx check job (default timeout).
    * @method
    * @param {TX} tx
@@ -219,7 +220,7 @@ WorkerPool.prototype.execute = function execute(packet, timeout) {
    * @returns {Promise}
    */
 
-WorkerPool.prototype.check = async function check(tx, view, flags) {
+  async check(tx, view, flags) {
     const packet = new packets.CheckPacket(tx, view, flags);
     const result = await this.execute(packet, -1);
 
@@ -227,9 +228,9 @@ WorkerPool.prototype.check = async function check(tx, view, flags) {
       throw result.error;
 
     return null;
-};
+  }
 
-/**
+  /**
    * Execute the tx signing job (default timeout).
    * @method
    * @param {MTX} tx
@@ -238,7 +239,7 @@ WorkerPool.prototype.check = async function check(tx, view, flags) {
    * @returns {Promise}
    */
 
-WorkerPool.prototype.sign = async function sign(tx, ring, type) {
+  async sign(tx, ring, type) {
     let rings = ring;
 
     if (!Array.isArray(rings))
@@ -250,9 +251,9 @@ WorkerPool.prototype.sign = async function sign(tx, ring, type) {
     result.inject(tx);
 
     return result.total;
-};
+  }
 
-/**
+  /**
    * Execute the tx input check job (default timeout).
    * @method
    * @param {TX} tx
@@ -262,7 +263,7 @@ WorkerPool.prototype.sign = async function sign(tx, ring, type) {
    * @returns {Promise}
    */
 
-WorkerPool.prototype.checkInput = async function checkInput(tx, index, coin, flags) {
+  async checkInput(tx, index, coin, flags) {
     const packet = new packets.CheckInputPacket(tx, index, coin, flags);
     const result = await this.execute(packet, -1);
 
@@ -270,9 +271,9 @@ WorkerPool.prototype.checkInput = async function checkInput(tx, index, coin, fla
       throw result.error;
 
     return null;
-};
+  }
 
-/**
+  /**
    * Execute the tx input signing job (default timeout).
    * @method
    * @param {MTX} tx
@@ -283,14 +284,14 @@ WorkerPool.prototype.checkInput = async function checkInput(tx, index, coin, fla
    * @returns {Promise}
    */
 
-WorkerPool.prototype.signInput = async function signInput(tx, index, coin, ring, type) {
+  async signInput(tx, index, coin, ring, type) {
     const packet = new packets.SignInputPacket(tx, index, coin, ring, type);
     const result = await this.execute(packet, -1);
     result.inject(tx);
     return result.value;
-};
+  }
 
-/**
+  /**
    * Execute the secp256k1 verify job (no timeout).
    * @method
    * @param {Buffer} msg
@@ -299,13 +300,13 @@ WorkerPool.prototype.signInput = async function signInput(tx, index, coin, ring,
    * @returns {Promise}
    */
 
-WorkerPool.prototype.ecVerify = async function ecVerify(msg, sig, key) {
+  async ecVerify(msg, sig, key) {
     const packet = new packets.ECVerifyPacket(msg, sig, key);
     const result = await this.execute(packet, -1);
     return result.value;
-};
+  }
 
-/**
+  /**
    * Execute the secp256k1 signing job (no timeout).
    * @method
    * @param {Buffer} msg
@@ -313,13 +314,13 @@ WorkerPool.prototype.ecVerify = async function ecVerify(msg, sig, key) {
    * @returns {Promise}
    */
 
-WorkerPool.prototype.ecSign = async function ecSign(msg, key) {
+  async ecSign(msg, key) {
     const packet = new packets.ECSignPacket(msg, key);
     const result = await this.execute(packet, -1);
     return result.sig;
-};
+  }
 
-/**
+  /**
    * Execute the mining job (no timeout).
    * @method
    * @param {Buffer} data
@@ -329,13 +330,13 @@ WorkerPool.prototype.ecSign = async function ecSign(msg, key) {
    * @returns {Promise} - Returns {Number}.
    */
 
-WorkerPool.prototype.mine = async function mine(data, target, min, max) {
+  async mine(data, target, min, max) {
     const packet = new packets.MinePacket(data, target, min, max);
     const result = await this.execute(packet, -1);
     return result.nonce;
-};
+  }
 
-/**
+  /**
    * Execute scrypt job (no timeout).
    * @method
    * @param {Buffer} passwd
@@ -347,24 +348,28 @@ WorkerPool.prototype.mine = async function mine(data, target, min, max) {
    * @returns {Promise}
    */
 
-WorkerPool.prototype.scrypt = async function scrypt(passwd, salt, N, r, p, len) {
+  async scrypt(passwd, salt, N, r, p, len) {
     const packet = new packets.ScryptPacket(passwd, salt, N, r, p, len);
     const result = await this.execute(packet, -1);
     return result.key;
-};
+  }
+}
 
 /**
- * Represents a worker.
+ * Worker
  * @alias module:workers.Worker
+ * @extends EventEmitter
+ */
+
+class Worker extends EventEmitter {
+  /**
+   * Create a worker.
    * @constructor
    * @param {String} file
    */
 
-function Worker(file) {
+  constructor(file) {
-  if (!(this instanceof Worker))
+    super();
-    return new Worker(file);
-
-  EventEmitter.call(this);
 
     this.id = -1;
     this.framer = new Framer();
@@ -374,16 +379,14 @@ function Worker(file) {
     this.child = new Child(file);
 
     this.init();
-}
+  }
 
-Object.setPrototypeOf(Worker.prototype, EventEmitter.prototype);
+  /**
-
-/**
    * Initialize worker. Bind to events.
    * @private
    */
 
-Worker.prototype.init = function init() {
+  init() {
     this.child.on('data', (data) => {
       this.parser.feed(data);
     });
@@ -405,14 +408,14 @@ Worker.prototype.init = function init() {
     });
 
     this.listen();
-};
+  }
 
-/**
+  /**
    * Listen for packets.
    * @private
    */
 
-Worker.prototype.listen = function listen() {
+  listen() {
     this.on('exit', (code, signal) => {
       this.killJobs();
     });
@@ -435,15 +438,15 @@ Worker.prototype.listen = function listen() {
         ? (process.stdout.isTTY ? '1' : '0')
         : '0'
     });
-};
+  }
 
-/**
+  /**
    * Handle packet.
    * @private
    * @param {Packet} packet
    */
 
-Worker.prototype.handlePacket = function handlePacket(packet) {
+  handlePacket(packet) {
     switch (packet.cmd) {
       case packets.types.EVENT:
         this.emit('event', packet.items);
@@ -462,71 +465,71 @@ Worker.prototype.handlePacket = function handlePacket(packet) {
         this.resolveJob(packet.id, packet);
         break;
     }
-};
+  }
 
-/**
+  /**
    * Send data to worker.
    * @param {Buffer} data
    * @returns {Boolean}
    */
 
-Worker.prototype.write = function write(data) {
+  write(data) {
     return this.child.write(data);
-};
+  }
 
-/**
+  /**
    * Frame and send a packet.
    * @param {Packet} packet
    * @returns {Boolean}
    */
 
-Worker.prototype.send = function send(packet) {
+  send(packet) {
     return this.write(this.framer.packet(packet));
-};
+  }
 
-/**
+  /**
    * Send environment.
    * @param {Object} env
    * @returns {Boolean}
    */
 
-Worker.prototype.sendEnv = function sendEnv(env) {
+  sendEnv(env) {
     return this.send(new packets.EnvPacket(env));
-};
+  }
 
-/**
+  /**
    * Emit an event on the worker side.
    * @param {String} event
    * @param {...Object} arg
    * @returns {Boolean}
    */
 
-Worker.prototype.sendEvent = function sendEvent(...items) {
+  sendEvent(...items) {
     return this.send(new packets.EventPacket(items));
-};
+  }
 
-/**
+  /**
    * Destroy the worker.
    */
 
-Worker.prototype.destroy = function destroy() {
+  destroy() {
     return this.child.destroy();
-};
+  }
 
-/**
+  /**
    * Call a method for a worker to execute.
    * @param {Packet} packet
    * @param {Number} timeout
    * @returns {Promise}
    */
 
-Worker.prototype.execute = function execute(packet, timeout) {
+  execute(packet, timeout) {
     return new Promise((resolve, reject) => {
       this._execute(packet, timeout, resolve, reject);
     });
-};
+  }
 
-/**
+  /**
    * Call a method for a worker to execute.
    * @private
    * @param {Packet} packet
@@ -536,7 +539,7 @@ Worker.prototype.execute = function execute(packet, timeout) {
    * the worker method specifies.
    */
 
-Worker.prototype._execute = function _execute(packet, timeout, resolve, reject) {
+  _execute(packet, timeout, resolve, reject) {
     const job = new PendingJob(this, packet.id, resolve, reject);
 
     assert(!this.pending.has(packet.id), 'ID overflow.');
@@ -546,92 +549,98 @@ Worker.prototype._execute = function _execute(packet, timeout, resolve, reject)
     job.start(timeout);
 
     this.send(packet);
-};
+  }
 
-/**
+  /**
    * Resolve a job.
    * @param {Number} id
    * @param {Packet} result
    */
 
-Worker.prototype.resolveJob = function resolveJob(id, result) {
+  resolveJob(id, result) {
     const job = this.pending.get(id);
 
     if (!job)
       throw new Error(`Job ${id} is not in progress.`);
 
     job.resolve(result);
-};
+  }
 
-/**
+  /**
    * Reject a job.
    * @param {Number} id
    * @param {Error} err
    */
 
-Worker.prototype.rejectJob = function rejectJob(id, err) {
+  rejectJob(id, err) {
     const job = this.pending.get(id);
 
     if (!job)
       throw new Error(`Job ${id} is not in progress.`);
 
     job.reject(err);
-};
+  }
 
-/**
+  /**
    * Kill all jobs associated with worker.
    */
 
-Worker.prototype.killJobs = function killJobs() {
+  killJobs() {
     for (const job of this.pending.values())
       job.destroy();
-};
+  }
+}
 
 /**
  * Pending Job
- * @constructor
  * @ignore
+ */
+
+class PendingJob {
+  /**
+   * Create a pending job.
+   * @constructor
    * @param {Worker} worker
    * @param {Number} id
    * @param {Function} resolve
    * @param {Function} reject
    */
 
-function PendingJob(worker, id, resolve, reject) {
+  constructor(worker, id, resolve, reject) {
     this.worker = worker;
     this.id = id;
     this.job = { resolve, reject };
     this.timer = null;
-}
+  }
 
-/**
+  /**
    * Start the timer.
    * @param {Number} timeout
    */
 
-PendingJob.prototype.start = function start(timeout) {
+  start(timeout) {
     if (!timeout || timeout <= 0)
       return;
 
     this.timer = setTimeout(() => {
       this.reject(new Error('Worker timed out.'));
     }, timeout);
-};
+  }
 
-/**
+  /**
    * Destroy the job with an error.
    */
 
-PendingJob.prototype.destroy = function destroy() {
+  destroy() {
     this.reject(new Error('Job was destroyed.'));
-};
+  }
 
-/**
+  /**
    * Cleanup job state.
    * @returns {Job}
    */
 
-PendingJob.prototype.cleanup = function cleanup() {
+  cleanup() {
     const job = this.job;
 
     assert(job, 'Already finished.');
@@ -647,27 +656,28 @@ PendingJob.prototype.cleanup = function cleanup() {
     this.worker.pending.delete(this.id);
 
     return job;
-};
+  }
 
-/**
+  /**
    * Complete job with result.
    * @param {Object} result
    */
 
-PendingJob.prototype.resolve = function resolve(result) {
+  resolve(result) {
     const job = this.cleanup();
     job.resolve(result);
-};
+  }
 
-/**
+  /**
    * Complete job with error.
    * @param {Error} err
    */
 
-PendingJob.prototype.reject = function reject(err) {
+  reject(err) {
     const job = this.cleanup();
     job.reject(err);
-};
+  }
+}
 
 /*
  * Helpers