firetruss-worker 2.6.0 → 3.0.0

package/dist/worker.es2015.js

@@ -1,597 +1,527 @@
 /* globals firebase */
 
-var fireworkers = [];
-var apps = {};
+const fireworkers = [];
+const apps = {};
 // This version is filled in by the build, don't reformat the line.
-var VERSION = '2.6.0';
+const VERSION = '3.0.0';
 
 
-var LocalStorage = function LocalStorage() {
-  this._items = [];
-  this._pendingItems = [];
-  this._initialized = false;
-  this._flushPending = this.flushPending.bind(this);
-};
-
-var prototypeAccessors = { length: { configurable: true } };
-
-LocalStorage.prototype.init = function init (items) {
-  if (!this._initialized) {
-    this._items = items;
-    this._initialized = true;
+class LocalStorage {
+  constructor() {
+    this._items = [];
+    this._pendingItems = [];
+    this._initialized = false;
+    this._flushPending = this.flushPending.bind(this);
   }
-};
-
-LocalStorage.prototype._update = function _update (item) {
-  if (!this._pendingItems.length) { Promise.resolve().then(this._flushPending); }
-  this._pendingItems.push(item);
-};
 
-LocalStorage.prototype.flushPending = function flushPending () {
-  if (!this._pendingItems.length) { return; }
-  if (!fireworkers.length) {
-    setTimeout(this._flushPending, 200);
-    return;
+  init(items) {
+    if (!this._initialized) {
+      this._items = items;
+      this._initialized = true;
+    }
   }
-  fireworkers[0]._send({msg: 'updateLocalStorage', items: this._pendingItems});
-  this._pendingItems = [];
-};
 
-prototypeAccessors.length.get = function () {return this._items.length;};
+  _update(item) {
+    if (!this._pendingItems.length) Promise.resolve().then(this._flushPending);
+    this._pendingItems.push(item);
+  }
 
-LocalStorage.prototype.key = function key (n) {
-  return this._items[n].key;
-};
+  flushPending() {
+    if (!this._pendingItems.length) return;
+    if (!fireworkers.length) {
+      setTimeout(this._flushPending, 200);
+      return;
+    }
+    fireworkers[0]._send({msg: 'updateLocalStorage', items: this._pendingItems});
+    this._pendingItems = [];
+  }
 
-LocalStorage.prototype.getItem = function getItem (key) {
-  for (var i = 0, list = this._items; i < list.length; i += 1) {
-    var item = list[i];
+  get length() {return this._items.length;}
 
-      if (item.key === key) { return item.value; }
+  key(n) {
+    return this._items[n].key;
   }
-  return null;
-};
 
-LocalStorage.prototype.setItem = function setItem (key, value) {
-  var targetItem;
-  for (var i = 0, list = this._items; i < list.length; i += 1) {
-    var item = list[i];
+  getItem(key) {
+    for (const item of this._items) {
+      if (item.key === key) return item.value;
+    }
+    return null;
+  }
 
+  setItem(key, value) {
+    let targetItem;
+    for (const item of this._items) {
       if (item.key === key) {
-      targetItem = item;
-      item.value = value;
-      break;
+        targetItem = item;
+        item.value = value;
+        break;
+      }
     }
+    if (!targetItem) {
+      targetItem = {key, value};
+      this._items.push(targetItem);
+    }
+    this._update(targetItem);
   }
-  if (!targetItem) {
-    targetItem = {key: key, value: value};
-    this._items.push(targetItem);
-  }
-  this._update(targetItem);
-};
 
-LocalStorage.prototype.removeItem = function removeItem (key) {
-  for (var i = 0; i < this._items.length; i++) {
-    if (this._items[i].key === key) {
-      this._items.splice(i, 1);
-      this._update({key: key, value: null});
-      break;
+  removeItem(key) {
+    for (let i = 0; i < this._items.length; i++) {
+      if (this._items[i].key === key) {
+        this._items.splice(i, 1);
+        this._update({key, value: null});
+        break;
+      }
     }
   }
-};
 
-LocalStorage.prototype.clear = function clear () {
-  for (var item in this._items) {
-    this._update({key: item.key, value: null});
+  clear() {
+    for (const item in this._items) {
+      this._update({key: item.key, value: null});
+    }
+    this._items = [];
   }
-  this._items = [];
-};
-
-Object.defineProperties( LocalStorage.prototype, prototypeAccessors );
+}
 
 self.localStorage = new LocalStorage();
 
 
-var Branch = function Branch() {
-  this._root = null;
-};
-
-Branch.prototype.set = function set (value) {
-  this._root = value;
-};
+class Branch {
+  constructor() {
+    this._root = null;
+  }
 
-Branch.prototype.diff = function diff (value, pathPrefix) {
-  var updates = {};
-  var segments = pathPrefix === '/' ? [''] : pathPrefix.split('/');
-  if (this._diffRecursively(this._root, value, segments, updates)) {
+  set(value) {
     this._root = value;
-    updates[pathPrefix] = value;
-  }
-  return updates;
-};
-
-Branch.prototype._diffRecursively = function _diffRecursively (oldValue, newValue, segments, updates) {
-  if (oldValue === undefined) { oldValue = null; }
-  if (newValue === undefined) { newValue = null; }
-  if (oldValue === null) { return newValue !== null; }
-  if (oldValue instanceof Object && newValue instanceof Object) {
-    var replace = true;
-    var keysToReplace = [];
-    for (var childKey in newValue) {
-      if (!newValue.hasOwnProperty(childKey)) { continue; }
-      var replaceChild = this._diffRecursively(
-        oldValue[childKey], newValue[childKey], segments.concat(childKey), updates);
-      if (replaceChild) {
-        keysToReplace.push(childKey);
-      } else {
-        replace = false;
+  }
+
+  diff(value, pathPrefix) {
+    const updates = {};
+    const segments = pathPrefix === '/' ? [''] : pathPrefix.split('/');
+    if (this._diffRecursively(this._root, value, segments, updates)) {
+      this._root = value;
+      updates[pathPrefix] = value;
+    }
+    return updates;
+  }
+
+  _diffRecursively(oldValue, newValue, segments, updates) {
+    if (oldValue === undefined) oldValue = null;
+    if (newValue === undefined) newValue = null;
+    if (oldValue === null) return newValue !== null;
+    if (oldValue instanceof Object && newValue instanceof Object) {
+      let replace = true;
+      const keysToReplace = [];
+      for (const childKey in newValue) {
+        if (!newValue.hasOwnProperty(childKey)) continue;
+        const replaceChild = this._diffRecursively(
+          oldValue[childKey], newValue[childKey], segments.concat(childKey), updates);
+        if (replaceChild) {
+          keysToReplace.push(childKey);
+        } else {
+          replace = false;
+        }
       }
+      if (replace) return true;
+      for (const childKey in oldValue) {
+        if (!oldValue.hasOwnProperty(childKey) || newValue.hasOwnProperty(childKey)) continue;
+        updates[segments.concat(childKey).join('/')] = null;
+        delete oldValue[childKey];
+      }
+      for (const childKey of keysToReplace) {
+        updates[segments.concat(childKey).join('/')] = newValue[childKey];
+        oldValue[childKey] = newValue[childKey];
+      }
+    } else {
+      return newValue !== oldValue;
     }
-    if (replace) { return true; }
-    for (var childKey$1 in oldValue) {
-      if (!oldValue.hasOwnProperty(childKey$1) || newValue.hasOwnProperty(childKey$1)) { continue; }
-      updates[segments.concat(childKey$1).join('/')] = null;
-      delete oldValue[childKey$1];
+  }
+}
+
+
+class Fireworker {
+  constructor(port) {
+    this._port = port;
+    this._lastWriteSerial = 0;
+    this._app = undefined;
+    this._cachedAuth = undefined;
+    this._cachedDatabase = undefined;
+    this._lastJsonUser = undefined;
+    this._configError = Fireworker._staticConfigError;
+    this._callbacks = {};
+    this._messages = [];
+    this._flushMessageQueue = this._flushMessageQueue.bind(this);
+    port.onmessage = this._receive.bind(this);
+  }
+
+  get _auth() {
+    if (this._cachedAuth) return this._cachedAuth;
+    if (!this._app) throw new Error('Must provide Firebase configuration data first');
+    return this._cachedAuth = this._app.auth();
+  }
+
+  get _database() {
+    if (this._cachedDatabase) return this._cachedDatabase;
+    if (!this._app) throw new Error('Must provide Firebase configuration data first');
+    if (Fireworker._databaseWrapperCallback) {
+      this._cachedDatabase = Fireworker._databaseWrapperCallback(this._app.database());
+    } else {
+      this._cachedDatabase = this._app.database();
     }
-    for (var i = 0, list = keysToReplace; i < list.length; i += 1) {
-      var childKey$2 = list[i];
+    return this._cachedDatabase;
+  }
+
+  init({storage, config}) {
+    if (storage) self.localStorage.init(storage);
+    if (config) {
+      try {
+        this._app = apps[config.databaseURL];
+        if (!this._app) {
+          this._app = apps[config.databaseURL] = firebase.initializeApp(config, config.databaseURL);
+          // If the API key looks invalid then assume that we're running against Cinderbase rather
+          // than Firebase and override the configuration appropriately.
+          if (config.apiKey && config.apiKey.length < 20) {
+            this._app.database().INTERNAL.forceWebSockets();
+            this._app.auth().useEmulator(config.databaseURL, {disableWarnings: true});
+          }
+        }
+        this._app.database();
+        this._app.auth();
+        this._configError = Fireworker._staticConfigError;
+      } catch (e) {
+        this._configError = e;
+        throw e;
+      }
+    } else if (this._configError) {
+      throw this._configError;
+    }
+    return {
+      exposedFunctionNames: Object.keys(Fireworker._exposed),
+      version: VERSION,
+      firebaseSdkVersion: firebase.SDK_VERSION
+    };
+  }
 
-        updates[segments.concat(childKey$2).join('/')] = newValue[childKey$2];
-      oldValue[childKey$2] = newValue[childKey$2];
+  destroy() {
+    for (const key in this._callbacks) {
+      const callback = this._callbacks[key];
+      if (callback.cancel) callback.cancel();
     }
-  } else {
-    return newValue !== oldValue;
-  }
-};
-
-
-var Fireworker = function Fireworker(port) {
-  this._port = port;
-  this._lastWriteSerial = 0;
-  this._app = undefined;
-  this._cachedAuth = undefined;
-  this._cachedDatabase = undefined;
-  this._lastJsonUser = undefined;
-  this._configError = Fireworker._staticConfigError;
-  this._callbacks = {};
-  this._messages = [];
-  this._flushMessageQueue = this._flushMessageQueue.bind(this);
-  port.onmessage = this._receive.bind(this);
-};
-
-var prototypeAccessors$1 = { _auth: { configurable: true },_database: { configurable: true } };
-
-prototypeAccessors$1._auth.get = function () {
-  if (this._cachedAuth) { return this._cachedAuth; }
-  if (!this._app) { throw new Error('Must provide Firebase configuration data first'); }
-  return this._cachedAuth = this._app.auth();
-};
-
-prototypeAccessors$1._database.get = function () {
-  if (this._cachedDatabase) { return this._cachedDatabase; }
-  if (!this._app) { throw new Error('Must provide Firebase configuration data first'); }
-  if (Fireworker._databaseWrapperCallback) {
-    this._cachedDatabase = Fireworker._databaseWrapperCallback(this._app.database());
-  } else {
-    this._cachedDatabase = this._app.database();
+    this._callbacks = {};
+    this._port.onmessage = null;
+    this._messages = [];
+    const k = fireworkers.indexOf(this);
+    if (k >= 0) fireworkers[k] = null;
   }
-  return this._cachedDatabase;
-};
 
-Fireworker.prototype.init = function init (ref) {
-    var storage = ref.storage;
-    var config = ref.config;
+  enableFirebaseLogging({value}) {
+    firebase.database.enableLogging(value);
+  }
+
+  ping() {
+    // Noop, placeholder for legacy Firetruss clients.
+  }
+
+  bounceConnection() {
+    this._database.goOffline();
+    this._database.goOnline();
+  }
+
+  _receive(event) {
+    Fireworker._firstMessageReceived = true;
+    for (const message of event.data) this._receiveMessage(message);
+  }
 
-  if (storage) { self.localStorage.init(storage); }
-  if (config) {
+  _receiveMessage(message) {
+    let promise;
     try {
-      this._app = apps[config.databaseURL];
-      if (!this._app) {
-        this._app = apps[config.databaseURL] = firebase.initializeApp(config, config.databaseURL);
-        // If the API key looks invalid then assume that we're running against Cinderbase rather
-        // than Firebase and override the configuration appropriately.
-        if (config.apiKey && config.apiKey.length < 20) {
-          this._app.database().INTERNAL.forceWebSockets();
-          this._app.auth().useEmulator(config.databaseURL, {disableWarnings: true});
-        }
+      const fn = this[message.msg];
+      if (typeof fn !== 'function') throw new Error('Unknown message: ' + message.msg);
+      if (message.writeSerial) {
+        this._lastWriteSerial = Math.max(this._lastWriteSerial, message.writeSerial);
       }
-      this._app.database();
-      this._app.auth();
-      this._configError = Fireworker._staticConfigError;
+      promise = Promise.resolve(fn.call(this, message));
     } catch (e) {
-      this._configError = e;
-      throw e;
+      e.immediateFailure = true;
+      promise = Promise.reject(e);
     }
-  } else if (this._configError) {
-    throw this._configError;
-  }
-  return {
-    exposedFunctionNames: Object.keys(Fireworker._exposed),
-    version: VERSION,
-    firebaseSdkVersion: firebase.SDK_VERSION
-  };
-};
-
-Fireworker.prototype.destroy = function destroy () {
-  for (var key in this._callbacks) {
-    var callback = this._callbacks[key];
-    if (callback.cancel) { callback.cancel(); }
-  }
-  this._callbacks = {};
-  this._port.onmessage = null;
-  this._messages = [];
-  var k = fireworkers.indexOf(this);
-  if (k >= 0) { fireworkers[k] = null; }
-};
-
-Fireworker.prototype.enableFirebaseLogging = function enableFirebaseLogging (ref) {
-    var value = ref.value;
-
-  firebase.database.enableLogging(value);
-};
-
-Fireworker.prototype.ping = function ping () {
-  // Noop, placeholder for legacy Firetruss clients.
-};
-
-Fireworker.prototype.bounceConnection = function bounceConnection () {
-  this._database.goOffline();
-  this._database.goOnline();
-};
-
-Fireworker.prototype._receive = function _receive (event) {
-  Fireworker._firstMessageReceived = true;
-  for (var i = 0, list = event.data; i < list.length; i += 1) {
-      var message = list[i];
-
-      this._receiveMessage(message);
+    if (!message.oneWay) {
+      promise.then(result => {
+        this._send({msg: 'resolve', id: message.id, result});
+      }, error => {
+        this._send({msg: 'reject', id: message.id, error: errorToJson(error)});
+      });
     }
-};
+  }
+
+  _send(message) {
+    if (!this._messages.length) Promise.resolve().then(this._flushMessageQueue);
+    this._messages.push(message);
+  }
 
-Fireworker.prototype._receiveMessage = function _receiveMessage (message) {
-    var this$1 = this;
+  _flushMessageQueue() {
+    this._port.postMessage(this._messages);
+    this._messages = [];
+  }
 
-  var promise;
-  try {
-    var fn = this[message.msg];
-    if (typeof fn !== 'function') { throw new Error('Unknown message: ' + message.msg); }
-    if (message.writeSerial) {
-      this._lastWriteSerial = Math.max(this._lastWriteSerial, message.writeSerial);
+  call({name, args}) {
+    try {
+      return Promise.resolve(Fireworker._exposed[name].apply(null, args));
+    } catch (e) {
+      return Promise.reject(e);
     }
-    promise = Promise.resolve(fn.call(this, message));
-  } catch (e) {
-    e.immediateFailure = true;
-    promise = Promise.reject(e);
-  }
-  if (!message.oneWay) {
-    promise.then(function (result) {
-      this$1._send({msg: 'resolve', id: message.id, result: result});
-    }, function (error) {
-      this$1._send({msg: 'reject', id: message.id, error: errorToJson(error)});
-    });
   }
-};
 
-Fireworker.prototype._send = function _send (message) {
-  if (!this._messages.length) { Promise.resolve().then(this._flushMessageQueue); }
-  this._messages.push(message);
-};
+  authWithCustomToken({url, authToken}) {
+    return this._auth.signInWithCustomToken(authToken)
+      .then(result => userToJson(result.user));
+  }
 
-Fireworker.prototype._flushMessageQueue = function _flushMessageQueue () {
-  this._port.postMessage(this._messages);
-  this._messages = [];
-};
+  authAnonymously({url}) {
+    return this._auth.signInAnonymously()
+      .then(result => userToJson(result.user));
+  }
 
-Fireworker.prototype.call = function call (ref) {
-    var name = ref.name;
-    var args = ref.args;
+  unauth({url}) {
+    return this._auth.signOut().catch(e => {
+      // We can ignore the error if the user is signed out anyway, but make sure to notify all
+      // authCallbacks otherwise we end up in a bogus state!
+      if (this._auth.currentUser === null) {
+        for (const callbackId in this._callbacks) {
+          if (!this._callbacks.hasOwnProperty(callbackId)) continue;
+          const callback = this._callbacks[callbackId];
+          if (callback.auth) callback(null);
+        }
+      } else {
+        return Promise.reject(e);
+      }
+    });
+  }
 
-  try {
-    return Promise.resolve(Fireworker._exposed[name].apply(null, args));
-  } catch (e) {
-    return Promise.reject(e);
+  onAuth({url, callbackId}) {
+    const authCallback = this._callbacks[callbackId] = this._onAuthCallback.bind(this, callbackId);
+    authCallback.auth = true;
+    authCallback.cancel = this._auth.onIdTokenChanged(authCallback);
   }
-};
 
-Fireworker.prototype.authWithCustomToken = function authWithCustomToken (ref) {
-    var url = ref.url;
-    var authToken = ref.authToken;
+  _onAuthCallback(callbackId, user) {
+    userToJson(user).then(jsonUser => {
+      if (areEqualValues(this._lastJsonUser, jsonUser)) return;
+      this._lastJsonUser = jsonUser;
+      this._send({msg: 'callback', id: callbackId, args: [jsonUser]});
+    });
+  }
 
-  return this._auth.signInWithCustomToken(authToken)
-    .then(function (result) { return userToJson(result.user); });
-};
+  set({url, value}) {
+    return this._createRef(url).set(value);
+  }
 
-Fireworker.prototype.authAnonymously = function authAnonymously (ref) {
-    var url = ref.url;
+  update({url, value}) {
+    return this._createRef(url).update(value);
+  }
 
-  return this._auth.signInAnonymously()
-    .then(function (result) { return userToJson(result.user); });
-};
+  once({url}) {
+    return this._createRef(url).once('value').then(snapshot => this._snapshotToJson(snapshot));
+  }
 
-Fireworker.prototype.unauth = function unauth (ref) {
-    var this$1 = this;
-    var url = ref.url;
+  on({listenerKey, url, spec, eventType, callbackId, options}) {
+    options = options || {};
+    if (options.sync) options.branch = new Branch();
+    options.cancel = this.off.bind(this, {listenerKey, url, spec, eventType, callbackId});
+    const snapshotCallback = this._callbacks[callbackId] =
+      this._onSnapshotCallback.bind(this, callbackId, options);
+    snapshotCallback.listenerKey = listenerKey;
+    snapshotCallback.eventType = eventType;
+    snapshotCallback.cancel = options.cancel;
+    const cancelCallback = this._onCancelCallback.bind(this, callbackId);
+    this._createRef(url, spec).on(eventType, snapshotCallback, cancelCallback);
+  }
 
-  return this._auth.signOut().catch(function (e) {
-    // We can ignore the error if the user is signed out anyway, but make sure to notify all
-    // authCallbacks otherwise we end up in a bogus state!
-    if (this$1._auth.currentUser === null) {
-      for (var callbackId in this$1._callbacks) {
-        if (!this$1._callbacks.hasOwnProperty(callbackId)) { continue; }
-        var callback = this$1._callbacks[callbackId];
-        if (callback.auth) { callback(null); }
-      }
+  off({listenerKey, url, spec, eventType, callbackId}) {
+    let snapshotCallback;
+    if (callbackId) {
+      // Callback IDs will not be reused across on() calls, so it's safe to just delete it.
+      snapshotCallback = this._callbacks[callbackId];
+      delete this._callbacks[callbackId];
     } else {
-      return Promise.reject(e);
+      for (const key of Object.keys(this._callbacks)) {
+        if (!this._callbacks.hasOwnProperty(key)) continue;
+        const callback = this._callbacks[key];
+        if (callback.listenerKey === listenerKey &&
+            (!eventType || callback.eventType === eventType)) {
+          delete this._callbacks[key];
+        }
+      }
     }
-  });
-};
-
-Fireworker.prototype.onAuth = function onAuth (ref) {
-    var url = ref.url;
-    var callbackId = ref.callbackId;
-
-  var authCallback = this._callbacks[callbackId] = this._onAuthCallback.bind(this, callbackId);
-  authCallback.auth = true;
-  authCallback.cancel = this._auth.onIdTokenChanged(authCallback);
-};
-
-Fireworker.prototype._onAuthCallback = function _onAuthCallback (callbackId, user) {
-    var this$1 = this;
-
-  userToJson(user).then(function (jsonUser) {
-    if (areEqualValues(this$1._lastJsonUser, jsonUser)) { return; }
-    this$1._lastJsonUser = jsonUser;
-    this$1._send({msg: 'callback', id: callbackId, args: [jsonUser]});
-  });
-};
-
-Fireworker.prototype.set = function set (ref) {
-    var url = ref.url;
-    var value = ref.value;
-
-  return this._createRef(url).set(value);
-};
-
-Fireworker.prototype.update = function update (ref) {
-    var url = ref.url;
-    var value = ref.value;
-
-  return this._createRef(url).update(value);
-};
-
-Fireworker.prototype.once = function once (ref) {
-    var this$1 = this;
-    var url = ref.url;
-
-  return this._createRef(url).once('value').then(function (snapshot) { return this$1._snapshotToJson(snapshot); });
-};
-
-Fireworker.prototype.on = function on (ref) {
-    var listenerKey = ref.listenerKey;
-    var url = ref.url;
-    var spec = ref.spec;
-    var eventType = ref.eventType;
-    var callbackId = ref.callbackId;
-    var options = ref.options;
-
-  options = options || {};
-  if (options.sync) { options.branch = new Branch(); }
-  options.cancel = this.off.bind(this, {listenerKey: listenerKey, url: url, spec: spec, eventType: eventType, callbackId: callbackId});
-  var snapshotCallback = this._callbacks[callbackId] =
-    this._onSnapshotCallback.bind(this, callbackId, options);
-  snapshotCallback.listenerKey = listenerKey;
-  snapshotCallback.eventType = eventType;
-  snapshotCallback.cancel = options.cancel;
-  var cancelCallback = this._onCancelCallback.bind(this, callbackId);
-  this._createRef(url, spec).on(eventType, snapshotCallback, cancelCallback);
-};
-
-Fireworker.prototype.off = function off (ref) {
-    var listenerKey = ref.listenerKey;
-    var url = ref.url;
-    var spec = ref.spec;
-    var eventType = ref.eventType;
-    var callbackId = ref.callbackId;
-
-  var snapshotCallback;
-  if (callbackId) {
-    // Callback IDs will not be reused across on() calls, so it's safe to just delete it.
-    snapshotCallback = this._callbacks[callbackId];
-    delete this._callbacks[callbackId];
-  } else {
-    for (var i = 0, list = Object.keys(this._callbacks); i < list.length; i += 1) {
-      var key = list[i];
-
-        if (!this._callbacks.hasOwnProperty(key)) { continue; }
-      var callback = this._callbacks[key];
-      if (callback.listenerKey === listenerKey &&
-          (!eventType || callback.eventType === eventType)) {
-        delete this._callbacks[key];
+    this._createRef(url, spec).off(eventType, snapshotCallback);
+  }
+
+  _onSnapshotCallback(callbackId, options, snapshot) {
+    if (options.sync && options.rest) {
+      const path = decodeURIComponent(
+        snapshot.ref.toString().replace(/.*?:\/\/[^/]*/, '').replace(/\/$/, ''));
+      let value;
+      try {
+        value = normalizeFirebaseValue(snapshot.val());
+      } catch (e) {
+        options.cancel();
+        this._onCancelCallback(callbackId, e);
+        return;
+      }
+      const updates = options.branch.diff(value, path);
+      for (const childPath in updates) {
+        if (!updates.hasOwnProperty(childPath)) continue;
+        this._send({
+          msg: 'callback', id: callbackId,
+          args: [null, {
+            path: childPath, value: updates[childPath], writeSerial: this._lastWriteSerial
+          }]
+        });
+      }
+    } else {
+      try {
+        const snapshotJson = this._snapshotToJson(snapshot);
+        if (options.sync) options.branch.set(snapshotJson.value);
+        this._send({msg: 'callback', id: callbackId, args: [null, snapshotJson]});
+        options.rest = true;
+      } catch (e) {
+        options.cancel();
+        this._onCancelCallback(callbackId, e);
       }
     }
   }
-  this._createRef(url, spec).off(eventType, snapshotCallback);
-};
 
-Fireworker.prototype._onSnapshotCallback = function _onSnapshotCallback (callbackId, options, snapshot) {
-  if (options.sync && options.rest) {
-    var path = decodeURIComponent(
-      snapshot.ref.toString().replace(/.*?:\/\/[^/]*/, '').replace(/\/$/, ''));
-    var value;
-    try {
-      value = normalizeFirebaseValue(snapshot.val());
-    } catch (e) {
-      options.cancel();
-      this._onCancelCallback(callbackId, e);
-      return;
-    }
-    var updates = options.branch.diff(value, path);
-    for (var childPath in updates) {
-      if (!updates.hasOwnProperty(childPath)) { continue; }
-      this._send({
-        msg: 'callback', id: callbackId,
-        args: [null, {
-          path: childPath, value: updates[childPath], writeSerial: this._lastWriteSerial
-        }]
-      });
-    }
-  } else {
-    try {
-      var snapshotJson = this._snapshotToJson(snapshot);
-      if (options.sync) { options.branch.set(snapshotJson.value); }
-      this._send({msg: 'callback', id: callbackId, args: [null, snapshotJson]});
-      options.rest = true;
-    } catch (e$1) {
-      options.cancel();
-      this._onCancelCallback(callbackId, e$1);
-    }
-  }
-};
-
-Fireworker.prototype._onCancelCallback = function _onCancelCallback (callbackId, error) {
-  delete this._callbacks[callbackId];
-  this._send({msg: 'callback', id: callbackId, args: [errorToJson(error)]});
-};
-
-Fireworker.prototype.transaction = function transaction (ref$1) {
-    var this$1 = this;
-    var url = ref$1.url;
-    var oldValue = ref$1.oldValue;
-    var relativeUpdates = ref$1.relativeUpdates;
-
-  var transactionPath = decodeURIComponent(url.replace(/.*?:\/\/[^/]*/, '').replace(/\/$/, ''));
-  var ref = this._createRef(url);
-  var branch = new Branch();
-  var stale, committedValue;
-
-  return ref.transaction(function (value) {
-    committedValue = undefined;
-    value = normalizeFirebaseValue(value);
-    stale = !areEqualNormalFirebaseValues(value, oldValue);
-    if (stale) { value = oldValue; }
-    if (relativeUpdates) {
-      for (var relativePath in relativeUpdates) {
-        if (!relativeUpdates.hasOwnProperty(relativePath)) { continue; }
-        if (relativePath) {
-          var segments = relativePath.split('/');
-          if (value === undefined || value === null) { value = {}; }
-          var object = value;
-          for (var i = 0; i < segments.length - 1; i++) {
-            var key = segments[i];
-            var child = object[key];
-            if (child === undefined || child === null) { child = object[key] = {}; }
-            object = child;
+  _onCancelCallback(callbackId, error) {
+    delete this._callbacks[callbackId];
+    this._send({msg: 'callback', id: callbackId, args: [errorToJson(error)]});
+  }
+
+  transaction({url, oldValue, relativeUpdates}) {
+    const transactionPath = decodeURIComponent(url.replace(/.*?:\/\/[^/]*/, '').replace(/\/$/, ''));
+    const ref = this._createRef(url);
+    const branch = new Branch();
+    let stale, committedValue;
+
+    return ref.transaction(value => {
+      committedValue = undefined;
+      value = normalizeFirebaseValue(value);
+      stale = !areEqualNormalFirebaseValues(value, oldValue);
+      if (stale) value = oldValue;
+      if (relativeUpdates) {
+        for (const relativePath in relativeUpdates) {
+          if (!relativeUpdates.hasOwnProperty(relativePath)) continue;
+          if (relativePath) {
+            const segments = relativePath.split('/');
+            if (value === undefined || value === null) value = {};
+            let object = value;
+            for (let i = 0; i < segments.length - 1; i++) {
+              const key = segments[i];
+              let child = object[key];
+              if (child === undefined || child === null) child = object[key] = {};
+              object = child;
+            }
+            object[segments[segments.length - 1]] = relativeUpdates[relativePath];
+          } else {
+            value = relativeUpdates[relativePath];
           }
-          object[segments[segments.length - 1]] = relativeUpdates[relativePath];
-        } else {
-          value = relativeUpdates[relativePath];
         }
       }
-    }
-    branch.set(value);
-    if (!stale) {
-      committedValue = value;
-      return value;
-    }
-  }).then(function (result) {
-    var snapshots = [];
-    var updates = branch.diff(normalizeFirebaseValue(result.snapshot.val()), transactionPath);
-    for (var path in updates) {
-      if (!updates.hasOwnProperty(path)) { continue; }
-      snapshots.push({
-        path: path, value: updates[path], writeSerial: result.writeSerial || this$1._lastWriteSerial
-      });
-    }
-    return {committed: !stale, snapshots: snapshots};
-  }, function (error) {
-    if (error.message === 'set' || error.message === 'disconnect') {
-      return ref.once('value').then(function (snapshot) {
-        return {committed: false, snapshots: [snapshot], writeSerial: this$1._lastWriteSerial};
-      });
-    }
-    error.committedValue = committedValue;
-    return Promise.reject(error);
-  });
-};
-
-Fireworker.prototype._snapshotToJson = function _snapshotToJson (snapshot) {
-  var path =
-    decodeURIComponent(snapshot.ref.toString().replace(/.*?:\/\/[^/]*/, '').replace(/\/$/, ''));
-  return {
-    path: path, value: normalizeFirebaseValue(snapshot.val()), writeSerial: this._lastWriteSerial
-  };
-};
-
-Fireworker.prototype.onDisconnect = function onDisconnect (ref) {
-    var url = ref.url;
-    var method = ref.method;
-    var value = ref.value;
-
-  var onDisconnect = this._createRef(url).onDisconnect();
-  return onDisconnect[method](value);
-};
-
-Fireworker.prototype._createRef = function _createRef (url, spec) {
-  if (!this._app) { throw new Error('Must provide Firebase configuration data first'); }
-  try {
-    var ref = this._database.refFromURL(url);
-    if (spec) {
-      switch (spec.by) {
-        case '$key': ref = ref.orderByKey(); break;
-        case '$value': ref = ref.orderByValue(); break;
-        default: ref = ref.orderByChild(spec.by); break;
+      branch.set(value);
+      if (!stale) {
+        committedValue = value;
+        return value;
       }
-      if (spec.at !== undefined) { ref = ref.equalTo(spec.at); }
-      else if (spec.from !== undefined) { ref = ref.startAt(spec.from); }
-      else if (spec.to !== undefined) { ref = ref.endAt(spec.to); }
-      if (spec.first !== undefined) { ref = ref.limitToFirst(spec.first); }
-      else if (spec.last !== undefined) { ref = ref.limitToLast(spec.last); }
-    }
-    return ref;
-  } catch (e) {
-    e.extra = {url: url, spec: spec};
-    throw e;
+    }).then(result => {
+      const snapshots = [];
+      const updates = branch.diff(normalizeFirebaseValue(result.snapshot.val()), transactionPath);
+      for (const path in updates) {
+        if (!updates.hasOwnProperty(path)) continue;
+        snapshots.push({
+          path, value: updates[path], writeSerial: result.writeSerial || this._lastWriteSerial
+        });
+      }
+      return {committed: !stale, snapshots};
+    }, error => {
+      if (error.message === 'set' || error.message === 'disconnect') {
+        return ref.once('value').then(snapshot => {
+          return {committed: false, snapshots: [snapshot], writeSerial: this._lastWriteSerial};
+        });
+      }
+      error.committedValue = committedValue;
+      return Promise.reject(error);
+    });
   }
-};
 
-Fireworker.expose = function expose (fn, name) {
-  name = name || fn.name;
-  if (!name) {
-    Fireworker._signalStaticConfigError(
-      new Error(("Cannot expose a function with no name: " + fn)));
-  }
-  if (Fireworker._exposed.hasOwnProperty(name)) {
-    Fireworker._signalStaticConfigError(new Error(("Function " + name + "() already exposed")));
-  }
-  if (Fireworker._firstMessageReceived) {
-    Fireworker._signalStaticConfigError(new Error('Too late to expose function, worker in use'));
+  _snapshotToJson(snapshot) {
+    const path =
+      decodeURIComponent(snapshot.ref.toString().replace(/.*?:\/\/[^/]*/, '').replace(/\/$/, ''));
+    return {
+      path, value: normalizeFirebaseValue(snapshot.val()), writeSerial: this._lastWriteSerial
+    };
   }
-  Fireworker._exposed[name] = fn;
-};
 
-Fireworker.setDatabaseWrapperCallback = function setDatabaseWrapperCallback (fn) {
-  if (Fireworker._databaseWrapperCallback) {
-    Fireworker._signalStaticConfigError(new Error('Database wrapper callback already set'));
+  onDisconnect({url, method, value}) {
+    const onDisconnect = this._createRef(url).onDisconnect();
+    return onDisconnect[method](value);
   }
-  if (Fireworker._firstMessageReceived) {
-    Fireworker._signalStaticConfigError(
-      new Error('Too late to set database wrapper callback, worker in use'));
+
+  _createRef(url, spec) {
+    if (!this._app) throw new Error('Must provide Firebase configuration data first');
+    try {
+      let ref = this._database.refFromURL(url);
+      if (spec) {
+        switch (spec.by) {
+          case '$key': ref = ref.orderByKey(); break;
+          case '$value': ref = ref.orderByValue(); break;
+          default: ref = ref.orderByChild(spec.by); break;
+        }
+        if (spec.at !== undefined) ref = ref.equalTo(spec.at);
+        else if (spec.from !== undefined) ref = ref.startAt(spec.from);
+        else if (spec.to !== undefined) ref = ref.endAt(spec.to);
+        if (spec.first !== undefined) ref = ref.limitToFirst(spec.first);
+        else if (spec.last !== undefined) ref = ref.limitToLast(spec.last);
+      }
+      return ref;
+    } catch (e) {
+      e.extra = {url, spec};
+      throw e;
+    }
   }
-  Fireworker._databaseWrapperCallback = fn;
-};
 
-Fireworker._signalStaticConfigError = function _signalStaticConfigError (error) {
-  if (!Fireworker._staticConfigError) { Fireworker._staticConfigError = error; }
-  for (var i = 0, list = fireworkers; i < list.length; i += 1) {
-    var fireworker = list[i];
+  static expose(fn, name) {
+    name = name || fn.name;
+    if (!name) {
+      Fireworker._signalStaticConfigError(
+        new Error(`Cannot expose a function with no name: ${fn}`));
+    }
+    if (Fireworker._exposed.hasOwnProperty(name)) {
+      Fireworker._signalStaticConfigError(new Error(`Function ${name}() already exposed`));
+    }
+    if (Fireworker._firstMessageReceived) {
+      Fireworker._signalStaticConfigError(new Error('Too late to expose function, worker in use'));
+    }
+    Fireworker._exposed[name] = fn;
+  }
 
-      if (fireworker && !fireworker._configError) { fireworker._configError = error; }
+  static setDatabaseWrapperCallback(fn) {
+    if (Fireworker._databaseWrapperCallback) {
+      Fireworker._signalStaticConfigError(new Error('Database wrapper callback already set'));
+    }
+    if (Fireworker._firstMessageReceived) {
+      Fireworker._signalStaticConfigError(
+        new Error('Too late to set database wrapper callback, worker in use'));
+    }
+    Fireworker._databaseWrapperCallback = fn;
   }
-  throw error;
-};
 
-Object.defineProperties( Fireworker.prototype, prototypeAccessors$1 );
+  static _signalStaticConfigError(error) {
+    if (!Fireworker._staticConfigError) Fireworker._staticConfigError = error;
+    for (const fireworker of fireworkers) {
+      if (fireworker && !fireworker._configError) fireworker._configError = error;
+    }
+    throw error;
+  }
+}
 
 Fireworker._exposed = {};
 Fireworker._firstMessageReceived = false;
@@ -599,11 +529,9 @@ Fireworker._databaseWrapperCallback = undefined;
 Fireworker._staticConfigError = undefined;
 
 function errorToJson(error) {
-  var json = {name: error.name, message: error.message};
-  var propertyNames = Object.getOwnPropertyNames(error);
-  for (var i = 0, list = propertyNames; i < list.length; i += 1) {
-    var propertyName = list[i];
-
+  const json = {name: error.name, message: error.message};
+  const propertyNames = Object.getOwnPropertyNames(error);
+  for (const propertyName of propertyNames) {
     json[propertyName] = error[propertyName];
   }
   return json;
@@ -611,27 +539,27 @@ function errorToJson(error) {
 
 function normalizeFirebaseValue(value) {
   if (Array.isArray(value)) {
-    var normalValue = {};
-    for (var i = 0; i < value.length; i++) {
-      var item = value[i];
-      if (item === undefined || item === null) { continue; }
+    const normalValue = {};
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      if (item === undefined || item === null) continue;
       normalValue[i] = normalizeFirebaseValue(item);
     }
     return normalValue;
   }
   if (value instanceof Object) {
-    for (var key in value) {
-      if (value.hasOwnProperty(key)) { value[key] = normalizeFirebaseValue(value[key]); }
+    for (const key in value) {
+      if (value.hasOwnProperty(key)) value[key] = normalizeFirebaseValue(value[key]);
     }
   }
   return value;
 }
 
 function userToJson(user) {
-  if (!user) { return Promise.resolve(user); }
-  var json = user.toJSON();
+  if (!user) return Promise.resolve(user);
+  const json = user.toJSON();
   delete json.stsTokenManager;
-  return user.getIdTokenResult().then(function (result) {
+  return user.getIdTokenResult().then(result => {
     delete result.claims.exp;
     delete result.claims.iat;
     json.claims = result.claims;
@@ -641,37 +569,37 @@ function userToJson(user) {
 
 
 function areEqualNormalFirebaseValues(a, b) {
-  if (a === b) { return true; }
-  if ((a === null || a === undefined) && (b === null || b === undefined)) { return true; }
-  if (a === null || b === null) { return false; }
-  if (!(typeof a === 'object' && typeof b === 'object')) { return false; }
-  for (var key in a) {
-    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) { return false; }
-    if (!areEqualNormalFirebaseValues(a[key], b[key])) { return false; }
+  if (a === b) return true;
+  if ((a === null || a === undefined) && (b === null || b === undefined)) return true;
+  if (a === null || b === null) return false;
+  if (!(typeof a === 'object' && typeof b === 'object')) return false;
+  for (const key in a) {
+    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) return false;
+    if (!areEqualNormalFirebaseValues(a[key], b[key])) return false;
   }
-  for (var key$1 in b) {
-    if (!a.hasOwnProperty(key$1) || !b.hasOwnProperty(key$1)) { return false; }
+  for (const key in b) {
+    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) return false;
   }
   return true;
 }
 
 function areEqualValues(a, b) {
-  if (a === b) { return true; }
-  if (a === null && b === null || a === undefined && b === undefined) { return true; }
-  if (a === null || b === null || a === undefined || b === undefined) { return false; }
-  if (!(typeof a === 'object' && typeof b === 'object')) { return false; }
-  for (var key in a) {
-    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) { return false; }
-    if (!areEqualValues(a[key], b[key])) { return false; }
+  if (a === b) return true;
+  if (a === null && b === null || a === undefined && b === undefined) return true;
+  if (a === null || b === null || a === undefined || b === undefined) return false;
+  if (!(typeof a === 'object' && typeof b === 'object')) return false;
+  for (const key in a) {
+    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) return false;
+    if (!areEqualValues(a[key], b[key])) return false;
   }
-  for (var key$1 in b) {
-    if (!a.hasOwnProperty(key$1) || !b.hasOwnProperty(key$1)) { return false; }
+  for (const key in b) {
+    if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) return false;
   }
   if (Array.isArray(a) || Array.isArray(b)) {
-    if (!Array.isArray(a) || !Array.isArray(b)) { return false; }
-    if (a.length !== b.length) { return false; }
-    for (var i = 0; i < a.length; i++) {
-      if (!areEqualValues(a[i], b[i])) { return false; }
+    if (!Array.isArray(a) || !Array.isArray(b)) return false;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!areEqualValues(a[i], b[i])) return false;
     }
   }
   return true;
@@ -691,6 +619,6 @@ function acceptConnections() {
 self.window = self;
 acceptConnections();
 
-export default Fireworker;
+export { Fireworker as default };
 
 //# sourceMappingURL=worker.es2015.js.map